"Implantation d'une poignée de dé"
Quentin Ducasse.
-Bonjour à tous. Dans cette partie deux du Redo de la semaine trois,
on va s'intéresser à la poignée de dés
présentée dans la dernière vidéo et à comment l'implémenter.
Déjà, l'API qu'on souhaiterait avoir ressemble à ça.
On va avoir "DieHandle new", donc on va le créer.
On ajoute un dé à notre poignée de dés avec "addDie".
On précise le dé qu'on veut ajouter : "Die withFaces: 6".
On aimerait ajouter plusieurs dés avec la même méthode,
mais peut-être un nombre de faces différent, 10,
et on rend cette instance.
Ce qui se passe ici,
c'est que la première ligne va nous créer une instance,
une poignée de dés, à laquelle on va ajouter un dé à six faces.
Le ";" signifie que le message suivant va être envoyé
au même receveur que le message précédent.
Ça veut dire que "addDie" avec 10 faces
va être envoyé au même receveur que "addDie" avec six faces,
c'est-à-dire l'instance poignée de dés.
Un nouveau ";", cette fois-ci, on rend l'instance.
Donc, on va implémenter tout ça.
On va commencer par implémenter la classe de test,
"#DieHandleTest".
On sauvegarde.
On va se diriger ici : "testCreationAndAddingIsOk".
Ça va être la même chose que ce qu'on a pu faire ici.
Je vais copier ça,
sauf qu'on va avoir besoin d'une variable temporaire
qu'on va appeler "handle".
Voilà, j'ai fixé la tabulation.
Un point.
Et ce qu'on va vérifier, c'est le nombre de dés
dans notre poignée de dés : "handle diceNumber equals: 2".
On n'a rien défini pour l'instant.
Plein de choses ne sont pas comprises,
comme "dieHandle", les méthodes "addDie", "diceNumber".
On va les définir tout à l'heure. On sauvegarde.
La classe n'est pas comprise, on va devoir la définir
avec une variable d'instance qui va être la collection des dés
qui sont compris dans cette poignée de dés.
OK. Des messages ne sont pas compris, mais ce n'est pas grave.
On va créer un autre test : "testCreationWithTheSameDie".
Qu'est-ce qu'on va faire ?
On va créer notre poignée de dés de la même manière, voilà.
Sauf que cette fois-ci, on va tout simplement vérifier
que si on en ajoute un,
ça nous renvoie bien un dé dans la collection,
mais que si on en ajoute un deuxième,
on ne va pas avoir besoin de le réinstancier.
On rajoute un deuxième dé du même type.
On veut que ce soit bien égal à deux.
On sauvegarde.
On a notre test. Si je clique ici, le débogueur va s'ouvrir.
Cette fois-ci, on va le créer à la main, dans la classe.
On va aller ici.
On va déjà créer une méthode "initialize"
qui va appeler "super initialize",
les initialisations de la super classe.
Puis on va initialiser notre variable d'instance "dice"
à une collection "new".
On sauvegarde.
On doit ajouter la méthode pour ajouter un dé :
"addDie: aDie".
Ce qu'on va faire, c'est qu'on va appeler la méthode "add"
sur notre variable d'instance "dice".
On sauvegarde.
Ce qui nous manque, c'est le getter "dice",
qui va renvoyer tout simplement "dice",
et "diceNumber", dont on se sert dans notre test,
qui va renvoyer la taille de "dice", donc "dice size".
On sauvegarde.
On a nos quatre méthodes, et si on relance les tests,
ils sont verts.
C'est un bon moment pour sauvegarder notre repository.
On se dirige dans Iceberg.
Vous pouvez voir que notre repository n'est pas sauvegardé.
Des changements n'ont pas été committés,
donc on va double-cliquer ici, cliquer sur Commit,
et on va dire : "DieHandle first methods with tests".
On peut voir ici tout ce qu'on a rajouté,
nos quatre méthodes, nos deux tests, on commit.
On va ranger Iceberg pour l'instant et on va s'intéresser
aux retours qu'on peut avoir en tant que programmeur
sur les dés ici.
Donc, si je fais Cmd+P, Print, on va avoir "aDie".
Même si c'est intéressant, on peut avoir mieux.
On pourrait indiquer le nombre de faces.
Pour changer le retour qu'on a en faisant Print,
il faut faire appel à la méthode "printOn".
Cette méthode prend une "aStream".
Nous, on aimerait avoir quelque chose qui, à la fin,
nous rende, par exemple, "a Die (faces number)".
Comment fait-on ça ?
On a besoin de "aDie", c'est le retour qu'on a déjà.
On va faire "super printOn: aStream",
et ensuite, on va faire "aStream nextPutall".
On va ajouter, à la suite de ça,
une parenthèse avec le nombre de faces.
Pour concaténer des chaînes de caractères,
c'est la virgule.
"faces print"...
Oups, attendez, on fait ça dans la mauvaise classe.
On est en train de le faire dans "dieHandle".
On va quitter ça.
On va se diriger dans "Die", c'est ici qu'on doit faire le "printOn".
Donc, le nombre de faces, "printString".
Virgule, car on va avoir une autre concaténation,
parenthèse fermante.
Si je sauvegarde ça et que je regarde à quoi ça correspond ici,
on va avoir "a Die (6)", et ici, "a Die (10)".
C'est le comportement qu'on cherchait.
C'est correct.
Maintenant, on va devoir définir
une méthode pour lancer une poignée de dés.
Pour ce faire, on va faire "roll".
On va avoir besoin du résultat,
on va le définir comme une variable temporaire.
On va initialiser à zéro,
puis on va itérer sur la collection de dés.
Pour ce faire, on fait "dice", notre collection de dés, "do:",
et il faut lui passer un bloc de code entre crochets.
Pour itérer sur chaque élément, on utilise ": each",
et on dit ce qu'on va faire : "res := res + each roll".
Et on doit renvoyer le résultat.
Ça, ça va être notre méthode de lancer de dés
pour une poignée de dés.
Dans le test, on va avoir besoin d'obtenir
la valeur maximale qu'on peut avoir, qu'on va appeler "maxValue".
Ce qu'on va faire, c'est qu'on va voir le résultat.
On va itérer, mais sans lancer le dé, on va ajouter le nombre de faces.
Voilà, on a notre méthode "maxValue", notre méthode "roll".
On va définir les tests associés.
On va ici.
"testMaxValue".
On va vérifier avec notre "handle" celui-là, par exemple.
On va mettre "10".
On va vérifier que "maxValue equals"...
On va vérifier que ça vaut bien 16, donc 6 plus 10.
On sauvegarde, on peut le lancer.
Le test est vert, c'est correct. Maintenant, on va tester "roll".
On va utiliser la même poignée de dés
et on va faire "handle roll between:",
on va le faire entre parenthèses.
Comme ça.
Ça va être entre le nombre de dés : "handle diceNumber",
ça, c'est le cas où tous les dés font des 1,
et "and: handle maxValue".
OK. Qu'est-ce que ça va faire ?
On va vérifier que quand on lance notre poignée de dés,
ça va être entre le nombre de dés
dans le cas où tous les dés font des 1
et le cas où tous les dés font respectivement leur chiffre maximum.
Par exemple, celui-ci fait un 10, celui-ci fait un 6.
On sauvegarde.
On lance le test.
Tout est vert, ça va conclure la partie deux du Redo.
Avant de partir, on va sauvegarder ce qu'on a fait dans Iceberg.
Encore une fois, on peut voir "uncommitted changes",
donc on double-clique, on clique sur Commit
et on va faire :
"Roll method implemented for DieHandle,",
et on va dire qu'on a rajouté un "printOn" :
"better print for Die".
Commit.
Voilà, on a tout qui est à jour.
On va se retrouver dans la partie trois
pour les derniers réglages vis-à-vis de ce qu'on voulait faire au départ.
On voulait avoir quelque chose qui fasse "1 D4 + 2 D6",
et pour l'instant, on a ce comportement-là qui est simulé,
mais on ne peut pas l'écrire comme ça.
On va regarder comment on peut faire dans la prochaine vidéo.