Discussion :

[Jordan62]

La couleur affiche bien que le roque est possible mais deplacer le roi de deux case vers la droite ne fonctionne pas.. (petit roque)

Dans le deplacement du roque , faut que je fasse une condition si le roque est possible, case entre tour et roi en vert non ?


Merci

[Jordan62]

c'est de la bidouille ça


en fait c'est un bug de la validation de déplacement

Code :

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

1
2
//Si c'est un pion, je verifie si la case est libre de toute piece.
					return !plateau[(int)deplacement.getArrivee().getColonne()][(int)deplacement.getArrivee().getLigne()].estOccupe();

c'est un oubli que exceptionnellement le pion peut se déplacer de 2 cases

il faut ajouter un test (si la case est occupée) sur la case juste avant le pion (éventuellement on testera 2 fois la même case : tu peux optimiser ton test si tu veux en ne le faisant que si la abs(deplacement.getDeplacementY())>1.

je te laisse y réfléchir...

J'ai essayer dans cheminpossible :

Code :

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

1
2
3
4
//Si c'est un pion, je verifie si la case est libre de toute piece.
					if(Math.abs(deplacement.getDeplacementY())>1){
						return !plateau[(int)deplacement.getArrivee().getColonne()][(int)deplacement.getArrivee().getLigne()].estOccupe();}
					}

Mais erreur (il me propose de remplacer la méthode booléenne par un void) alors que je retourne toujours la meme chose qu'avant (il y a juste une condition en plus)

Merci

[joel.drigo]

Merci vraiment pour tout ...

Vous êtes une personne très aimable !

de rien. je me suis bien amusé.

j'espère surtout que tu as progressé et que tu serais capable de le refaire sans aide (ou moins en tout cas).

ce n'est pas fini de toute manière : il reste la prise en passant. à pouvoir jouer le roque. et plein d'autres choses comme par exemple indiquer la case ou le roi doit aller pour faire le roque en vert, ou mieux en vert rayé jaune, enregistrer la partie dans un fichier, pouvoir démarrer une partie en cours, pour résoudre les jeux d'echecs qu'on trouve dans les journaux, permettre d'annuler des coups, etc...

[Jordan62]

de rien. je me suis bien amusé.

j'espère surtout que tu as progressé et que tu serais capable de le refaire sans aide (ou moins en tout cas).

ce n'est pas fini de toute manière : il reste la prise en passant. à pouvoir jouer le roque. et plein d'autres choses comme par exemple indiquer la case ou le roi doit aller pour faire le roque en vert, ou mieux en vert rayé jaune, enregistrer la partie dans un fichier, pouvoir démarrer une partie en cours, pour résoudre les jeux d'echecs qu'on trouve dans les journaux, permettre d'annuler des coups, etc...

Pouvoir jouer le roque serait deja pas mal mais je ne sais pas comment my prendre...

[joel.drigo]

La couleur affiche bien que le roque est possible mais deplacer le roi de deux case vers la droite ne fonctionne pas.. (petit roque)

Dans le deplacement du roque , faut que je fasse une condition si le roque est possible, case entre tour et roi en vert non ?


Merci

en fait j'ai fait une condition pour afficher la tour du roque en jaune quand on clique sur le roi.

maintenant pour pouvoir jouer le roque, il faudrait faire une méthode qui dit qu'une case à 2 cases du roi est valide (en modifiant estValide et cheminPossible) dans le cas ou la tour est dans une position de roque possible (en réutilisant le test déjà fait).
il faudra modifier également la validation du mouvement dans l'écouteur du clic pour déplacer 2 pièces exceptionnellement (alors que d'habitude on en déplace toujours qu'une)

[joel.drigo]

J'ai essayer dans cheminpossible :

Code :

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

1
2
3
4
//Si c'est un pion, je verifie si la case est libre de toute piece.
					if(Math.abs(deplacement.getDeplacementY())>1){
						return !plateau[(int)deplacement.getArrivee().getColonne()][(int)deplacement.getArrivee().getLigne()].estOccupe();}
					}

Mais erreur (il me propose de remplacer la méthode booléenne par un void) alors que je retourne toujours la meme chose qu'avant (il y a juste une condition en plus)

Merci

bon on va reprendre tout ça mais pas ce soir, je peux pas.

