use Coat !

No related posts.

Related posts:

1. Jouons avec Moose (ou comment réapprendre le Perl Objet) – partie 1 Cet article inaugure une série consacrée à Moose qui vise...
2. Jouons avec Moose (ou comment réapprendre le Perl Objet) – partie 2 Cet article est la seconde partie d’une série consacrée à...
3. Jouons avec Moose (ou comment réapprendre le Perl Objet) – partie 4 Cet article est la quatrième partie d’une série consacrée à...

Dans notre précédent article, nous avons vu comment utiliser les Moose::Role pour définir des armes. Ajourd’hui nous allons créer une nouvelle classe de héros, les mages, qui vont nous servir à illustrer un concept tout aussi magique : la coercition (coercion en anglais). Cet article est dédicacé à Jérôme Bourgeois qui m’a donné l’idée de faire intervenir un mage dans cette série, merci à lui.

Nous allons aujourd’hui créer la classe « Mage » qui modélisera un nouveau type de héros. Pour commencer, et avant de s’attaquer à la coercition, nous allons spécialiser la classe Mage. Nous voulons qu’un mage soit un héros comme un autre à ceci prêt qu’il est plus chétif (c’est bien connu, les mages sont tous végétariens, ça facilite la circulation des fluides énergétiques, mais ça freine sensiblement le développement de la masse musculaire).

Bref. Un mage est un Héros disions-nous :

package Mage;
use Moose;
extends 'Heros';

Mais un mage est plus faible qu’un héros conventionnel, nous voulons donc altérer sa force et son endurance. Pour cela, Moose nous permet de modifier un attribut hérité en préfixant le nom dudit attribut par un “+” :

has '+force' => (default => 2);
has '+endurance' => (default => 2);

Les attributs force et endurance hérités de la classe Héros (définie dans le permiet article de cette série) vaudront donc 2 pour un Mage, au lieu de 3.

Perl> $merlin = new Mage name => "Merlin"
$Mage1 = Mage=HASH(0x8b082c4);

Perl> $merlin->force
2

Maintenant, nous allons enrichir le mage en le dottant d’un familier (pour nos amis non-rôliste, rapellons que les familiers sont des petites créatures qui accompagnent les mages). Pour cela, nous allons faire intervenir le mécanisme de coercition, en créant un attribut « familier ».

La coercition va nous permettre de donner à l’accesseur de l’attribut familier une chaîne en entrée et celui-ci se chargera de convertir la chaîne en un objet Heros.
Pour cela, il nous faut définir un type de champ, et cela se fera grâce qu module Moose::Util::TypeConstraints :

package Mage;
use Moose;
use Moose::Util::TypeConstraints;

use Heros;
subtype 'Familier'
    => as 'Object'
    => where  {$_->isa('Heros')};

Maintenant nous disposons d’un type d’attribut nommé « Familier » qui cache un objet de la classe « Heros ».
Nous allon à présent définir la coercition qui doit s’opérer lorsqu’un attribut de ce type est modifié avec une chaîne de caractères :

coerce 'Familier'
    => from 'Str'
        => via {new Heros
            name => $_,
            force => 1,
            endurance => 1};

Nous convertissons donc la chaîne donnée en Heros dont le nom est précisément la chaîne fournie. Au passage, comme le familier est une petite créature, nous écrasons les valeurs par défaut du Héros en force et endurance. Le lecteur comprendra ici que nous pourrions définir une classe Familier pour l’occasion.
Maintenant, il nous reste à déclarer l’attribut à proprement parlé :

has 'familier' => (
    is => 'rw',
    isa => 'Familier',
    coerce => 1
);

On note la présence du mot-clef “coerce” ici qui active la coercition. Ce mécanisme étant désactivé par défaut pour éviter les mauvaises surprises.

Bien. Vérifions que tout se comporte comme prévu :

Perl> $merlin->familier('sarkopette')
$Heros1 = Heros=HASH(0x8b2bb8c);

$merlin->familier->force
1

$merlin->familier->name
sarkopette

Le coercition a bien eu lieu, lorsque l’accesseur familier() est utilisé, une instanciation de Heros a lieu, comme par magie.

Related posts:

