1 Étude de cas : Jeu d’échecs

1.1 Version 0

Diagramme de classes de l’atelier de l’étape précédente

Figure 01 : Le diagramme de classe initialise.

La Classe Echiquier
La classe Échiquier caractérisée par un nombre de lignes, un nombre de colonnes et un tableau
des cases de deux dimensions (Figure 01).
Chaque cellule peut avoir les valeurs suivantes
 -1 : obstacle
 0 : vide
 2 : position trésor

1
La classe Echiquier admet les comportements suivants :
 void InitialerEchiquier(): Appelé à chaque nouveau lancement de jeu. Elle permet
d’initialiser les positions d’obstacles et la position trésor.
 int etatCellule (i, j) : Cette méthode permet de retourner l’état de la cellule (une valeur
entre -1 et 2).
 boolean estCelluleTresor(i, j) : Cette méthode permet de retourner une valeur boolean
qui indique si cette cellule indice i, j est cellule but.
 boolean EstCelluleVide(i, j) : Cette méthode permet de retourner la valeur vraie si la
cellule indice i, j est vide.
 boolean estFin() permet de retourner true, si la position du roi est égale à la position du
trésor et false sinon.
 public ArrayList deplacementRealisable(ArrayList tabProRoi): Cette méthode
permet de filtrer la liste de déplacement reçu en paramètre et retourne la liste finale de
déplacement réalisable.

Tester cette classe avec la classe TestEchiquier (Ajouter les méthodes nécessaires)

La classe Roi
La classe Roi caractérisée par sa position son nombre de mouvements et la liste de mouvements.
Cette classe admet les comportements suivants :
 void deplacer(i, j) choisir un déplacement du Roi selon une méthode de déplacement
(saisie du clavier, utiliser la méthode aléatoire, utiliser une méthode intelligente).
Chaque déplacement doit être vérifié par l’échiquier.

2
  ArrayList deplacementPossible() permet de retourner sous forme de liste tous les
déplacements possibles. Pour le roi, il existe huit déplacements possibles.
 Case choisirDeplacement(), cette méthode accepte en paramètre une liste de
déplacement réalisables (filtre par l’échiquier) et retourne un seul déplacement. Le choix
de déplacement peut être aléatoire.
 void affiche() ; permet de retourner la position du roi et tous les déplacements réalisés.

1.2 Description

Le jeu d’échecs contient 6 types de pièces Roi, Dame, Tour, Cavalier, Fou, Pion. Chaque pièce
est caractérisée par un identifiant, un libellé et une couleur.

Figure 03 : Les pièces

Les pièces blanches
Pièce Id Libelle
Roi 1 RB
Dame 2 DB
Tour 3 TB
Cavalier 4 CB
Fou 5 FB
Pion 6 PB

Les pièces noires

3
 Pièce id Libelle
Roi 11 RN
Dame 12 DN
Tour 13 TN
Cavalier 14 CN
Fou 15 FN
Pion 16 PN

Ces pièces admettent les mêmes caractéristiques et aussi les mêmes comportements sauf le
comportement déplacements possibles.
Dans le chapitre précèdent, on a développé trois classes : Case, Roi et Echiquier pour la
navigation d’un roi dans un échiquier plein d’obstacles. Maintenant, en jeu d’échecs il n’existe
plus la notion d’obstacles.
Dans le paragraphe suivant on découvrira les déplacements de chaque pièce du jeu d’échecs.

Le Roi :
Le roi se déplace d'une seule case dans n'importe quelle
direction

La Tour :
La tour se déplace en suivant les colonnes ou les
rangées

Le Fou :
Le fou se déplace en suivant les diagonales, on
remarque qu'il se déplace toujours sur les cases d'une
même couleur

4
 La Dame :
La dame cumule les déplacements de la tour et du fou,
cela en fait la pièce la plus puissante du jeu.

Le pion :
Le pion se déplace droit devant lui d'une seule case à
chaque coup et sans jamais pouvoir reculer. Cependant,
lors de son tout premier déplacement, il peut avancer
d'une ou de deux cases à la fois

Le cavalier :
Les cases accessibles au cavalier forment une rosace

Donc , on a besoin d’appliquer le concept d’héritage pour les six types de pièces qui admet une
super classe nommée Piece. Cette classe Piece regroupe tous les champs et toutes les méthodes
communes de ces six types de pièces.

Question 01 :

Ajouter les méthodes toString et equals dans la classe Case et porter les modifications
nécessaires.

Question 02 :

Écrire les méthodes toString et equals de la classe Roi hérite de la classe Object

Question 03 :

La classe Roi et Tour, Fou, Dame, Cavalier et Pion sont hérités de la super classe Piece.

5
  Dans la classe Piece :
 Ajouter les attributs,
 Les constructeurs,
 Les méthodes déjà développées dans la classe roi.
 Redéfinir la méthode equals et toString
 Réaliser les modifications nécessaires dans la classe Roi
 Écrire les autres classes.

