Echiquier en Java

Version imprimable

Voir 40 message(s) de cette discussion en une page

Citation:

Envoyé par Jordan62

Code:

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 piece
	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

à défaut d'enumeration, fait au moins des constantes pour tes couleurs !!!

Code:

1
2
public final static String COULEUR_JOUEUR_BLANC="rouge et jaune";
public final static String COULEUR_JOUEUR_NOIR="noir et jaune";

Code:

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;
		
	}

tu vois que ce que j'ai mis en rouge ne peut plus marcher puisque tu as changé les textes des couleurs des pièces : encore une bonne raison de ne pas faire ça comme ça, mais comme je l'ai dit, ou au moins avec des constantes (dont tu peux changer la valeur sans modifier tous les tests relatifs)

Citation:

Envoyé par joel.drigo

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

Code:

enregistreDeplacement(false)

autre chose :

dans

Code:

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

J'ai changer les couleurs par les variables,
mais j'ai eu un soucis au niveau de :
enregistredeplacement(false) car il ne connait pas enregistredeplacement dans la methode RAZ..

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
	public void RAZ()
	{
		for (int ligne = 0; ligne < 8; ligne++) 
			for (int colonne = 0; colonne < 8; colonne++) {
				tab[colonne][ligne].setIcon(null);
				e.getCase(colonne, ligne).setPiece(null);
				tab[colonne][ligne].enregistreDeplacement(false);
			}
		champTexte.setText("");
		boutonDebuter.setEnabled(true);
		e.debuter();

		panelblanc.removeAll();
		panelblanc.repaint();
		panelnoir.removeAll();
		panelnoir.repaint();
		

	}

Pourtant le enregistreDeplacement(true); ne produit aucune erreur :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
else//si on depose la piece sur une case vide
								{
									//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);
	
									pieceTampon = null;
									iconeTampon = null;
									temp = null;
	
									couleurControle = couleurControle.equals(COULEUR_JOUEUR_BLANC) ? COULEUR_JOUEUR_NOIR : COULEUR_JOUEUR_BLANC;
									champTexte.setText(couleurControle + " , a vous de jouer");
                                    		
								}

J'ai donc mon fichier piece qui ressemble a ceci :

Code:

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
 
public abstract class Piece {
 
	private boolean deplaceunefois;
	 // nom de la piece
	private String nom;
	 // couleur de la pièce 
	private String couleur;
	public final static String COULEUR_JOUEUR_BLANC="rouge et jaune";
	public final static String COULEUR_JOUEUR_NOIR="noir et jaune";
 
 
	// 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 == COULEUR_JOUEUR_NOIR) || (couleur == COULEUR_JOUEUR_BLANC))
			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 void enregistreDeplacement(boolean deplace) {
	    deplaceunefois=deplace;
	}
	public boolean aDejaEteDeplaceUneFois(){
	       return deplaceunefois;
	}
 
}

Merci

Citation:
Envoyé par Jordan62
J'ai changer les couleurs par les variables,
mais j'ai eu un soucis au niveau de :
enregistredeplacement(false) car il ne connait pas enregistredeplacement dans la methode RAZ..
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 public void RAZ() { for (int ligne = 0; ligne < 8; ligne++) for (int colonne = 0; colonne < 8; colonne++) { tab[colonne][ligne].setIcon(null); e.getCase(colonne, ligne).setPiece(null); tab[colonne][ligne].enregistreDeplacement(false); } champTexte.setText(""); boutonDebuter.setEnabled(true); e.debuter(); panelblanc.removeAll(); panelblanc.repaint(); panelnoir.removeAll(); panelnoir.repaint(); }
enregistreDeplacement est une méthode de Piece et la tu l'appelle sur CaseLabel...

il faut que tu parcourt toutes les pièces et que tu appelles cette méthode sur ces instances de piece. peut être voir si tu ne peux pas le faire dans la méthode débuter de Echiquier ou une autre méthode ! cherche celle qui est la plus adaptée, et qui ne risque pas d'être appelée en plein milieu de partie