[Jordan62]

Merci bcp,
Je comprend tout a fait..

Bonne soirée,
Je vais essayer faire la methode pour jouer le roque.

Merci

[Jordan62]

Si je récapitule , il reste :

- Le fonctionnement du roque,
- Le pion a rajouter une contrainte de déplacement
- L'échec car la on doit manger le roi

Options :
1) Prise en passant
2) Charger / sauvegarder

[joel.drigo]

salut,

donc pour régler le problème du pion il faut modifier la condition dans la méthode cheminPossible(Deplacement) de la classe Echiquier

à savoir :

Code :

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

1
2
3
else 					
       //Si c'est un pion, je verifie si la case est libre de toute piece.
       return !plateau[(int)deplacement.getArrivee().getColonne()][(int)deplacement.getArrivee().getLigne()].estOccupe();

donc la particularité du pion c'est qu'au premier déplacement il peut se déplacer de 2 cases : donc ce test ne testant que la case d'arrivée, il ne teste pas la case intermédiaire

on va rajouter ce cas si notre pion n'a pas été déplacé

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
else {
//Si c'est un pion, je verifie si la case est libre de toute piece.
     if ( !pieceDepart.aDejaEteDeplaceUneFois() ) {
       // si le pion n'a pas été déplacé, il peut avancer de 1 ou 2 case
       // donc on teste si la case devant lui est occupée 
        int depY= (int) Math.signum(deplacement.getDeplacementY()); // on détermine le sens de déplacement (différent selon la couleur)
        if ( plateau[deplacement.getDepart().getColonne()][deplacement.getDepart().getLigne()+depY].estOccupe() ) {
             // si la case est occupée le pion ne peut pas avancer
             return false;
        }
     }
     // sinon on teste la case d'arrivée
						return !plateau[(int)deplacement.getArrivee().getColonne()][(int)deplacement.getArrivee().getLigne()].estOccupe();
					}

[Jordan62]

salut,

donc pour régler le problème du pion il faut modifier la condition dans la méthode cheminPossible(Deplacement) de la classe Echiquier

à savoir :

Code :

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

1
2
3
else 					
       //Si c'est un pion, je verifie si la case est libre de toute piece.
       return !plateau[(int)deplacement.getArrivee().getColonne()][(int)deplacement.getArrivee().getLigne()].estOccupe();

donc la particularité du pion c'est qu'au premier déplacement il peut se déplacer de 2 cases : donc ce test ne testant que la case d'arrivée, il ne teste pas la case intermédiaire

on va rajouter ce cas si notre pion n'a pas été déplacé

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
else {
//Si c'est un pion, je verifie si la case est libre de toute piece.
     if ( !pieceDepart.aDejaEteDeplaceUneFois() ) {
       // si le pion n'a pas été déplacé, il peut avancer de 1 ou 2 case
       // donc on teste si la case devant lui est occupée 
        int depY= (int) Math.signum(deplacement.getDeplacementY()); // on détermine le sens de déplacement (différent selon la couleur)
        if ( plateau[deplacement.getDepart().getColonne()][deplacement.getDepart().getLigne()+depY].estOccupe() ) {
             // si la case est occupée le pion ne peut pas avancer
             return false;
        }
     }
     // sinon on teste la case d'arrivée
						return !plateau[(int)deplacement.getArrivee().getColonne()][(int)deplacement.getArrivee().getLigne()].estOccupe();
					}

Merci sa fonctionne ,
Signum permet donc de connaitre le sens (donc soit + ou - ) si j'ai bien compris

[Jordan62]

J'aimerais essayer de faire la méthode pour le roque ,
Je pense savoir tester si c'est libre entre les tour et le roi puis s'ils ont pas encore bougé mais je ne sais pas comment savoir s'ils sont en echec..
Je pensais a m'aider des cases rouges or, il faut cliquer sur chaque case...

[joel.drigo]

Signum permet donc de connaitre le sens (donc soit + ou - ) si j'ai bien compris

Math.signum( expr ) permet de connaitre le signe de expr, c'est à dire s'il est positive ou négatif,

comme

Code :

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

deplacement.getDeplacementY()

