-Bonjour à tous. Dans ce redo de la semaine 3,
on va s'intéresser à comment écrire un simulateur de dé
et à un langage qui serait capable de comprendre
une expression comme "2 D20 + 1 D4".
On peut croiser ce genre de dés dans des jeux de rôle
comme "Donjons et Dragons",
et on aimerait qu'à partir de ces expressions
sorte le résultat d'un lancer de deux dés à 20 faces,
plus le résultat du lancer d'un dé à quatre faces.
Pour ce faire, on va avoir besoin de créer une classe de dé
et une classe qui représenterait une poignée de dés
pour pouvoir faire des opérations entre eux.
Donc, on va ouvrir le System Browser : Tools,
System Browser.
On va créer notre classe "#Die", sous-classe d'objet,
qui va avoir une variable d'instance
qui s'appellera "faces", qui correspondra au nombre de faces,
et on va mettre tout ça dans le package "Dice".
On peut sauvegarder avec Cmd+S.
Notre dé est créé.
On va tout de suite lui mettre une méthode d'initialisation
qu'on va appeler "initialize".
On n'oublie pas d'appeler les méthodes d'initialisation
des super classes avec "super initialize",
et on va dire que le nombre de faces par défaut pour notre dé,
ce sera six.
On sauvegarde ça.
On va tout de suite tester ce comportement,
donc on va créer notre classe de test.
Déjà, je vous enlève les autres packages.
On va créer notre classe de test qu'on va appeler "DieTest",
qui est une sous-classe de "TestCase", cette fois,
mais on ne va pas avoir besoin de l'instance "faces".
On peut sauvegarder, Cmd+S.
Notre classe de test est là, on peut écrire notre test :
"testInitializationIsOk".
Très bien. Dans ce test, que va-t-on faire ?
On va mettre une variable temporaire, "d",
qui va être notre dé qu'on va initialiser.
Et on va vérifier que le nombre de faces de notre dé
vaut bien six.
On voit que la méthode "faces" est écrite en rouge,
parce que c'est un accessoire qu'on n'a pas défini,
mais, comme on l'a vu dans le redo de la semaine dernière,
le débogueur peut s'occuper de ça pour nous.
On sauvegarde. Il y a un message d'erreur, mais ce n'est pas grave.
On va lancer notre test en cliquant sur le bouton.
On clique sur Create.
On va le définir dans la classe "#Die"
sous le protocole "accessing".
OK.
Il nous propose déjà un corps de méthode qui est correct.
C'est un simple guetteur.
On clique sur Proceed, notre test est vert.
Je vais juste rafraîchir. Voilà.
On voit que la méthode est maintenant reconnue.
Notre test est vert.
On va pouvoir définir un lancer de dé.
Pour définir un lancer de dé,
on fait ça via une méthode qui s'appelle "roll".
Le comportement de cette méthode, c'est simplement
de renvoyer le nombre de faces "atRandom".
La méthode "atRandom", qu'est-ce qu'elle fait ?
Je vous montre ça dans un Playground.
Donc, si je fais "6 atRandom"
et que j'imprime le résultat, Cmd+P,
on a trois, cinq, six, six, un.
On peut voir que ça va nous rendre, en résultat,
un entier entre un
et le chiffre sur lequel on va envoyer la méthode "atRandom".
C'est exactement le comportement qu'on souhaite pour notre dé.
On peut sauvegarder ça, Cmd+S.
La méthode "roll" est là, on va maintenant la tester.
Pour la tester, on va écrire "testRolling",
et pour tester un comportement aléatoire,
ce qui est bien, c'est d'utiliser la répétition.
Ce qu'on va faire, c'est "10 timesRepeat",
c'est-à-dire qu'il va répéter 10 fois.
Cette méthode "timesRepeat" attend un bloc de code à exécuter.
Donc, on va exécuter 10 fois,
on va vérifier que le résultat de "d roll"
va être compris entre un et six.
Donc, si je recommence,
on va créer notre variable temporaire "d",
qui va être notre dé,
puis on va répéter avec "timesRepeat" 10 fois
ce bloc de code.
Ce bloc de code va vérifier
que le résultat de "d roll" est bien compris entre un et six.
Ça va le répéter 10 fois.
On sauvegarde.
On lance notre test. Notre test passe.
Si vous n'avez pas confiance
dans le nombre de fois que vous répétez,
vous pensez que c'est aléatoire et que ça peut ne pas marcher,
vous pouvez le faire répéter plus de fois, 100 fois.
On relance, ça fonctionne.
C'est un bon moment pour faire notre premier commit.
Pour le faire, on se dirige
dans Iceberg.
On clique sur Add.
On va l'appeler "Dice".
New repository, OK.
Notre repository est là, on double-clique dessus.
On va ajouter le package "Dice".
Add. Très bien.
On voit que les changements n'ont pas été rajoutés.
Donc, on les rajoute, Commit.
C'est le moment de faire une description qui a du sens.
"Initial commit :
Die initialization and rolling with test."
On a toutes les informations.
Commit.
Votre nom et adresse mail de GitHub.
Voilà, le premier commit de notre package est fait.
C'est très bien, on va pouvoir garder Iceberg sous la main, ici.
Et on va ajouter un nouveau test
qu'on va appeler "testCreationIsOk".
Que va faire ce test ?
On aimerait créer un dé
avec une méthode qui s'appellerait "withFaces: 20".
Et on aimerait que...
"self assert: d Faces equals: 20".
On aimerait définir cette méthode de classe "withFaces"
qui serait capable de prendre un entier
et de nous sortir un dé qui a ce nombre de faces en sortie.
On pourrait aller ici et la faire du côté classe,
mais on va le faire dans le débogueur.
Cmd+S, on lance la création, on lance le test
et on va cliquer sur Create.
On va créer notre méthode "withFaces"
du côté classe de dé, et on va la classer
dans le protocole Instance creation.
OK.
Donc, on a notre corps de méthode.
Cette fois-ci, il ne sait pas comment l'interpréter.
Donc, on va créer une variable temporaire
dans laquelle on va mettre un dé,
et ensuite, on va utiliser notre accesseur setter "faces",
qu'on n'a pas encore défini, mais qui va se définir automatiquement.
On va lui passer "anInteger" et on va rendre "d".
Très bien, on peut sauvegarder ça.
Même si le message "faces:" n'est pas compris,
le débogueur va nous aider à le prendre en compte.
On peut cliquer sur Proceed.
Cette fois-ci, c'est "faces:" qui n'a pas été compris
car on ne l'a pas défini.
On clique sur Create, on va aller dans "Die".
On va faire "accessing". OK.
"faces := amInteger".
C'est parfait, c'est le setter qu'il nous faut.
On peut proceed.
La méthode est rouge, mais si on la reset, elle est verte.
On a maintenant nos trois tests qui sont écrits, qui fonctionnent.
On peut les réexécuter. C'est le moment de sauvegarder.
On retourne dans Iceberg, que j'ai gardé ici.
On va dans Uncommitted changes, on double-clique, Commit.
"Class method for instance creation."
Très bien, on peut commit.
On a notre dé qui est plutôt fonctionnel.
On peut lui passer le nombre de faces qu'on veut,
on peut lui demander de rouler et on a les tests associés.
Voilà la fin de cette première partie.
Dans la deuxième, on va s'intéresser à la poignée de dés
et au comportement qu'on veut qu'elle ait.