si tu n'arrives pas à trouver un moyen de parcourir toutes les pièces, tu peux aussi modifier le code qui place les pièces sur l'échiquier : la a priori on parcourir toutes les pieces pour les placer, et on est en démarrage de partie

Citation:

Envoyé par joel.drigo

enregistreDeplacement est une méthode de Piece et la tu l'appelle sur CaseLabel...

il faut que tu parcourt toutes les pièces et que tu appelles cette méthode sur ces instances de piece. peut être voir si tu ne peux pas le faire dans la méthode débuter de Echiquier ou une autre méthode ! cherche celle qui est la plus adaptée, et qui ne risque pas d'être appelée en plein milieu de partie

si tu n'arrives pas à trouver un moyen de parcourir toutes les pièces, tu peux aussi modifier le code qui place les pièces sur l'échiquier : la a priori on parcourir toutes les pieces pour les placer, et on est en démarrage de partie
Code:

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 public Case getCase(int colonne, int ligne) { return plateau[colonne][ligne]; } //place les pieces au debut public void debuter() { int ligne = 7; for (String couleur = COULEUR_JOUEUR_NOIR ; !couleur.equals(COULEUR_JOUEUR_BLANC); couleur = COULEUR_JOUEUR_BLANC, ligne = 0){ //J'initialise tout mes pieces de la premieres rangee (tour, cavalier etc...) plateau[0][ligne].setPiece(new Tour(couleur)); plateau[1][ligne].setPiece(new Cavalier(couleur)); plateau[2][ligne].setPiece(new Fou(couleur)); plateau[3][ligne].setPiece(new Reine(couleur)); plateau[4][ligne].setPiece(new Roi(couleur)); plateau[5][ligne].setPiece(new Fou(couleur)); plateau[6][ligne].setPiece(new Cavalier(couleur)); plateau[7][ligne].setPiece(new Tour(couleur)); //Je change de ligne ligne += couleur.equals(COULEUR_JOUEUR_NOIR) ? -1 : 1; //J'initialise tout mes pions. for (int ctr = 0; ctr <= 7; ctr++) plateau[ctr][ligne].setPiece(new Pion(couleur)); } }
Dans ce code, je ne vois pas ou le mettre car on s'interrese qu'au ligne ici
Je n'ai pas trop compris ce qu'il devait y avoir avant
enregistreDeplacement(false);
J'ai compris qu'il fallais parcourir chaque case pour mettre deplacement a faux comme on débute la partie mais je ne vois pas ou le mettre.

Code:

1 2 3 4 public void setCouleur(String couleur) { if ((couleur == COULEUR_JOUEUR_NOIR) || (couleur == COULEUR_JOUEUR_BLANC)) this.couleur = couleur; }
attention, au test d'égalité :
- il faut que tu comprennes la différence entre

Code:

couleur.equals(COULEUR_JOUEUR_NOIR)

et

Code:

couleur==COULEUR_JOUEUR_NOIR

sinon tu risques d'avoir des dysfonctionnement sans comprendre pourquoi

les variables sont typées en java. il y a 2 types de type : les types primitifs et les classes.
quand une variable est de type primitid, elle "contient" directement sa valeur
Code:

1 2 int a; a=123;
int est un type primitif, a contient 123.
mais quand une variable est de type classe, la variable contient une référence à l'instance de classe
Code:

1 2 String s; s="TOTO";
String est une classe
s ne contient pas "TOTO", mais une référence à une instance de la classe String qui contient une tableau de char qui contient les lettres T, O, T et O.

si tu écris
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public static void main(String[] args) { String s="TOTO"; String s1=s.substring(0,2); String s2=s.substring(0,2); System.out.println("s1 : " + s1); System.out.println("s2 : " + s2); System.out.println("s1==s2 : " + (s1==s2)); System.out.println("s1.equals(s2) : " + s1.equals(s2)); }
tu auras a l'écran :
Code:

