Discussion :

[joel.drigo]

J'ai vu différentes classes, mais ce projet est dans le but de découvrir sauf que c'est dur ..

Les cases vertes affichent aussi quand elles sont occupées ...
Les cases rouges s'affichent pas...


Sa parait simple quand on le lit mais quand il faut le faire c'est dure ...

Remet moi le bout de code fini que tu as fait (celui avec les setCoupPossible) que je regarde qui ne va pas ?

[joel.drigo]

mets moi aussi le code de la méthode getCase() de la classe Echiquier

[Jordan62]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
								for (int ligne = 0; ligne < 8; ligne++) {
								     for (int colonne = 0; colonne < 8; colonne++) {
								        Position pos = new Position(colonne,ligne);
								        Deplacement deplacement=new Deplacement(temp,pos);
								        if (pieceTampon.estValide(deplacement)) {
								            if(e.captureParUnPionPossible(deplacement)){
								                tab[colonne][ligne].setCoupPossible(CoupPossible.prisepion);}
								            else if (tab[colonne][ligne].estOccupe()){
								                tab[colonne][ligne].setCoupPossible(null);}
								            else {
								        		    tab[colonne][ligne].setCoupPossible(CoupPossible.mouvement);
								        		 }
								        } else {
								            tab[colonne][ligne].setCoupPossible(null);
								        }
								}	
							}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public Case getCase(int colonne, int ligne) {
		return plateau[colonne][ligne];
	}

Merci..

[joel.drigo]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public Case getCase(int colonne, int ligne) {
		return plateau[colonne][ligne];
	}

je m'en doutais : je t'ai fait créer une classe Case extends JLabel, mais j'ai dans l'idée que tu as confondu les deux classes, parce que j'ai vu dans tes posts précédent que tu avais ajouté dans cette classe des méthodes genre estOccupe etc...

si tu avais déjà une classe Case, il ne fallait pas la remplacer par celle là : mais changer le nom, genre CaseLabel extends JLabel

donc quand tu appelles tab[i][j].estOccupe() tu obtiens toujours false, parce que Echiquier gère ses propres instances de Case, qui ne sont pas celles qu'on créé quand on construit l'échiquier graphique

tu vois ce que je veux dire :
- remet le code d'origine de la classe Case (si tu avais modifié des trucs dedans, remet les)
- recréé une classe CaseLabel extends JLabel sur le modèle de ce que je t'avais dit (mais que j'avais appelé Case)

ensuite il faut modifier le test de condition :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
if (pieceTampon.estValide(deplacement)) {
    if(e.captureParUnPionPossible(deplacement)){
        tab[colonne][ligne].setCoupPossible(CoupPossible.prisepion);}
    else if (tab[colonne][ligne].estOccupe()){
        tab[colonne][ligne].setCoupPossible(null);}
    else {
		    tab[colonne][ligne].setCoupPossible(CoupPossible.mouvement);
		 }
} else {
    tab[colonne][ligne].setCoupPossible(null);
}

remplace la condition en rouge par la dernière condition qu'on a vu :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if (e.getCase(colonne,ligne).estOccupe(pieceTampon.getCouleur().equals("blanc") ? "noir" : "blanc")

et en orange par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

e.getCase(colonne,ligne).estOccupe()

[Jordan62]

J'ai remis a l'état initial et changer le texte orange et rouge par ce que vous avez gentillement proposé.

Mon fichier case.java contient donc :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
package projet;
 
import java.awt.Color;
 
import javax.swing.JLabel;
 
import projet.Piece;
 
 
public class Case {
	private Piece piece;
 
	public Case()
	{
		//constructeur par defaut 
	}
 
	public Case(Piece piece)
	{
		this.piece = piece;
	}
 
	public Piece getPiece() {
        //sert a retourner la piece sur la case ou return null si case vide
		return piece;
	}
 
	public void setPiece(Piece piece) {
        //permet d'inserer la piece dans une case
		this.piece = piece;
	}
 
 
	public boolean estOccupe()
	{
        //sert a savoir si la case est occuper ou non
		return (piece != null);	
	}
 