1. Jouons avec Moose (ou comment réapprendre le Perl Objet) – partie 1 Cet article inaugure une série consacrée à Moose qui vise...
2. Jouons avec Moose (ou comment réapprendre le Perl Objet) – partie 3 Cet article est la troisième partie d’une série consacrée à...
3. Jouons avec Moose (ou comment réapprendre le Perl Objet) – partie 2 Cet article est la seconde partie d’une série consacrée à...

Dans notre précédent article, nous avons vu comment spécialiser une classe en créant la classe Barbare à partir de la classe Heros. Aujourd’hui nous allons découvrir un autre mécanisme important que Moose nous permet de réaliser : l’interfaçage. Aujourd’hui, nous allons jouer avec les Moose::Role.

Moose nous permet de définir des interfaces au moyen de la classe Moose::Role. Nous allons utiliser ce mécanisme pour armer Conan. Maintenant qu’il sait se battre, crier et encaisser des coups, il lui faut une arme ! Regardez-le avec son regard aggard, un barbare à mains nues ça ne ressemble à rien !

Un rôle en Moose est une classe particulière, qui ne peut pas être instanciée et qui spécifie un modèle. D’autres classe – instanciables – pourront implémenter ce rôle et devront par là-même respecter les restrictions de ce dernier.

Nous allons donc créer une rôle « Arme » qui imposera à toutes les armes dignes de ce nom (les classes Moose qui implémenteront le Moose::Role « Arme ») de fournir une méthode degats().

Ensuite nous modifierons la classe Heros pour que chaque Heros (et pas uniquement les barbares) puisse disposer d’une arme.
Commençons par la fin, et modifions la classe Heros (définie dans le premier article de cette série). Nous devons pouvoir prendre en compte la présence d’une arme, il nous faut donc un nouvel attribut pour stocker cet objet :

package Heros;
[...]

has 'arme' => (
    is => 'rw',
    does => 'Arme',
    predicate => 'has_arme'
);

Deux notions nouvelles ici : does, qui nous permet d’éxiger que l’objet contenu dans cet attribut implémente le role « Arme » et predicate qui nous laisse définir le nom d’une méthode dédiée à tester la présence de l’attribut ($heros->has_arme renverra vrai si une arme est définie, faux sinon).

Maintenant, nous voulons que notre arme soit prise en compte lors d’une attaque au cas où le héros en possède une. Nous allons pour cela utiliser la méthode définie dans le prédicat de l’attribut :

package Heros;
[...]

sub attaque
{
    my ($self) = @_;
    my $bonus = 0;
    if ($self->has_arme) {
        $bonus = $self->arme->degats;
    }
    return $self->force + $bonus + int(rand(10) + 1);
}

Bien, on constate que maintenant, l’attaque d’un héros prend en compte les dégâts de l’arme, si celui-ci en possède une. Ces dégâts sont obtenus en appelant la méthode degats() de l’arme. Il nous faut donc être certains que l’objet qui tient rôle d’arme implémente bien une méthode de ce nom. Et c’est là qu’intervient Moose::Role :

package Arme;

use Moose::Role;
requires 'degats';

1;

Tout simplement. Ici nous déclarons un Moose::Role nommé Arme qui spécifie une chose : toutes les armes doivent proposer une méthode degats().

Il ne nous reste plus qu’à créer notre première arme. J’avais pensé commencer avec un gourdin mais quand j’ai vu la tête de Conan, j’ai compris que c’était une mauvaise idée… Hahem. Bref, créons un glaive donc.

package Glaive;
use Moose;
with ('Arme');

sub degats
{
    return 3;
}
1;

Ici, le mot-clef with permet de déclarer que notre classe implémente le role Arme. Cela nous impose donc de proposer une méthode degats (le lecteur pourra s’amuser à reproduire l’exemple sans la méthode en question pour voir ce qui se passe).

Bien, maintenant, tout semble en place. Jouons un peu avec toutes ces nouveautés. Comme nous avons modifié la classe Heros et que Barbare en hérite, nous devons avoir le support des armes avec un Barbare, vérifions cela avec conan :

Perl> my $conan = new Barbare name => 'Conan'
$Barbare1 = Barbare=HASH(0x8ada0a4);

Perl> $conan->has_arme
0