permet de connaitre le déplacement en y (la différence entre le y de la case d'arrivée et le y de la case de départ), le signe de cette expression est effectivement le sens de déplacement

[Jordan62]

Math.signum( expr ) permet de connaitre le signe de expr, c'est à dire s'il est positive ou négatif,

comme

Code :

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

deplacement.getDeplacementY()

permet de connaitre le déplacement en y (la différence entre le y de la case d'arrivée et le y de la case de départ), le signe de cette expression est effectivement le sens de déplacement

D'accord merci

[joel.drigo]

J'aimerais essayer de faire la méthode pour le roque ,
Je pense savoir tester si c'est libre entre les tour et le roi puis s'ils ont pas encore bougé mais je ne sais pas comment savoir s'ils sont en echec..
Je pensais a m'aider des cases rouges or, il faut cliquer sur chaque case...

je reviendrai ce soir. là j'ai du boulot j'ai pas trop le temps.

mais pour commencer à réfléchir :

- déjà décider comment le joueur va faire le roque
1) on peut lui permettre de déplacer le roi de 2 cases, donc vers la droite ou vers la gauche
2) on peut lui permettre de cliquer sur la tour après qu'il ait sélectionné le roi
3) on peut offire les deux possibilités
4) on peut prévoir 2 boutons supplémentaires (petit roque, grand roque), mais c'est pas terrible je trouve, ça nous oblige à repenser l'écran en entier...
- pour le 1, je pense le faire en modifiant les méthode qui testent si un déplacement est valide et si un chemin est possible, en ajoutant le cas des 2 roques : il faut tester si la case d'arrivée est sur la meme ligne que le roi et à 2 cases du roi, que le roi n'a pas été déplacé, que la tour est bien à sa place d'origine (donc en col=0 ou col=7 sur la même ligne), que la case d'arrivée est vide (c'est un test rapide qui nous permet d'éviter de faire le test suivant qui est un peu plus long), qu'un déplacement simulé entre la tour et le roi est valide (avec la méthode utilisée pour afficher la case en jaune),

- pour le 2, il suffit d'utiliser la méthode utilisée pour afficher la case en jaune

- pour faire le roque proprement dit, comme la case sera valide au niveau déplacement, le roi se déplacera dans cette case si on clique dessus dans le cas 1. il faudra juste ajouter un petit bout de code pour déplacer la tour en plus

- dans le cas 2, il faudra bouger les 2 pièces : modifier le code qui traite le cas du clic sur une pièce de la même couleur que la pièce sélectionnée dans le cas voulu (départ=roi, arrivée=tour, roque valide)

[Jordan62]

je reviendrai ce soir. là j'ai du boulot j'ai pas trop le temps.

D'accord merci

[joel.drigo]

on continue ?

procédons par étape :

étape 1 : permettre au roi de se déplacer de 2 cases

dans la classe Roi, on va modifier la méthode estValide

on va traiter le déplacement de 2 cases en imaginant que l'échiquier ne contient que le roi : on ne peut pas faire autrement, puisqu'on a pas accès à l'échiquier, donc on ne peut rien connaitre des autres pièces

donc j'ajoute au test de validation du déplacement le cas du déplacement de 2 cases du roi à partir de sa position de départ (ici en rouge)

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
public boolean estValide(Deplacement deplacement) {
  //le deplacement du roi ressemble a celui de la reine sauf qu'il se deplacement seulement d'une seul et unique case donc nous allons prendre les regles de la reine mais tout mettre inferieur ou egal a 1
  
  // on traite le roque
  if ( !aDejaEteDeplaceUneFois() ) {
      // le roque n'est possible que si le roi n'a jamais été déplacé
      if ( deplacement.getDeplacementY()==0 ) {
        	// le roque est horizontal
        	if ( Math.abs(deplacement.getDeplacementX())==2 ) {
        		// lors du roque le roi se déplace de 2 cases
        		return true;
        	}
      }
  }
  
  return Math.abs(deplacement.getDeplacementX()) * Math.abs(deplacement.getDeplacementY()) <= 1
  && Math.abs(deplacement.getDeplacementX()) - Math.abs(deplacement.getDeplacementY()) <= 1
  && Math.abs(deplacement.getDeplacementX()) - Math.abs(deplacement.getDeplacementY()) >= -1
  	&& !deplacement.isNul();
		
}