	public boolean estOccupe(String couleur)
	{
        //Si il n'y a pas de piece sur la case c'est que la case n'est pas occuper au contraire la fonctioin retournera la piece de la couleur en question.
		if (piece == null)
			return false;
		else
			return (piece.getCouleur().equals(couleur));
	}
 
}
 
class CaseLabel extends JLabel {
	private static final long serialVersionUID = 1L;
	private boolean blanc; // false si case noire, true si case blanche
	private CoupPossible couppossible;	
 
	public enum CoupPossible {
	     mouvement,
	     prisepion,
	     roque
	}
	private void setCouleur() {
		if ( couppossible!=null )
              switch(couppossible) {
                  case mouvement:
			setBackground(new Color(0, 240, 0)); //couleur d'un coup possible : vert
                        break;
                  case prisepion:
			setBackground(new Color(255, 0, 0)); //couleur d'un coup possible avec prise de pion : rouge
                        break;
                  case roque:
			setBackground(new Color(247, 255, 60)); //couleur d'un roque possible : jaune
                        break;
                }
		else if (blanc)
			setBackground(new Color(255, 255, 255)); //couleur des cases : blanc
		else
			setBackground(new Color(153, 153, 153)); //couleur des cases : noir
	}
	public void setCoupPossible(CoupPossible couppossible) {
	    this.couppossible=couppossible;
	    setCouleur();
	}
	public void setCouleur(boolean blanc) {
	    this.blanc=blanc;
	    setCouleur();
	}
}

Je ne suis pas sur pour CaseLabel...

[joel.drigo]

oui c'est ça

il faut pas que tu oublies de modifier la création des cases !