1 2 3 4 s1 : TO s2 : TO s1==s2 : false s1.equals(s2) : true
bien sur ton == marchera tant que tu utiliseras uniquement les constantes pour affecter la valeur de couleur (puisqu'en fait tu utiliseras la même référence à chaque fois pour chacune des deux constantes), mais tu risques à un moment que ton test ne marche pas parce que tu compares à une chaine qui n'est pas la constante de départ
avec des String, à moins d'être sur de ton coup, utilise equals

Citation:
Envoyé par joel.drigo
Code:

1 2 3 4 public void setCouleur(String couleur) { if ((couleur == COULEUR_JOUEUR_NOIR) || (couleur == COULEUR_JOUEUR_BLANC)) this.couleur = couleur; }
attention, au test d'égalité :
- il faut que tu comprennes la différence entre

Code:

couleur.equals(COULEUR_JOUEUR_NOIR)

et

Code:

couleur==COULEUR_JOUEUR_NOIR

sinon tu risques d'avoir des dysfonctionnement sans comprendre pourquoi

les variables sont typées en java. il y a 2 types de type : les types primitifs et les classes.
quand une variable est de type primitid, elle "contient" directement sa valeur
Code:

1 2 int a; a=123;
int est un type primitif, a contient 123.
mais quand une variable est de type classe, la variable contient une référence à l'instance de classe
Code:

1 2 String s; s="TOTO";
String est une classe
s ne contient pas "TOTO", mais une référence à une instance de la classe String qui contient une tableau de char qui contient les lettres T, O, T et O.

si tu écris
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public static void main(String[] args) { String s="TOTO"; String s1=s.substring(0,2); String s2=s.substring(0,2); System.out.println("s1 : " + s1); System.out.println("s2 : " + s2); System.out.println("s1==s2 : " + (s1==s2)); System.out.println("s1.equals(s2) : " + s1.equals(s2)); }
tu auras a l'écran :
Code:

1 2 3 4 s1 : TO s2 : TO s1==s2 : false s1.equals(s2) : true
bien sur ton == marchera tant que tu utiliseras uniquement les constantes pour affecter la valeur de couleur (puisqu'en fait tu utiliseras la même référence à chaque fois pour chacune des deux constantes), mais tu risques à un moment que ton test ne marche pas parce que tu compares à une chaine qui n'est pas la constante de départ
avec des String, à moins d'être sur de ton coup, utilise equals
Merci pour ces explications,
Donc je remplace :
.equals par == si j'ai bien compris
Est-ce que je change aussi ici :
Code:

1 2 3 4 5 6 7 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));}
Merci

Citation:
Envoyé par Jordan62
Code:

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 public Case getCase(int colonne, int ligne) { return plateau[colonne][ligne]; } //place les pieces au debut public void debuter() { int ligne = 7; for (String couleur = COULEUR_JOUEUR_NOIR ; !couleur.equals(COULEUR_JOUEUR_BLANC); couleur = COULEUR_JOUEUR_BLANC, ligne = 0){ //J'initialise tout mes pieces de la premieres rangee (tour, cavalier etc...) plateau[0][ligne].setPiece(new Tour(couleur)); plateau[1][ligne].setPiece(new Cavalier(couleur)); plateau[2][ligne].setPiece(new Fou(couleur)); plateau[3][ligne].setPiece(new Reine(couleur)); plateau[4][ligne].setPiece(new Roi(couleur)); plateau[5][ligne].setPiece(new Fou(couleur)); plateau[6][ligne].setPiece(new Cavalier(couleur)); plateau[7][ligne].setPiece(new Tour(couleur)); //Je change de ligne ligne += couleur.equals(COULEUR_JOUEUR_NOIR) ? -1 : 1; //J'initialise tout mes pions. for (int ctr = 0; ctr <= 7; ctr++) plateau[ctr][ligne].setPiece(new Pion(couleur)); } }
Dans ce code, je ne vois pas ou le mettre car on s'interrese qu'au ligne ici
Je n'ai pas trop compris ce qu'il devait y avoir avant
enregistreDeplacement(false);
J'ai compris qu'il fallais parcourir chaque case pour mettre deplacement a faux comme on débute la partie mais je ne vois pas ou le mettre.
ouais effectivement comme il n'y a pas une belle boucle qui boucle sur toutes les pièces, tu ne peux pas intervenir facilement pour boucler sur la liste des pièces : mais tu as de la chance : on voit ici que pour recréer le damier, le code recréer les Piece à zéro par un new
(new Pion(..), new Fou(..), new Tour(...) etc...)
du coup pas la peine de remettre la valeur à zéro, puis qu'elle sera à sa bonne valeur initiale des le départ, comme à la première exécution : comme la variable est un booleen, par défaut elle contient false à l'instanciation donc elle a la bonne valeur