si tu fais le test en l'état tu verras que le roi peut se déplacer de 2 cases horizontalement à partir de sa case de départ

bien sur cela ne fait pas encore un roque

tu verras que la règle cheminPossible marche déjà partiellement puisqu'elle empêche le roi de sauter des pièces

maintenant il s'agit de modifier cheminPossible pour qu'on ne puisse faire ce déplacement de 2 cases que dans les conditions valables pour un roque

[Jordan62]

on continue ?

procédons par étape :

étape 1 : permettre au roi de se déplacer de 2 cases

dans la classe Roi, on va modifier la méthode estValide

on va traiter le déplacement de 2 cases en imaginant que l'échiquier ne contient que le roi : on ne peut pas faire autrement, puisqu'on a pas accès à l'échiquier, donc on ne peut rien connaitre des autres pièces

donc j'ajoute au test de validation du déplacement le cas du déplacement de 2 cases du roi à partir de sa position de départ (ici en rouge)

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
public boolean estValide(Deplacement deplacement) {
  //le deplacement du roi ressemble a celui de la reine sauf qu'il se deplacement seulement d'une seul et unique case donc nous allons prendre les regles de la reine mais tout mettre inferieur ou egal a 1
  
  // on traite le roque
  if ( !aDejaEteDeplaceUneFois() ) {
      // le roque n'est possible que si le roi n'a jamais été déplacé
      if ( deplacement.getDeplacementY()==0 ) {
        	// le roque est horizontal
        	if ( Math.abs(deplacement.getDeplacementX())==2 ) {
        		// lors du roque le roi se déplace de 2 cases
        		return true;
        	}
      }
  }
  
  return Math.abs(deplacement.getDeplacementX()) * Math.abs(deplacement.getDeplacementY()) <= 1
  && Math.abs(deplacement.getDeplacementX()) - Math.abs(deplacement.getDeplacementY()) <= 1
  && Math.abs(deplacement.getDeplacementX()) - Math.abs(deplacement.getDeplacementY()) >= -1
  	&& !deplacement.isNul();
		
}

si tu fais le test en l'état tu verras que le roi peut se déplacer de 2 cases horizontalement à partir de sa case de départ

bien sur cela ne fait pas encore un roque

tu verras que la règle cheminPossible marche déjà partiellement puisqu'elle empêche le roi de sauter des pièces

maintenant il s'agit de modifier cheminPossible pour qu'on ne puisse faire ce déplacement de 2 cases que dans les conditions valables pour un roque

Merciii
Ce qui me bloque c'est l'échec ... :/

[joel.drigo]

donc la modification pour tester le chemin possible

on a un peu bidonné finalement estValide pour que le roi puisse se déplacer de 2 cases dans des conditions très limitées

cheminPossible est censé déterminer s'il n'y a pas d'obstacle sur le chemin, ce qui fait partie des conditions à vérifier

mais pour un roque, des cases menacées constituent également un obstacle infranchissable (en quelque sorte).

c'est valable uniquement pour le roque