On a bien le prédicat has_arme ajouté par le nouvel attribut arme de la classe Heros. Maintenant, testons la validité de nos propos en essayant de faire une aberration en attribuant un Heros comme arme pour conan (bon d’accord, on pourrait y voir une certaine logique…)

Perl> $conan->arme(new Heros name => 'Bilbon')
Runtime error: Attribute (arme) does not pass the
type constraint (__ANON__) with Heros=HASH(0x8ae87d0)

En effet, dans notre modèle, un Heros n’est pas une arme (du moins pas encore, pauvre Bilbon) et l’attribut arme ne se laisse pas abuser aussi facilement. Conan n’aura qu’à bien se tenir et utiliser un glaive.

Perl> $conan->arme(new Glaive)
$Glaive1 = Glaive=HASH(0x8ada074);

C’est mieux. Les attaques de Conan vont maintenant être augmentées de 3 points grâce au glaive. Laissons le mot de la fin à Conan, fier qu’il est de sa nouvelle acquisition :

Perl> $conan->attaque
Ourgh!
14
Perl> $conan->attaque
Mabangaaa!
16
Perl> $conan->attaque
Yeeeeaaa!
13

Dans notre prochain article, nous découvrirons la puissance de la coercition d’attribut en créant la classe « Mage ».

Related posts:

1. Jouons avec Moose (ou comment réapprendre le Perl Objet) – partie 2 Cet article est la seconde partie d’une série consacrée à...
2. Jouons avec Moose (ou comment réapprendre le Perl Objet) – partie 1 Cet article inaugure une série consacrée à Moose qui vise...
3. Jouons avec Moose (ou comment réapprendre le Perl Objet) – partie 4 Cet article est la quatrième partie d’une série consacrée à...

Dans notre précédent article, nous avons vu comment créer une classe “Heros” et nous avons joué avec Conan et lui attribuant un nom et en le torturant un peu. Nous allons voir dans cet article comment le spécialiser en “Barbare” afin de lui donner plus de relief.

Nous voulons que la classe “Barbare” soit une spécialisation de la classe “Heros” et qu’elle présente les particularités suivantes :

• un Barbare peut posséder une armure
• un Barbare pousse un crie de guerre à chaque attaque

Mais avant tout, il nous faut dire ce qu’est un Barbare, il s’agit d’un Heros :

package Barbare;

use Moose;
extends (qw(Heros));

Le mot-clef extends est exporté par Moose dans notre espace de noms, il permet de déclarer l’héritage d’une classe envers une autre. Ici, vous l’avez compris, “Barbare” hérite de “Heros”. Vérifions de suite que l’héritage a bien eu lieu:

Perl> my $conan = new Barbare name => 'Conan';
$Barbare1 = Barbare=HASH(0x8acb7b0);
Perl> $conan->name
Conan
Perl> $conan->pv
20
Perl>

Nous avons bien les attributs d’un Héros, tout va bien.

Nous voulons qu’un barbare puisse posséder une armure, et ainsi amortir encore davantage les coups qu’il reçoie. Cela se fera en deux étapes : ajouter l’attribut “armure” pour stocker la valeur de ladite protection, et subtilement altérer le comportement de la méthode blessure() héritée de la classe Heros.

has 'armure' => (
    is => 'rw',
    isa => 'Int',
    default => 0
);

Rien de bien compliqué ici, un nouvel attribut. Maintenant, la partie intéressante :

around 'blessure' => sub {
    my $orig = shift;
    my ($self, $degats) = @_;
    if ($self->armure) {
        $degats = $degats - $self->armure;
        $degats = 0 if $degats < 0;
    }
    $self->$orig($degats);
};

Le mot-clef “around” nous permet d’envelopper l’appel d’une méthode (ici “blessure”) afin d’en modifier le comportement pour la classe que nous décrivons. Nous définissons donc une méthode ( => sub {} ) qui reçoit en argument respectivement : la référence vers la méthode originelle ($orig), la référence de l’instance en cours ($self) puis les arguments passés lors de l’appel ($degats). Il nous convient ensuite de faire ce que bon nous semble avec cela.

On constate que la dernière instruction de notre encapsulation est l’appel de la méthode originelle (celle de Heros donc) :
$self->$orig($degats);. Si nous enlevons cette ligne, l’appel de la méthode originelle n’aura tout simplement pas lieu.