11/06/2013, 15h14
Jordan62

Citation:

Envoyé par joel.drigo

ouais effectivement comme il n'y a pas une belle boucle qui boucle sur toutes les pièces, tu ne peux pas intervenir facilement pour boucler sur la liste des pièces : mais tu as de la chance : on voit ici que pour recréer le damier, le code recréer les Piece à zéro par un new
(new Pion(..), new Fou(..), new Tour(...) etc...)
du coup pas la peine de remettre la valeur à zéro, puis qu'elle sera à sa bonne valeur initiale des le départ, comme à la première exécution : comme la variable est un booleen, par défaut elle contient false à l'instanciation donc elle a la bonne valeur

Enfin un point positif du code... :ccool:

1 pièce(s) jointe(s)

Donc je peux enfin le recompiler,

Mais j'ai toujours le même soucis des cases vertes :

Code:

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.getCase(colonne,ligne).estOccupe(pieceTampon.getCouleur()==(COULEUR_JOUEUR_BLANC) ? COULEUR_JOUEUR_NOIR : COULEUR_JOUEUR_BLANC)){		
								        		tab[colonne][ligne].setCoupPossible(CoupPossible.prisepion);}
								            else if (e.getCase(colonne,ligne).estOccupe() && !e.cheminPossible(deplacement)){
								                tab[colonne][ligne].setCoupPossible(null);
								                }
								            else {
								        		    tab[colonne][ligne].setCoupPossible(CoupPossible.mouvement);
								        		 }
								        } else {
								            tab[colonne][ligne].setCoupPossible(null);
								        }
								}

11/06/2013, 15h34
joel.drigo

envoie le code complet (zip en pièce jointe), j'essayerai de voir pourquoi
11/06/2013, 15h39
joel.drigo

Citation:

Envoyé par Jordan62

Enfin un point positif du code... :ccool:

oui et non