donc il suffit d'ajouter le bout de code en rouge suivant à la méthode cheminPossible de Echiquier

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
if(!(pieceDepart instanceof Pion)){
 
  // cas spécial du roque
  if ( pieceDepart instanceof Roi ) {
    if (!pieceDepart.aDejaEteDeplaceUneFois() && Math.abs(deplacement.getDeplacementX())==2 ) {
      // on est entrain de tester si un roque est possible (on est sur le cas d'un déplacement de 2 cases)
      // on détermine la position de la tour
      int xtour;
      if( deplacement.getDeplacementX()<0 ) {
        // déplacement vers la gauche = grand roque = roque avec la tour gauche (vue des blancs)
        xtour=0;
      }
      else {
        // déplacement vers la droite = petit roque = roque avec la tour droite (vue des blancs)
        xtour=7;
      }
      Position positionTour=new Position(xtour, deplacement.getDepart().getLigne());
      Piece piece = plateau[positionTour.getColonne()][positionTour.getLigne()].getPiece();
      if ( piece instanceof Tour && !piece.aDejaEteDeplaceUneFois() ) {
        // dans le cas contraire le roque n'est pas possible
        // on simule un déplacement pour pouvoir utiliser la méthode de controle du roque
        Deplacement roque = new Deplacement(deplacement.getDepart(),positionTour);
        if ( isRoquePossible(roque) ) {
        	// cette configuration autorise le roque
        	// le déplacement est valide
        	return true;
        }
      }
      return false; // dans tous les autres cas un déplacement de 2 cases du roi est bien entendu interdit
    } 
  }
 
		//Je verifie que le deplacement est superieur a un.

en testant je me suis aperçu d'une autre bizareté de l'algo d'origine : le roi peut se mettre en echec, alors qu'il me semble bien (ça fait dans les 30 ans que j'ai pas joué aux echecs, alors je suis un peu rouillé) qu'il est interdit que le roi se mette en echec

ce serait interessant de corriger ça : soit interdire au roi de se mettre en echec (et avec tout ce que je t'ai montré, tu devrais pouvoir le faire tout seul), ou au moins afficher la case dans une couleur spéciale pour dire attention là c'est mise en echec du roi

j'ai vu un autre bug sinon si tu fais commencer, puis terminé, puis commencer, tu ne peux pas bouger les pièces

[joel.drigo]

Merciii
Ce qui me bloque c'est l'échec ... :/

c'est à dire ?

[joel.drigo]

donc pour jouer le roque maintenant :

ça se passe dans la méthode ou on gère le déplacement évidemment

la seule chose c'est qu'on a une pièce a déplacer en plus que d'habitude : la tour quand le roi s'est déplacé de 2 cases (on s'est arrangé avec estValide et cheminPossible pour le seul déplacement de 2 cases soit un roque)

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
//on met le tampon sur la case vide et on vide le tampon apres
e.getCase(temp.getColonne(), temp.getLigne()).setPiece(null);
tab[temp.getColonne()][temp.getLigne()].setBorder(BorderFactory.createLineBorder(new Color(0, 0, 0),0)); // j'enleve le cadre rouge de la piece selectionne
tab[colonneClic][ligneClic].setIcon(iconeTampon);
e.getCase(colonneClic, ligneClic).setPiece(pieceTampon); // pour pouvoir le rebouger plusieurs fois dans une partie
tab[temp.getColonne()][temp.getLigne()].setIcon(null); // permet de faire bouger la piece selectionne en supprimant la piece bouger de sa position initiale 
pieceTampon.enregistreDeplacement(true);

if ( pieceTampon instanceof Roi ) {
	// est ce qu'on était pas entrain de faire un roque, des fois
	if ( Math.abs(deplacement.getDeplacementX())==2) {
		// ah bah si on dirait bien
		// donc faut que je déplace aussi la tour derrière le roi
		int xtourDepart, xtourArrivee;
		if( deplacement.getDeplacementX()<0 ) {
			// déplacement vers la gauche = grand roque = roque avec la tour gauche (vue des blancs)
			xtourDepart=0;
			xtourArrivee=3;
		}
		else {
			// déplacement vers la droite = petit roque = roque avec la tour droite (vue des blancs)
			xtourDepart=7;
			xtourArrivee=5;
		}
                // on déplace la tour... donc la pièce et l'icone
		Piece tour = e.getCase(xtourDepart, ligneClic).getPiece();
		e.getCase(xtourArrivee, ligneClic).setPiece(tour);
		e.getCase(xtourDepart, ligneClic).setPiece(null);
		tour.enregistreDeplacement(true); // ce déplacement doit être compté
		tab[xtourArrivee][ligneClic].setIcon(tab[xtourDepart][ligneClic].getIcon());
		tab[xtourDepart][ligneClic].setIcon(null);
	}
}

pieceTampon = null;
iconeTampon = null;
temp = null;

couleurControle = couleurControle==(COULEUR_JOUEUR_BLANC) ? COULEUR_JOUEUR_NOIR : COULEUR_JOUEUR_BLANC;
champTexte.setText(couleurControle + " , a vous de jouer");

en passant, autre bug que j'ai vu et que tu peux facilement corriger toi même :
si on sélectionne une pièce et que ça allume en vert, rouge ou jaune des cases, si là on clique sur terminé, les cases restent en vert, rouge ou jaune : il faut donc les remettre à zéro (tu te souvient setCoupPossible(null)?) lorsqu'on clique sur le bouton terminé comme on l'a fait quand le coup est joué...


bon sur ce je vais te quitter pour ce soir