Ce cours initie aux bases de la programmation en utilisant le langage Java : variables, boucles, fonctions, ... Il ne présuppose pas de connaissance préalable. Les aspects plus avancés (programmation orientée objet) sont donnés dans un cours suivant, «Introduction à la programmation orientée objet (en Java)». Il s'appuie sur de nombreux éléments pédagogiques : vidéos sous-titrées, quizz dans et hors vidéos, exercices, devoirs notés automatiquement, notes de cours.
Puissance 4 : méthode joue 1ère version
Loading...
En provenance du cours de École Polytechnique Fédérale de Lausanne
Initiation à la programmation (en Java)
237 notes
À partir de la leçon
Etude de cas
Nous voulons terminer notre cours avec une étude de cas, la création d'un jeu de « Puissance 4 », nous permettant de revoir tous les concepts abordés au long du cours.
Rencontrer les enseignants
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
Jamila SamDr
School of Computer and Communication Sciences
Continuons la programmation de notre jeu puissance 4.
Dans les séquences vidéos précédentes,
vous avez vu respectivement quelles sont les structures de données que nous vous
proposons d'utiliser pour représenter ce jeu, représenter les couleurs des joueurs.
Et deux fonctionnalités de base que sont
l'initialisation de la grille et son affichage.
Intéressons-nous maintenant au fait même de jouer.
De quoi avons-nous besoin?
Pour cela, il faut pouvoir demander au joueur l'endroit où il veut jouer.
Il faut pouvoir valider son coup.
Valider aussi bien du point de vue de la réponse que du point de vue donc des
structures de données.
C'est-à-dire si le coup est correct, rendre les structures valides,
mettre le pion effectivement dans la grille.
Puis ensuite, il faut tour à tour donc demander à l'autre joueur
de jouer un coup, puis revenir donc alterner entre les deux joueurs.
Et puis enfin, décider donc si la partie se termine,
soit si un des deux joueurs a gagné ou si la grille est pleine.
Dans cette séquence vidéo-ci, nous allons nous intéresser au second point.
C'est-à-dire donc,
recevoir une colonne d'un joueur et vérifier si elle est correcte.
Et puis donc, mettre à jour le jeu en fonction du coup joué.
Nous sommes donc ici au clair
sur ce que veut faire la méthode que l'on veut implémenter.
Donnons-lui un nom.
Pour cela, on va l'appeler donc la méthode joue().
Regardons maintenant comment on va la programmer.
Commençons pour cela par son entête.
Donc, pour avoir une idée de son entête,
on va se demander comment on appellerait la méthode joue() depuis le programme.
Et donc par exemple, on ferait de jouer sur la grille évidemment,
à une certaine colonne, par exemple 3.
Donc ici, on est dans le programme et donc
les positions vont correspondre aux positions Java.
Donc, la numérotation commence ici en 0.
Et la colonne 3 serait donc ici.
Et puis, bien sûr il faut préciser donc la couleur du joueur.
Est-ce que c'est un joueur rouge ou est-ce que c'est un joueur jaune?
Donc, voilà typiquement un appel que l'on pourrait faire.
A ce moment-là, cela donnerait la situation suivante.
En colonne 3, le joueur met un pion.
Donc, on aurait un pion rouge qui viendrait se mettre ici.
Puis, on aurait donc après typiquement des appels, où on aurait un pion par exemple
jaune qui viendrait se mettre en colonne numérotée 2, donc en troisième colonne.
Et puis, un joueur rouge qui rejoue dans la même colonne numéro 3,
donc dans la quatrième colonne, ce qui correspond à cette situation-ci.
Voilà, donc on est maintenant à peu près assez au clair pour pouvoir écrire donc
l'entête de notre méthode joue().
Donc, joue() va prendre comme premier paramètre la grille.
Donc, on avait dit que c'était un tableau à deux dimensions d'entiers.
Puis ensuite, on va prendre une position qui indiquera la colonne.
Donc ici, de nouveau aussi un entier.
Et enfin, on avait décidé de coder les couleurs par des entiers,
donc on va prendre ici comme troisième argument la couleur.
Donc, voilà donc pour l'entête de la méthode joue().
Maintenant, en ce qui concerne sa valeur de retour.
Donc, on va commencer ici par le mot-clé bien sûr statique.
Mais quel est son type de retour?
Donc, le type de retour ici, comme on n'a pas écrit z = joue() quelque chose,
on a simplement fait des appels ici directement à joue(),
cela veut dire que la méthode joue() ne renvoie rien.
Et donc, évidemment son type de retour va ici être void.
Ce qui termine donc l'écriture de son entête et nous permet maintenant
de passer à la définition, au corps de cette méthode.
Donc, pour cela commençons par nous demander ce que l'on veut vraiment faire
si par exemple on a un coup valide que le joueur joue en colonne 3.
Et imaginons donc le cas général,
où on avait par exemple déjà des pions dans la colonne 3.
Et le joueur donc va rejouer un pion ici dans la colonne 3.
Donc, qu'est-ce qu'il faut qu'on fasse?
Eh bien, pour cela, le pion va arriver sur,
ici la première case vide dans la même colonne.
Alors, première, depuis où?
Première depuis le bas.
Donc, l'algorithme va devoir rechercher depuis le bas, la première position vide.
Les lignes sont numérotées donc depuis ici 0 jusqu'à la taille de la grille moins 1.
Je vous rappelle qu'un tableau est numéroté depuis
0 jusqu'à la taille moins 1.
Et donc, ce qu'on va faire, c'est qu'on va commencer par faire une variable ici
qu'on va appeler de façon très originale ligne,
qui va partir donc de la taille de la grille moins 1.
Et puis comme cela, remonter de un en un, jusqu'à trouver une place vide.
Reste maintenant plus qu'à l'écrire.
On commence pour cela par mettre un commentaire qui explique ce
que l'on veut faire.
Donc, on parcourt la colonne en partant du bas jusqu'à trouver une case vide.
C'est donc pour cela qu'on va déclarer une variable pour le parcours,
appelons-la donc ligne.
Et on va l'initialiser à la dernière position du tableau de ligne,
c'est-à-dire par grille.length- 1.
Donc, elle part d'ici, puis donc tant que,
on va remonter, tant que on n'a pas trouvé de case vide, donc tant que
la grille à la position de la ligne et de la colonne que l'on veut n'est pas vide.
On avait donc pour cela défini la valeur vide,
qu'on va pouvoir ici bien sûr réutiliser.
Donc, tant que cette colonne n'est pas vide, on va remonter de un en un,
donc ce qui s'écrit- - ligne.
Voilà. Et donc à ce stade,
on a trouvé une case vide,
ce qui nous permet donc de la remplir avec la couleur que l'on a reçu.
Donc, pour cela comme d'habitude on écrit d'abord le commentaire.
Puis, on l'écrit simplement donc en Java,
grille [ligne] [colonne] = la couleur que l'on a reçu.
Ce qui termine notre première version donc de la méthode joue().
Et en bon programmeur, maintenant nous allons donc la tester.
Pour cela, on écrit donc une méthode main()
pour pouvoir tester ses fonctionnalités.
Donc, typiquement, on va ici
écrire donc dans une méthode main() la déclaration d'une grille.
On va déclarer une grille ici qui fait donc 6 par 7.
On va, comme vous l'aviez vu dans la séquence vidéo précédente,
initialiser la grille.
On peut commencer par l'afficher.
Et puis, ici on teste directement donc que l'on veut jouer
en troisième colonne avec donc la couleur rouge.
Et puis, on affiche la grille donc ce qui devrait
nous donner un affichage correspondant au fait d'avoir un pion rouge ici.
Puisque je vous rappelle que l'indice que l'on reçoit ici correspond à la
numérotation Java, donc qui correspond, qui commence à 0.
Et donc, l'affichage sera le suivant.
Puis ensuite, on continue à tester en jouant un pion
jaune dans la colonne numéro 2, c'est-à-dire dans la troisième colonne.
Puis, on continue à tester en remettant un pion rouge et en affichant la grille.
En remettant un pion rouge dans la quatrième colonne, la colonne d'indice 3.
Ce qui va donc nous donner,
nous afficher quelque chose qui correspondrait donc à la grille ici.
Maintenant, que se passe-t-il si on continue à
jouer comme ceci dans la colonne 3 et si on rajoute des pions.
Donc ici par exemple des pions rouges, chaque fois dans la colonne 3.
Que va faire notre méthode joue() dans ce cas-là?
Que se passe-t-il donc lorsqu'on joue un pion dans une colonne qui est déjà
toute remplie?
Donc, ce qui va se passer, c'est qu'on initialise comme d'habitude notre
variable ligne à la dernière ligne du tableau.
Puis, donc tant que la ligne à la colonne correspondante n'est pas vide,
donc en l'occurrence ici, jusqu'à ce que la ligne atteigne la position 0,
cette condition va être vraie, on va toujours faire donc- - ligne,
on va remonter comme cela jusqu'à la position 0.
Quand ligne vaut 0, alors qu'est-ce qui se passe?
Eh bien, à ce moment-là, on va avoir cette condition qui est toujours vraie.
La position 0 n'est pas vide et donc on recommence à faire un- - ligne.
Ce qui fait qu'on va comme cela s'enfuir au-delà de notre tableau,
au-delà de notre jeu.
En tout cas, c'est une erreur de conception,
puisqu'on a ici une boucle qui nous fait sortir du tableau.
Donc, il va falloir corriger ceci et arrêter donc
cette boucle while dès que l'on dépasse ici la fin du tableau.
C'est-à-dire dès qu'on atteint l'indice 0.
Il ne reste plus qu'à l'écrire.
Donc, pour cela on va déclarer une variable booléenne qui va tester
si l'on est, si on a rempli complètement une colonne.
Donc, on va l'appeler par exemple pleine typiquement.
Au départ, a priori, la colonne n'est pas, on ne sait pas son statut,
donc a priori la colonne n'est pas supposée être pleine.
Donc, on va déclarer cette variable à false.
Et puis, donc dans la boucle ici qui va remonter pour rechercher une position
vide, on va changer la valeur de la variable booléenne
pleine et la faire passer à vrai dès que l'on atteint la position 0.
Puisque si dans cette boucle ici on arrive jusqu'à la position 0,
c'est que la position 0 n'était pas vide.
Donc, la position 0 n'est pas vide que si le reste de la colonne est pleine.
Donc, continuons à l'écrire.
Si la ligne atteint la position 0,
à ce moment-là, on dit que la colonne est pleine.
Donc, pleine = true.
Dans ce cas-là, en plus, il ne faut pas décrémenter,
il ne faut soustraire 1 à la ligne.
Et donc, on protège notre instruction -- ligne ici par le fait que la ligne n'est
pas nulle, donc on met ici une partie else qui protège cette décrémentation,
ce moins moins ligne, de la condition, enfin du fait que la ligne soit nulle.
Et on corrige maintenant notre boucle, en disant que on continue la
boucle comme toute à l'heure c'est-à-dire à rechercher une position vide,
mais tant que la colonne n'est pas pleine.
Donc ce signe là, je vous rappelle ça veut dire not,
donc tant que la colonne n'est pas pleine et que on n'a pas trouvé une case vide.
On continue tant que les deux conditions sont vraies,
si elle n'est pas pleine et si on n'a pas trouvé une position vide, on remonte.
Si jamais l'une des deux conditions, soit qu'elle est pleine, soit qu'on a trouvé
une case vide était vraie, à ce moment là, la boucle s'arrêterait.
On peut terminer en ajoutant ici une paire de parenthèses pour rendre notre
code plus lisible.
Enfin puisqu'on n'a pas fait au début ce qu'on aurait dû faire,
on commente ce que l'on vient de faire, donc l'idée c'est qu'on parcourt la
colonne en partant du bas jusqu'à trouver une case vide, ou jusqu'en haut.
Enfin il faut ne pas oublier de corriger ici la fin qui n'est pas toujours valide,
puisqu'on ne peut plus maintenant à chaque fois garantir que l'on peut jouer le pion,
puisque si la colonne est pleine, on ne joue pas le pion,
donc on protège bien sûr le fait de jouer ici par la condition,
si la colonne n'est pas pleine, donc if not pleine,
à ce moment là on peut jouer et puis on peut en même temps donner une indication,
donc notre fonction joue maintenant, on va pouvoir donner une indication à
l'extérieur, et donc par exemple renvoyer true pour dire oui, j'ai bien pu jouer,
la fonction joue a pu faire ce que l'on veut, et puis donc sinon par exemple,
retourner fausse pour dire non, la colonne était pleine, le coup n'était pas valide,
et donc je n'ai pas pu passer mon pion à la bonne position.
Enfin comme d'habitude on commente notre code pour expliquer
soit à nous plus tard qui allons le reprendre,
soit à d'autres personnes qui le liraient, ce que fait effectivement notre code.
Donc ici si on n'est pas arrivé jusqu'en haut, if not pleine,
si on n'est pas arrivé jusqu'en haut de la colonne, à ce moment là on peut jouer.
N'oublions pas enfin de corriger notre type de retour, puisque nous avons
maintenant décidé de renvoyer un booléen qui nous indique si le coup était
valide ou non, donc on change bien sûr ici le type de retour de void à un booléen.
Voilà nous pensons donc maintenant avoir corrigé notre première
version de la méthode joue en une version qui est robuste au fait que la colonne
est pleine et donc il faut maintenant tester bien sûr cette méthode,
et pour ça donc on va réécrire une nouvelle fonction main ici,
où on va tester spécifiquement le fait de jouer tout le temps dans la même colonne.
Donc comme d'habitude on déclare la grille, on l'initialise, on l'affiche,
et puis ici on va donc faire une boucle qui va jouer donc dix fois,
dans la même colonne, ici toujours dans la quatrième colonne, la colonne numéro 3.
Donc on fait une boucle qui fait dix itérations,
qui joue dans la colonne 3, Remarquez que donc maintenant la fonction joue,
retournant un booléen qui indique si le coup était valide, on appelle maintenant
joue, en partie gauche d'une expression où on récupère donc la valeur,
on écrit valide égale joue, et puis donc pour voir ce qui se passe et
pour tester notre programme, si le coup n'était pas valide,
alors on va afficher un message qui nous dit qu'il n'était pas possible de jouer,
et dans tous les cas, on affiche la grille pour voir ce qui se passe.
Donc qu'est-ce que ça va nous donner?
J'ai recopié donc ici le main en bas et puis donc toute notre méthode joue,
et donc exécutons le main.
On part à partir de i égal 0, donc i on ne l'utilise pas,
c'est juste pour dire qu'on va faire dix fois la boucle,
donc on part ici de i égal 0, on joue toujours dans la colonne 3 et en rouge,
donc ça va commencer à jouer ici un pion, puis ça va jouer un autre pion etc.
donc tous ces cas là ne sont pas spécialement intéressants,
mais qu'est-ce qui va se passer quand on va jouer le septième coup?
Donc une fois que i vaut 6 ici, on a envie de jouer ici un septième pion
qui va venir, qui devrait, enfin qu'on essaie de faire venir dans la colonne
qui est pleine, et donc quand i vaut 6, on va rentrer à nouveau ici avec donc
la valeur 3 pour la colonne et puis la couleur rouge, et on va donc
ici initialiser la ligne à la taille de la grille moins 1,
on va initialiser le booléen à faux, donc évidemment,
notre pleine est vraie, la grille à la position ligne colonne ici
n'est pas vide, la ligne n'est pas égale à 0, donc on saute ici dans le else et
donc on décrémente ligne qui va donc passer ici.
Ici on a toujours les deux conditions qui sont vérifiées.
Donc on a toujours notre pleine qui est vraie et on a toujours
une grille ici qui n'est pas vide, et donc etc,
on va monter jusqu'à arriver à la position ligne égale 0.
Donc quand ligne égale 0, qu'est-ce qui va se passer?
On arrive donc toujours ici avec une condition vraie,
et la grille de ligne de zéro de colonne n'est pas vide, okay,
donc on rentre, mais cette fois-ci le if ici est vrai, la ligne vaut 0,
et donc à ce moment là, on change et ce qu'on fait,
c'est qu'on met cette fois-ci la valeur de pleine à vrai.
On est donc ici, on a donc terminé le bloc du if, et on revient une nouvelle fois
dans notre boucle, mais cette fois-ci la condition ici not pleine est fausse
et donc le while s'arrête et on termine, ici on sort de la boucle.
Donc ensuite on continue, ici on arrive sur ce if, de nouveau,
not pleine ici n'est pas vraie, donc cette condition ici est fausse,
on saute dans le else, et on retourne false.
Ce qui fait que arrivé ici, quand i vaut 6, valide va valoir faux,
et donc on va ici afficher le message d'erreur,
et donc ce message d'erreur s'affichera pour i égal 6, 7, 8 et 9.
On aura donc quatre fois un affichage du message de l'impossibilité de jouer.
Voilà donc le test qui nous confirme que, on ne peut pas remplir une colonne qui
était déjà pleine, c'est exactement ce que nous voulions.
Voilà je propose de terminer ici cette séquence vidéo et d'aborder dans une
séquence suivante,
des versions alternatives qu'on aurait pu choisir pour implémenter la méthode joue.
Explorer notre catalogue
Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.
Coursera propose un accès universel à la meilleure formation au monde,
en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.
© 2019 Coursera Inc. Tous droits réservés.