le code ressemblait à ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
//J'attribue la couleur aux JLabels
		int a = 1;
		for (int ligne = 0; ligne < 8; ligne++) {
			a = a == 1 ? 0 : 1;
			for (int colonne = 0; colonne < 8; colonne++) {
				tab[colonne][ligne] = new Case();
				panelGrille.add(tab[colonne][ligne]); // ajouter au Panel

evidemment le truc en rouge devient :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

new CaseLabel()

et bien sur la déclaration du tableau tab !

[Jordan62]

J'ai remplacer ici :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
import java.awt.Color;
 //cette classe permet de faire l'inteface graphique avec les boutons reset et commencer ainsi que le champs texte informant que c'est sont tour et des Jpanel pour recuperer les pions manger 
public class FenetreJeu extends JFrame {
	private static final long serialVersionUID = 42L; //serialVersionUID permet d'affecter un numéro de version à la classe
	//construction tableau echequier
	private Echiquier e; // echiquier
	private CaseLabel[][] tab; // tableau de cases
	private JPanel panelControle = new JPanel(); // panel du haut
	private JPanel panelGrille = new JPanel(); // panel du bas ( grille )
	GridLayout gridLayout1 = new GridLayout();

	private JButton boutonDebuter = new JButton();
	private JTextField champTexte = new JTextField();
	private JButton boutonfin = new JButton();
	
	 //Constructeur
	public FenetreJeu()
	{
		try {
			initialisationPanel(); //appelle methode initialisationPanel
		} catch (Exception e) {
			e.printStackTrace(); //affiche l'exception au moment de son appel
	    }
	}

	
	 // initialise la surface de jeu. Cre tout les elements et initialise leur position, leur couleur.. etc
	 
	private void initialisationPanel() throws Exception {

		tab = new CaseLabel[8][8]; // création du tableau de JLabel
		e = new Echiquier(); // création de l'échiquier

		this.getContentPane().setLayout(null); // permet de centrer le cadre du haut
		this.setSize(new Dimension(900, 700)); //dimension fenetre 
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //fermer la fenetre
		this.setTitle("ECHEC"); //titre de la fenetre
		panelControle.setBounds(new Rectangle(160, 10, 550, 45)); //dimension du bloc du haut
		panelControle.setBorder(BorderFactory.createEtchedBorder(EtchedBorder.RAISED)); //bordure cadre du haut
		panelControle.setLayout(null); //permet de voir le champ en haut
		panelGrille.setBounds(new Rectangle(160, 65, 550, 465)); //dimension de l'échiquier
		panelGrille.setBorder(BorderFactory.createEtchedBorder(EtchedBorder.RAISED));
		panelGrille.setLayout(gridLayout1); // insert les colonnes et les lignes pour les cases
		gridLayout1.setColumns(8);
		gridLayout1.setRows(8);
		panelControle.add(boutonfin, null);
		panelControle.add(champTexte, null);
		panelControle.add(boutonDebuter, null);
		this.getContentPane().add(panelControle, null); //visualiser le champ text en haut
		boutonDebuter.setBounds(new Rectangle(15, 10, 130, 25));
		boutonDebuter.setText("Commencer");
		champTexte.setBounds(new Rectangle(160, 10, 215, 25));

		// les écouteurs
		boutonfin.setText("Terminé");
		boutonfin.setBounds(new Rectangle(390, 10, 130, 25));
		GestionnaireEvenement gest = new GestionnaireEvenement();
		boutonDebuter.addMouseListener(gest);
		boutonfin.addMouseListener(gest);
		
		//crŽation des labels
		panelblanc.setBounds(new Rectangle(30, 65, 90, 465)); // dimension recuperateur de piece blanche
		panelblanc.setBackground(new Color(255, 0, 0));
		panelblanc.setLayout(new FlowLayout());
		panelblanc.setBorder(BorderFactory.createEtchedBorder(EtchedBorder.RAISED));
		panelnoir.setBounds(new Rectangle(750, 65, 90, 465)); // dimension recuperateur de piece noire
		panelnoir.setBackground(new Color(0, 0, 0));
		panelnoir.setLayout(new FlowLayout());
		

		
		
		//J'attribue la couleur aux cases
		int a = 1;
		for (int ligne = 0; ligne < 8; ligne++) {
			a = a == 1 ? 0 : 1;
			for (int colonne = 0; colonne < 8; colonne++) {
				tab[colonne][ligne] = new CaseLabel();
				panelGrille.add(tab[colonne][ligne]); // ajouter au Panel
				tab[colonne][ligne].setOpaque(true);
				tab[colonne][ligne].setHorizontalAlignment(SwingConstants.CENTER); //centre les pieces dans les cases
				tab[colonne][ligne].addMouseListener(gest); 
				if ((colonne + 1) % 2 == a)
					tab[colonne][ligne].setCouleur(true); //couleur des cases : blanc
				else
					tab[colonne][ligne].setCouleur(false); //couleur des cases : noir
				
			}
		}		
	}

J'ai tester et cela m'affiche bien les choix disponibles en vert et miracle !! Les cases occupé sont marqué de rien !

Merci

Le rouge fonctionne aussi :O
Mais Pour le pion il marche que de face alors que normalement on prend un pion adverse en diagonale ...


De plus, la dame ou le fou par exemple ont des cases vertes quand on clique (ce qui est normal) et les cases occupées sont pas vertes (toujours normal) sauf que si par exemple il y a un pion devant la tour, juste devant le pion il y a que des cases vertes alors que la tour ne peut pas passer au dessus en théorie ...

[joel.drigo]

Mais Pour le pion il marche que de face alors que normalement on prend un pion adverse en diagonale ...


De plus, la dame ou le fou par exemple ont des cases vertes quand on clique (ce qui est normal) et les cases occupées sont pas vertes (toujours normal) sauf que si par exemple il y a un pion devant la tour, juste devant le pion il y a que des cases vertes alors que la tour ne peut pas passer au dessus en théorie ...

possible que le code que tu as pris en exemple ne soit pas tout à fait au point

[Jordan62]

Merci, pour le roque,
Il faut un boolean qui verifie que le roi n'est pas en echec puis qu'il y a rien entre le roi et la tour pour que sa permute ???

[joel.drigo]

les règles pour le roque :

- ni le roi ni la tour ne doivent avoir déjà bouger
- aucune des cases entre la tour et le roi ne doivent être occupée
- aucune des cases entre la tour et le roi, ou la tour ou le roi, ne doivent être menacée (c'est à dire qu'une pièce adverse pourrait s'y déplacer), donc par déduction le roi ne peut être en echec pour roquer

[Jordan62]

Le seul hic c'est que je n'ai pas la methode roi en echec,

Pour gagner il suffit de manger le roi...

[joel.drigo]

fait 2 méthodes :

- une qui teste le petit roque
- une qui teste le grand roque

pour chacune d'entre elles,

détermine la tour concernée

puis traite chaque règle
1 ni le roi ni la tour ne doivent avoir déjà bouger
2 aucune des cases entre la tour et le roi ne doivent être occupée
3 aucune des cases entre la tour et le roi, ou la tour ou le roi, ne doivent être menacée (c'est à dire qu'une pièce adverse pourrait s'y déplacer), donc par déduction le roi ne peut être en echec pour roquer

pour la 1, tu peux faire un boolean pour le roi, 1 pour le tour droite, et 1 pour la tour gauche : dès que tu bouges la pièce tu passes le booleen correspondant à true
ce qui te permet de tester si la pièce à bouger
tu peux aussi mettre le boolean directement dans la classe pièce : on pourra savoir pour n'importe quelle pièce si elle a déjà bougé une fois

pour la 2, tu connais les x,y de chacune de ces cases, donc tu peux tester si elles sont occupées ou non

pour la 3, il te suffit de parcourir toutes les pièces adverses, pour chacune des ces pièces, parcourir toutes les cases concernées (donc celle ou est le roi, celle ou est la tour, celles entre les deux, donc en gros celles qui ont été testées pour la règle 2) : pour tous ces couples de case, tu simules le mouvement (comme on a fait pour déterminer les cases vertes) : dès qu'un deplacement simulé est valide, tu peux arreter ton test : tu as trouvé un cas qui interdit le roque !

[joel.drigo]

Pour gagner il suffit de manger le roi...

déjà un cas mal géré par ton programme d'echec: aux echecs le roi ne peut être "mangé" : dès que le roi est menacé et ne peut plus se déplacer sans se mettre dans une position menacée, et qu'aucune de ses pièces ne peut être déplacé pour protéger le roi, le jeu s'arrête : on appelle ça "echec et mat" !

[Jordan62]

fait 2 méthodes :

- une qui teste le petit roque
- une qui teste le grand roque

pour chacune d'entre elles,

détermine la tour concernée

puis traite chaque règle
1 ni le roi ni la tour ne doivent avoir déjà bouger
2 aucune des cases entre la tour et le roi ne doivent être occupée
3 aucune des cases entre la tour et le roi, ou la tour ou le roi, ne doivent être menacée (c'est à dire qu'une pièce adverse pourrait s'y déplacer), donc par déduction le roi ne peut être en echec pour roquer

pour la 1, tu peux faire un boolean pour le roi, 1 pour le tour droite, et 1 pour la tour gauche : dès que tu bouges la pièce tu passes le booleen correspondant à true
ce qui te permet de tester si la pièce à bouger
tu peux aussi mettre le boolean directement dans la classe pièce : on pourra savoir pour n'importe quelle pièce si elle a déjà bougé une fois

pour la 2, tu connais les x,y de chacune de ces cases, donc tu peux tester si elles sont occupées ou non

pour la 3, il te suffit de parcourir toutes les pièces adverses, pour chacune des ces pièces, parcourir toutes les cases concernées (donc celle ou est le roi, celle ou est la tour, celles entre les deux, donc en gros celles qui ont été testées pour la règle 2) : pour tous ces couples de case, tu simules le mouvement (comme on a fait pour déterminer les cases vertes) : dès qu'un deplacement simulé est valide, tu peux arreter ton test : tu as trouvé un cas qui interdit le roque !

Merci pour tout ces détails,
Je réfléchirais demain a tête reposé pour éviter de dire des bêtises ce soir.

Merci encore,
Bonne soirée .

[Jordan62]

Pour la couleur rouge du pion qui déconnait , j'ai essayer cela en vain :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
     if (pieceTampon.estValide(deplacement)) {
								        	if (e.getCase(colonne,ligne).estOccupe(pieceTampon.getCouleur().equals("blanc") ? "noir" : "blanc ") || (e.getCase(colonne,ligne).captureParUnPionPossible())){		
								        		tab[colonne][ligne].setCoupPossible(CoupPossible.prisepion);}
								            else if (e.getCase(colonne,ligne).estOccupe()){
								                tab[colonne][ligne].setCoupPossible(null);
								                }
								            else {
								        		    tab[colonne][ligne].setCoupPossible(CoupPossible.mouvement);
								        		 }
								        } else {
								            tab[colonne][ligne].setCoupPossible(null);
								        }

car dans la classe deplacement j'avais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public boolean captureParUnPionPossible(Deplacement deplacement) {
		//Je verifie si la piece est un pion
		if(plateau[deplacement.getDepart().getColonne()][deplacement.getDepart().getLigne()].getPiece() instanceof Pion)
		{
			//initialisation des variables, et savoir la couleur de la piece de depart et la case d'arrive.
			Case Arrive = plateau[(int)deplacement.getArrivee().getColonne()][(int)deplacement.getArrivee().getLigne()];
			String couleurDepart = plateau[(int)deplacement.getDepart().getColonne()][(int)deplacement.getDepart().getLigne()].getPiece().getCouleur();
			
			//je verifie d'abord si la piece d'arrive existe et si elle est de la couleur contraire de celle de depart.
			if(Arrive.estOccupe(couleurDepart.equals("blanc") ? "noir" : "blanc"))
			//on verifie  si le deplacement est valide par le produit du deplacement des ordonner et absices et si cela fait 1 pour les noir ou -1 pour les blanc cela sera accepter
           
				return (deplacement.getDeplacementY() * Math.abs(deplacement.getDeplacementX()) == (couleurDepart.equals("noir et jaune") ? 1 : -1)); //en diagonale
		}
		return false;
		
	}

Ensuite dans ma classe Piece j'ai ajouté :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
	public boolean ReineGaucheDejabouge(){
		if(plateau[0][0].getPiece() instanceof Tour(couleur));
		 	return true;
		else
			return fase;
	}

Mais plateau n'est pas reconnu.
Comment faire une méthode pour chaque pion s'il a déjà bougé une fois ou non ?


Pour tester les cases entre la tour et le roi , je fais une méthode booléenne dans quelle classe ? Merci



Pour ce qui est en est de l'echec , je pensais a si une case est rouge cela signifie qu'il est en echec mais il faut cliquer sur la piece en question pour apercevoir les couleurs...


Merci

[joel.drigo]

euh, c'est quoi ça ?

c'est dans le code d'origine ce genre de test ? ou c'est toi qui a ajouté ça ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

pieceTampon.getCouleur().equals("rouge et jaune")

c'est quoi le code de la classe Piece

[Jordan62]

euh, c'est quoi ça ?

c'est dans le code d'origine ce genre de test ? ou c'est toi qui a ajouté ça ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

pieceTampon.getCouleur().equals("rouge et jaune")

c'est quoi le code de la classe Piece

J'ai personnalisé les images donc j'ai du changer le bouton qui afficher c'est au ... De jouer"

[Jordan62]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public abstract class Piece {
 
 
	 // nom de la piece
	private String nom;
	 // couleur de la pièce 
	private String couleur;
 
	// constructeur permettant d'initialiser le nom et la couleur d'une pièce 
	public Piece(String nom, String couleur) {
		setNom(nom);
		setCouleur(couleur);
	}
 
	public String getNom() {
		return nom;
	}
 
	public void setNom(String nom) {
		this.nom = nom;
	}
 
	public String getCouleur() {
		return couleur;
	}
 
	public void setCouleur(String couleur) {
		if ((couleur == "noir et jaune") || (couleur == "rouge et jaune"))
			this.couleur = couleur;
	}
 
	// méthode permettant de vérifier si le déplacement de la pièce est valide 
	public abstract boolean estValide(Deplacement deplacement);
 
	public boolean ReineGaucheDejabouge(){
		if(plateau[0][0].getPiece() instanceof Tour(couleur));
		 	return true;
		else
			return fase;
	}
 
}

Merci

[joel.drigo]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
	public boolean ReineGaucheDejabouge(){
		if(plateau[0][0].getPiece() instanceof Tour(couleur));
		 	return true;
		else
			return fase;
	}

et ça c'est quoi au juste ? dans la classe Piece ?

déjà je suppose que ça devrait s'appeler TourGaucheDejabouge

ça n'a rien a faire dans Piece

et si la tour se déplace et revient à sa place d'origine, ta méthode va dire que la tour n'a pas bougé alors que si

pour traiter le mouvement tu dois simplement ajouter à ta classe Piece

- une variable booléenne pour stocker l'état déplacé, par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

private boolean deplaceunefois;

- un mutateur (une méthode pour modifier cette valeur) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public void enregistreDeplacement(boolean deplace) {
    deplaceunefois=deplace;
}

- un accesseur pour connaitre l'état de cette variable

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public boolean aDejaEteDeplaceUneFois(){
       return deplaceunefois;
}

maintenant il faut appeler enregistreDeplacement() au bon endroit dans le code : c'est à dire au moment ou un joueur déplace une pièce.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 pieceTampon.enregistreDeplacement(true)

à priori c'est dans un des bloc du code principal de l'écouteur de clic, là ou y'a le commentaire //on met le tampon sur la case vide et on vide le tampon apres

dans la méthode RAZ() : parcourt toutes les pièces et remet à false la variable

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

enregistreDeplacement(false)

autre chose :

dans

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if ((pieceTampon.estValide(deplacement) && e.cheminPossible(deplacement)) | e.captureParUnPionPossible(deplacement))

a noter l'appel e.cheminPossible(deplacement) : voilà peut être une méthode qui sert dans les test pour déterminer les coupPossible en plus de estValide : à vérifier ce qu'elle fait exactement

[joel.drigo]

J'ai personnalisé les images donc j'ai du changer le bouton qui afficher c'est au ... De jouer"

ouais je vois le code d'origine traitait les 2 couleurs de jouer par une chaine,qui contenant "noir" ou "blanc" et toi tu as remplacé ça

c'est pas comme ça qu'on fait (le code d'origine) : et toi tu modifié directement un code pourri en le pourrissant encore plus

on doit distinguer les états et valeurs de leur représentation, ce qui évite d'avoir à écrire ce genre d'horreur et à tout modifier quand on change la représentation

le codeur initial aurait du utiliser un type à 2 états, moi j'aurais utiliser une énumération à 2 valeurs : aux echecs il y a un joueur blanc et un joueur noir, que les pièces soit rouge, jaune, rouge à pois vert, ou bleue rayée d'orange, ou texture bois

et on teste toujours la couleur de la pièce par le même test
et on utilise ensuite une méthode qui détermine le texte à afficher (ou autre chose à afficher) en fonction de la valeur.

le jour ou tu voudras ajouter la possibilité au joueur de choisir parmi plusieurs type de pièce différent, tu vas écrire des tests dans le genre

if ( piece.getCouleur().equals("rouge et jaune") || piece.getCouleur().equals("rouge et vert") || piece.getCouleur().equals("bleue et rouge") || piece.getCouleur().equals("orange et violet") || ... piece.getCouleur().equals("bleue et jaune")

tu imagines ?

et un jour tu as un pote anglais qui aimerait bien jouer avec ton jeu d'echec : il va traduire les textes et quand il va voir qu'il doit changer des tests dans tout le code, à priori, il va un peu criser