Nous avons juste pris soin de modifier $degats dans notre encapsulation, et voilà. Si le barbare dispose d’une armure (if ($self->armure)) les dégâts sont amortis d’autant. Testons cela :

Perl> $conan->pv
20
Perl> $conan->blessure(4)
19
Perl> $conan->armure(1)
1
Perl> $conan->blessure(4)
19

Avec son endurance de 3 et son armure de 1, Conan amortit maintenant totalement les blessures de 4 ! Mais quel homme ce Conan !

Nous allons maintenant doter Conan de cris de guerre, en commençant par l’attribut “cris” qui sera d’un nouveau type : ‘ArrayRef’ :

has 'cris' => (
    is => 'rw',
    isa => 'ArrayRef',
    default => sub {[qw(Yeeeeaaa! Ourgh! Mabangaaa!)]},
);

La seule particularité ici est l’encapsulation de la liste dans une fonction, cela est nécessaire pour le bon fonctionnement des accesseurs.
Maintenant que les cris sont définis (et le barbare pourra en apprendre de nouveaux, car nous déclarons l’attribut en read/write), il nous faut une méthode pour crier :

sub crie
{
    my ($self) = @_;
    return $self->cris->[int(rand(@{$self->cris}))];
}

Voyons-voir si cela se comporte comme prévu :

Perl> $conan->cris
$ARRAY1 = [
            'Yeeeeaaa!',
            'Ourgh!',
            'Mabangaaa!'
          ];
Perl> $conan->crie
Mabangaaa!
Perl> $conan->crie
Ourgh!
Perl>

Il nous reste à venir intercepter l’appel à la méthode “attaque” pour pousser un cri avant que celle-ci s’éxecute ; cela se fera au moyen d’une structure similaire à celle vue ci-dessus avec ‘around’ mais avec un autre corchet : “before” (on dispose évidemment de son pendant “after” également) :

before 'attaque' => sub {
    my ($self) = @_;
    print $self->crie."\n";
};

Maintenant, vérifions que Conan pousse la chansonette à chaque attaque :

Perl> $conan->attaque
Mabangaaa!
11
Perl> $conan->attaque
Ourgh!
12

Conan est désormais un barbare digne de ce nom, et il peut snober les petits héros de pacotille si communs lorsqu’il les croise dans une taverne. Sacré Conan.

Dans notre article suivant, nous utiliserons Moose::Role afin d’ajouter une arme à notre classe Heros. Conan poura donc brandir un glaive, sacré Conan !

Related posts:

1. Jouons avec Moose (ou comment réapprendre le Perl Objet) – partie 3 Cet article est la troisième partie d’une série consacrée à...
2. Jouons avec Moose (ou comment réapprendre le Perl Objet) – partie 1 Cet article inaugure une série consacrée à Moose qui vise...
3. Jouons avec Moose (ou comment réapprendre le Perl Objet) – partie 4 Cet article est la quatrième partie d’une série consacrée à...

Jusqu’à hier, je croyais connaître Perl. Hier j’ai découvert Moose. Il s’agit d’une extension du système objet de Perl. Au début je dois avouer que j’étais scéptique. J’avais tort.

Moose est une extension qui enrichi le système objet de Perl5 d’une façon profonde.

C’est à dire :

• une syntaxe élégante (avec des mot-clef qui ont du sens)
• une meta-classe digne de ce nom (constructeur et accesseurs par défaut)
• un système d’interface
• un système d’héritage propre
• une gestion fine des attributs des objets.

Au lieu de vanter ses mérites en long en large et en travers, je propose à ceux qui en ont envie de me suivre au travers d’un exemple concret : nous allons découvrir ensemble Moose en modélisant Conan le Barbare ! (quoi de plus épique, sans déconner ?).

Notre premier objectif est de disposer d’une classe Heros qui décrive un héros de base.
Pour commencer, ce héros devra avoir un nom :

package Heros;
use Moose;

has 'name' => (
    is => 'ro',
    required => 1,
    isa => 'Str'
);

Avec ces quelques lignes, nous venons de dire beaucoup de choses. Tout d’abord, Heros est un objet Moose, ce qui nous fournit un constructeur par défaut et tout un jeu d’accesseurs évolués. Nous disons également que les objets de la classe Heros ont impérativement un attribut “name” et que cet attribut n’est pas modifiable.