Figure 05 : Diagramme de classe de Piece

Question 04 :

Dans la classe Test :

 Créer une instance de chaque sous classe de la classe Pièce.
 Afficher le nombre de déplacements possibles de chaque pièce.
Déroulement d’une partie

6
Une partie de jeu d’échecs se déroule entre deux joueurs. Le joueur est caractérisé par un
identifiant, un nom, un prénom et un score. Le joueur des pièces blanches commence toujours
la partie. Chaque joueur joue un coup à tour de rôle.
Figure 06 : La classe Joueur
Cette classe possède les méthodes suivantes :
 incrementeScore qui permet d’incrémenter le score du joueur gagnant.

 decrementerJoueur qui permet de décrémenter le score du joueur perdant.

 alimentationJoueur qui permet de retourner une liste de joueur.
Un coup est caractérisé par l’identifiant de pièce et la position initiale et la position finale. Un
coup peut être dans l’un des états suivants :
Figure 07 : La classe Coup

Figure 08 : L’organigramme de l’état d’un coup

 Syntaxe incorrecte  objet null

 Syntaxe correcte :
o Coup non réalisable

7
 non oui
Synthaxe

Null non oui

Réalisable

Position debut incorrecte (-1)

non oui
Position finale
Position fin incorrecte (-2)
Occupée

Position finale est vide (1)

Par une pièce de même couleur (-3)

Par une pièce de l’autre couleur (2)

 Position début incorrecte (-1)
 Position fin incorrecte (-2)
o Coup réalisable
 Position finale est vide (1)
 Position finale est occupé
 Par une pièce de même couleur (-3)
 Par une pièce de l’autre couleur (2)
La classe Partie est caractérisée par :

8
 Figure 09 : La classe Partie
 Deux attributs du type joueur, joueur blanc et joueur noir.
 Le score de la partie, initialisé à zéro prend la valeur 1 si le joueur blanc gagne et prend
la valeur -1 si le joueur noir gagne sinon prend la valeur zéro correspondant à une partie
nulle.
 Le tour de rôle. Ce dernier prend l’identifiant du joueur actif.
 Deux listes de coups de chaque joueur.
Cette classe possède deux méthodes
 La méthode modifieRole permet de modifier l’attribut rôle.
 La méthode insertCoup qui permet d’insérer le coup soit dans la liste du joueur blanc
ou dans la liste du joueur noir.

Question 05 :

 Développer la classe Joueur

Question 06 :

 Développer la classe Coup.

 Développer la classe Partie

Question 07 :

Modifier la classe Echiquier caractérisée par l’environnement, une pièce blanche et une pièce
noire.

9
 Figure 10 : La classe Echiquier

Question 08 :

Développer une autre classe JeuEchecs qui comporte le scénario suivant :

Créer une instance de la classe partie comportant deux objets du type joueur.
 Créer une instance de la classe Echiquier.
 Créer deux pièces : une pièce blanche et une pièce noire.
 Insérer les deux pièces dans l’instance échiquier.
 Répéter le traitement suivant plusieurs fois.
 La pièce du joueur courant propose une liste de déplacements.
 L’échiquier filtre les déplacements proposés.
 La pièce choisit automatiquement un déplacement.
 La pièce se déplace.
 L’échiquier met à jour son état.
 Enregistrer le coup du joueur
 Modifier le tour de rôle.
La partie se termine si la pièce d’un joueur prend la case occupée par celle de l’autre joueur
(Les deux pièces dans la même position).

10
 Menu
1. Lancer la navigation
2. Quitter
1
Lancement de la partie
Joueur blanc: Ali 02 Salah 02 identifiant: 2 Score: 801
Joueur noir: Ali 04 Salah 04 identifiant: 4 Score: 199
+++ La rôle du joueur: 2
DB | DN | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |

NB.dep.Possible: 60
NB.dep.Realisable: 22
Le coup sélectionné : Coup [idPiece=2, posDepart=(0,0),
posFin=(7,0)]
-- | DN | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
DB | -- | -- | -- | -- | -- | -- | -- |
L’interface du lancement d’une partie de la question

+++ La rôle du joueur: 4

DN | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | DB | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |

NB.dep.Possible: 60
NB.dep.Realisable: 22
Le coup sélectionné : Coup [idPiece=12, posDepart=(0,0),
posFin=(5,5)]
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | DN | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |
-- | -- | -- | -- | -- | -- | -- | -- |

11
 La partie entre le joueur Ali 02 et le joueur Ali 04 est terminé
Partie entre Joueur: Ali 02 Salah 02 identifiant: 2 Score: 799 et
Joueur: Ali 04 Salah 04 identifiant: 4 Score: 201
Ali 04 Salah 04 identifiant: 4 Score: 201 est gagnant
Fin de la partie
***** ***** ***** ***** ***** *****
1. Lancer la navigation
2. Quitter
L’interface de la fin d’une partie de la question avec l’incrémentation de score du joueur
gagnant et la décrémentation du score du joueur perdant.

12