moi j'aurai pas recréer toutes les pièces : j'évite toujours de créer plusieurs fois une même instance qui représente la même chose : je prefère avoir un état (c'est comme si au vrai jeu d'echec tu jetais tes pièces à la poubelle à chaque fin de partie et que tu allais abbatre un arbre pour fabriquer des nouvelles pièces : bien sur ça facilite les choses de faire comme ça, mais c'est pas clean.
y'a pas beaucoup de pièces donc peu d'impact, mais si on faisait ça pour un plus grand nombre d'instances de classes, on aurait des problèmes de performances, à l'instanciation et au garbage recollecting.

imagine que tu veuilles maintenant faire qu'à chaque fois que tu recommences une partie, on ait une animation qui déplace les pièces pour les remettre à la bonne place...
11/06/2013, 15h48
Jordan62

Je comprend qu'il faudrait optimiser mon code mais l'idéal serait qu'il fonctionne car sans vous je serais dans les choux...
Merci

(avec ECLIPSE)

5 pièce(s) jointe(s)

bon c'est ce que je t'avais plus ou fait remarquer : le test du déplacement se fait pas seulement avec estValide mais aussi avec cheminPossible

Piece.estValide(Deplacement) retourne true si le déplacement est possible quelque soit la position des autres pièces

Echiquier.cheminPosible(Deplacement); retour true si la pièce peut se déplacer librement de la position de départ à la position d'arrivée

donc pour commencer :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 if (pieceTampon.estValide(deplacement) && e.cheminPossible(deplacement) ) { if (e.getCase(colonne,ligne).estOccupe(pieceTampon.getCouleur()==(COULEUR_JOUEUR_BLANC) ? COULEUR_JOUEUR_NOIR : COULEUR_JOUEUR_BLANC)){ tab[colonne][ligne].setCoupPossible(CoupPossible.prisepion);} else if (e.getCase(colonne,ligne).estOccupe() /*&& !e.cheminPossible(deplacement)*/){ tab[colonne][ligne].setCoupPossible(null); } else { tab[colonne][ligne].setCoupPossible(CoupPossible.mouvement); } } else { tab[colonne][ligne].setCoupPossible(null); }
permet d'avoir les cases vers lesquelles on peut se déplacer en vert
http://www.developpez.net/forums/att...1&d=1370974462
http://www.developpez.net/forums/att...1&d=1370974462
http://www.developpez.net/forums/att...1&d=1370974462

certaines configurations de prise de pièces fonctionnent :

http://www.developpez.net/forums/att...1&d=1370974462
http://www.developpez.net/forums/att...1&d=1370974462

mais effectivement la prise de pion ne s'affiche pas en rouge

Citation:
Envoyé par joel.drigo
bon c'est ce que je t'avais plus ou fait remarquer : le test du déplacement se fait pas seulement avec estValide mais aussi avec cheminPossible

Piece.estValide(Deplacement) retourne true si le déplacement est possible quelque soit la position des autres pièces

Echiquier.cheminPosible(Deplacement); retour true si la pièce peut se déplacer librement de la position de départ à la position d'arrivée

donc pour commencer :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 if (pieceTampon.estValide(deplacement) && e.cheminPossible(deplacement) ) { if (e.getCase(colonne,ligne).estOccupe(pieceTampon.getCouleur()==(COULEUR_JOUEUR_BLANC) ? COULEUR_JOUEUR_NOIR : COULEUR_JOUEUR_BLANC)){ tab[colonne][ligne].setCoupPossible(CoupPossible.prisepion);} else if (e.getCase(colonne,ligne).estOccupe() /*&& !e.cheminPossible(deplacement)*/){ tab[colonne][ligne].setCoupPossible(null); } else { tab[colonne][ligne].setCoupPossible(CoupPossible.mouvement); } } else { tab[colonne][ligne].setCoupPossible(null); }
permet d'avoir les cases vers lesquelles on peut se déplacer en vert
http://www.developpez.net/forums/att...1&d=1370974462
http://www.developpez.net/forums/att...1&d=1370974462
http://www.developpez.net/forums/att...1&d=1370974462

certaines configurations de prise de pièces fonctionnent :

http://www.developpez.net/forums/att...1&d=1370974462
http://www.developpez.net/forums/att...1&d=1370974462

mais effectivement la prise de pion ne s'affiche pas en rouge
Ouah, merci !!
Faut-il rajouter une condition pour le pion ?

1 pièce(s) jointe(s)

en regardant de plus près la méthode estValide() on se rend compte que le mouvement en diagonal du pion n'est pas considéré comme valide, ce qui n'est pas faux

donc (j'ai un peu refactorisé pour plus de clarté):

Code:

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
for (int ligne = 0; ligne < 8; ligne++) {
  for (int colonne = 0; colonne < 8; colonne++) {
    if ( colonne==temp.getColonne() && ligne==temp.getLigne() ) continue; // une pièce ne peut pas se déplacer sur elle même
        Position pos = new Position(colonne,ligne);
        Deplacement deplacement=new Deplacement(temp,pos);
        
        if (pieceTampon.estValide(deplacement) ) {
          // si la pièce peut effectuer ce déplacement (en la considérant seule sur l'échiquier)
        	if ( e.cheminPossible(deplacement) ) {
            // si la pièce peut se déplacer vers la case d'arrivée, c'est à dire si le chemin est libre
            Deplacement deplacementinverse=new Deplacement(pos,temp);
        		if ( e.getCase(colonne,ligne).estOccupe() ) {
        			// si la case d'arrivée est occupée, alors c'est que c'est une pièce adverse prenable
        			// pas beson de tester la couleur, puisque si la couleur est la couleur du joueur le déplacement n'est pas possible
        		    tab[colonne][ligne].setCoupPossible(CoupPossible.prisepion);
        		}
        		else {
          		// alors le déplacement est possible
        		    tab[colonne][ligne].setCoupPossible(CoupPossible.mouvement);
        		}
        	}
      } else if ( e.captureParUnPionPossible(deplacement) ) {
      	tab[colonne][ligne].setCoupPossible(CoupPossible.prisepion);
      }
    else {
        tab[colonne][ligne].setCoupPossible(null);
    }
  } 
}

11/06/2013, 20h39
Jordan62

1 pièce(s) jointe(s)

Le déplacement du pion est vraiment bizarre...
En position initiale il peux "sauter" au dessus du cavalier...

Grace au boolean qui verifie qu'une piece a deja bougé on pourrait rajouter la condition que s'il a pas encore bougé et qu'il y a une piece devant lui il ne puisse pas sauté au dessus ? (et ainsi enlever la case verte )
Merci

2 pièce(s) jointe(s)

maintenant le roque !

Code:

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
for (int ligne = 0; ligne < 8; ligne++) {
  for (int colonne = 0; colonne < 8; colonne++) {
    if ( colonne==temp.getColonne() && ligne==temp.getLigne() ) continue; // une pièce ne peut pas se déplacer sur elle même
        Position pos = new Position(colonne,ligne);
        Deplacement deplacement=new Deplacement(temp,pos);
        
        if (pieceTampon.estValide(deplacement) ) {
          // si la pièce peut effectuer ce déplacement (en la considérant seule sur l'échiquier)
        	if ( e.cheminPossible(deplacement) ) {
            // si la pièce peut se déplacer vers la case d'arrivée, c'est à dire si le chemin est libre
            Deplacement deplacementinverse=new Deplacement(pos,temp);
        		if ( e.getCase(colonne,ligne).estOccupe() ) {
        			// si la case d'arrivée est occupée, alors c'est que c'est une pièce adverse prenable
        			// pas beson de tester la couleur, puisque si la couleur est la couleur du joueur le déplacement n'est pas possible
        		    tab[colonne][ligne].setCoupPossible(CoupPossible.prisepion);
        		}
        		else {
          		// alors le déplacement est possible
        		    tab[colonne][ligne].setCoupPossible(CoupPossible.mouvement);
        		}
        	}
      } else if ( e.captureParUnPionPossible(deplacement) ) {
      	tab[colonne][ligne].setCoupPossible(CoupPossible.prisepion);
      }else if ( e.isRoquePossible(deplacement) ) {
								        	tab[colonne][ligne].setCoupPossible(CoupPossible.roque);
								        }
    else {
        tab[colonne][ligne].setCoupPossible(null);
    }
  } 
}

et dans echiquier j'ai ajouté la méthode :

Code:

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
public boolean isRoquePossible(Deplacement deplacement) {
		return isPetitRoquePossible(deplacement) ||
		isGrandRoquePossible(deplacement);
	}
 
	public boolean isGrandRoquePossible(Deplacement deplacement) {
		return isRoquePossible(deplacement,true);
	}
	public boolean isPetitRoquePossible(Deplacement deplacement) {
		return isRoquePossible(deplacement,false);
	}
 
	private boolean isRoquePossible(Deplacement deplacement, boolean grand) {
		Piece pieceDeDepart = getCase(deplacement.getDepart().getColonne(),deplacement.getDepart().getLigne()).getPiece();
		Piece pieceDArrivee = getCase(deplacement.getArrivee().getColonne(),deplacement.getArrivee().getLigne()).getPiece();
		if ( pieceDeDepart instanceof Roi && pieceDArrivee instanceof Tour ) {
			// les deux pièces doivent être de la même couleur
			if ( pieceDeDepart.getCouleur().equals(pieceDArrivee.getCouleur() ) ) {
				// aucune des deux pièces ne doit pas avoir bouger
				if ( !pieceDeDepart.aDejaEteDeplaceUneFois() && !pieceDArrivee.aDejaEteDeplaceUneFois() ) {
					// distance horizontale
					int distance = Math.abs(deplacement.getDepart().getColonne()-deplacement.getArrivee().getColonne());
					if ( (distance==4 && grand) || (distance==3 && !grand) ) {
						// toutes les cases doivent être innocupées
						int ligneroque = deplacement.getDepart().getLigne(); // on pourrait utiliser la couleur de la pièce aussi
						// le grand roque va de 0 à 4 (donc les cases entre les deux sont 1,2,3
						// le petit roque va de 4 à 7 (donc les cases entre les deux sont 5,6
						int cased = grand?1:5; 
						int casef = grand?3:6;
						for(int col=cased; col<=casef; col++) {
							if ( getCase(col, ligneroque).estOccupe() ) {
								return false; // case occupee roque impossible
							}
						}
						// on doit vérifier si les cases sont menacées
						// donc occupée par la couleur adverse...
						String couleurAdverse = pieceDeDepart.getCouleur().equals(COULEUR_JOUEUR_BLANC)?COULEUR_JOUEUR_NOIR:COULEUR_JOUEUR_BLANC;
						// ...est qui controle une des cases
						cased--; casef++; // on inclut les cases avec le roi et la tour
						int prisepion=couleurAdverse.equals(COULEUR_JOUEUR_NOIR) ? 1 : -1; // on précalcul cette valeur, parce qu'on va en avoir besoin plusieurs fois
						for(int col=cased; col<=casef; col++) {
							// on va simuler un déplacement avec toutes les cases adverses
							Position positionATester = new Position(col,ligneroque);
							for (int ligne = 0; ligne < 8; ligne++) {
							     for (int colonne = 0; colonne < 8; colonne++) {
							    	 if ( getCase(colonne, ligne).estOccupe(couleurAdverse) ) {
							    		 Deplacement simuleDeplacement = new Deplacement(new Position(colonne, ligne), positionATester);
							    		 if ( getCase(colonne, ligne).getPiece().estValide(simuleDeplacement) && cheminPossible(simuleDeplacement) ) {
							    			// la pièce peut se déplacer, la case est menacé
							    			 return false; // le roque n'est pas possible
							    		 }
							    		 else if ( (simuleDeplacement.getDeplacementY() * 
							    				 Math.abs(simuleDeplacement.getDeplacementX()) == prisepion) ) {
							    			 // le cas de la prise par le pion est traitée à part
							    			 // et on ne peut pas utiliser la méthode captureParUnPionPossible(simuleDeplacement) car elle ne retourne true que si la case est occupée
							    			 // on a simplement reprise la formule utilisée dans cette méthode (on pourrait faire une méthode spéciale pour ce calcul)
							    			 return false; // le roque n'est pas possible
							    		 }
							    	 }
							     }
							}
						}
						return true;
					}
				}
			}
		}
		/* ici on pourrait indiquer si le roque est possible par la tour
        else if (pieceDeDepart instance Tour && pieceDArrivee instanceof Roi) {
           ... 
        }
         */
		return false;
	}

quand les 2 roques sont possibles :
http://www.developpez.net/forums/att...1&d=1370978158

le petit n'est plus possible :

http://www.developpez.net/forums/att...1&d=1370978158

11/06/2013, 21h23
joel.drigo
Citation:

Grace au boolean qui verifie qu'une piece a deja bougé on pourrait rajouter la condition que s'il a pas encore bougé et qu'il y a une piece devant lui il ne puisse pas sauté au dessus ? (et ainsi enlever la case verte )
Merci

c'est de la bidouille ça

Citation:

Envoyé par Jordan62

Le déplacement du pion est vraiment bizarre...
En position initiale il peux "sauter" au dessus du cavalier...

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

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...
11/06/2013, 21h27
Jordan62

Merci vraiment pour tout ...

Vous êtes une personne très aimable !

Voir 40 message(s) de cette discussion en une page