Regardons ce que cela donne:

Perl> $perso = new Heros name => 'Conan'
$Heros1 = Heros=HASH(0x8abe7d8);

Perl> $perso->name
Conan

Perl> $perso->name('Merlin')
Runtime error: Cannot assign a value to a
read-only accessor at (eval 62) line 1

Très bien, tout ça est parfait. Nous assignons un nom lors de l’instanciation, mais ne pouvons pas le modifier par la suite. C’est bien ce que nous avons décrit.

Nous voulons maintenant donner de la vie (et de la mort !) à notre héros, pour cela il nous faut deux nouveaux attributs : un nombre de points de vie et un score en endurance (qui nous permettra d’amortir les dégâts pris lors d’une attaque).

has 'pv' => (
    is => 'rw', required => 1, isa => 'Int',
    default => 20,
);

has 'endurance' => (
    is => 'rw', required => 1, isa => 'Int',
    default => 3
);

Notre personnage aura donc 20 points de vie lors de sa naissance, et amortira 3 points de dégâts lors d’un choc reçu.
C’est très bien, mais il nous faut détecter la mort du personnage lorsque ses points de vie atteindront 0…

Pour cela Moose nous permet d’attacher des déclencheurs (trigger) à des attributs. C’est ce que nous allons faire pour l’attribut “pv” :

has 'pv' => (
    is => 'rw', required => 1, isa => 'Int',
    default => 20,
    trigger => sub {
            my ($self, $pv, @args) = @_;
            $self->meurt if $pv == 0;
        }
);

Maintnant, lorsque les point de vie arrivent à zéro, la méthode meurt() est appelée. Il nous reste donc à la définir :

sub meurt
{
    my ($self) = @_;
    $self->endurance(0);
    print $self->name . " est mort !\n";
}

Très bien, amusons-nous cruellement à tuer Conan maintenant :

Perl> $perso->pv
20
Perl> $perso->pv(0)
Conan est mort !
0
Perl>

C’est bien ce que nous voulons, lorsque les PV sont nul, le personnage meurt. Mais cette façon arbitraire de faire perdre des points de vie au personnage n’est pas très orthodoxe pour les rôlistes que nous sommes. Il nous faut une méthode blessure() qui sera dédiée à encaisser les coups, et ce de la bonne façon (en amortissant les dégâts avec l’endurance) :

sub blessure
{
    my ($self, $degats) = @_;
    $degats = $degats - $self->endurance;
    $degats = 0 if $degats < 0;
    my $pv = $self->pv - $degats;
    $pv = 0 if $pv < 0;
    $self->pv($pv);
}

Très bien, nous pouvons désormais blesser Conan en prenant en compte son endurance :

Perl> $perso->pv
20
Perl> $perso->blessure(4)
19
Perl>

Pour terminer (et surtout pour être honnète vis à vis de Conan), il nous faut donner à notre héros la possibilité de causer des dégâts. Pour cela il a besoin naturellement d’un score en force et d’une méthode pour frapper.

has 'force' => (
    is => 'rw', required => 1, isa => 'Int',
    default => 3
);

sub attaque
{
    my ($self) = @_;
    return $self->force + int(rand(10) + 1);
}

Voici donc une attaque qui prend la force et y ajoute un score compris entre 1 et 10 :

Perl> $perso->attaque
7
Perl> $perso->attaque
9
Perl>

Voilà, notre héros est désormais armé pour arpenter les chemins de terre et y pourfendre bêtes et immondices.

Dans notre prochain article nous verrons comment étendre la classe “Heros” en classe “Barbare”, afin de spécialiser Conan, et lui donner encore plus de prestence (il va être content le Conan).

Related posts:

1. Jouons avec Moose (ou comment réapprendre le Perl Objet) – partie 2 Cet article est la seconde partie d’une série consacrée à...
2. Jouons avec Moose (ou comment réapprendre le Perl Objet) – partie 3 Cet article est la troisième partie d’une série consacrée à...
3. Jouons avec Moose (ou comment réapprendre le Perl Objet) – partie 4 Cet article est la quatrième partie d’une série consacrée à...