Valeurs de deux ArrayList

Version imprimable

Bonsoir,

Je suis en train d'essayer de comprendre un morceau de code suite à avoir suivi un tutoriel pour créer un sokoban en 2D.
Mais je bloque sur un test... :oops:

Le principe est simple un cristal doit toucher un objectif pour qu'il passe en "objectif atteint".

J'ai donc une ArrayList d'Obectifs et une ArrayList de Crystaux, au chargement de la map elles s'initialisent correctement mais malheureusement je bloque sur un test qui concerne les collisions.

Voici mon code qui gère les collisions entre le cristal et l'objectif :
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 for (int i = 0; i < Objectifs.size(); i++){ objectif = Objectifs.get(i); Rectangle objectifRec = objectif.getBounds(); for (int j = 0; j < Crystaux.size(); j++){ crystal = Crystaux.get(i); Rectangle crystalRec = crystal.getBounds(); // Si le rectangle de crystal intersecte le rectangle de objectif if (crystalRec.intersects(objectifRec) && !crystal.getJuste() && !objectif.getDessus()){ crystal.setEtat("OBJECTIF"); crystal.setJuste(true); objectif.setDessus(true); } // Si on enlève un crystal d'un objectif il redevient à l'état normal else if (!crystalRec.intersects(objectifRec) && crystal.getJuste() && objectif.getDessus()){ crystal.setEtat("NORMAL"); crystal.setJuste(false); objectif.setDessus(false); } } }
Avec ce code, je test bien si un cristal entre en collision avec un objectif mais seulement sur 1 objectif.
C'est à dire que j'aimerais que le cristal puisse aller sur tout les objectifs et non seulement celui de i.

Un petit exemple : J'ai 3 cristaux et 3 objectifs, mon premier cristal ne peut pas être posé sur tout les objectifs mais seulement sur 1 seul. Idem pour les autres.

Je ne vois pas du tout comment tester si un cristal de son ArrayList rencontre un objectif de l'ArrayList Objectifs. :?

Je ne sais pas si cela est très clair, je cherche une piste comment tester les éléments des 2 ArrayList entre eux et non seulement 1 à 1.

En espérant avoir choisi la bonne section, je pense que c'est plus un problème d'analyse qu'autre chose.

Merci d'avance de votre aide.

23/11/2013, 22h53
joel.drigo

Salut,

tu as justes fait une petite erreur dans :

Code:

crystal = Crystaux.get(i);

C'est j, pas i.
24/11/2013, 01h21
Caypamoi

4 pièce(s) jointe(s)

En effet je te remercie.

Mais lorsque je met j, cela permet en effet de sélectionner un crystal sur n'importe quel objectif comme je le souhaite sauf que cela ne marche qu'avec le premier crystal/objectif.

Je pense que je comprend très mal ce qu'il se passe. Je continue à chercher d’où cela peut venir.

Voilà un petit exemple :

Lorsque le premier Rectangle de crystal intersecte avec le premier Rectangle de Objectif :

Pièce jointe 131548

Pièce jointe 131549

Pièce jointe 131551

Et lorsque je tente avec un deuxième crystal :

Pièce jointe 131552

Je pense que je vais devoir chercher autre part pour résoudre ce problème.
Si quelqu'un à une piste ou je pourrais regarder je suis preneur :roll:

Merci d'avance.
24/11/2013, 01h38
joel.drigo

Sans avoir tout le code, je ne peux que supputer;)
Je me dis que dans la mesure ou tes conditions combinent un test d'intersection et 2 tests d'états, et que l'intersection semblent bien fonctionner, puisque chaque cristal peut bien être posé sur chaque objectif, si aucun autre cristal l'est, le problème vient des tests des états. Et la, je pense automatiquement : static ! Si tes variables d'état (juste et audessus) sont statiques, lorsque tu modifies la valeur pour une instance de cristal, ou d'objectif, tu le modifies pour toutes les instances, et du coup aucune de tes conditions ne peut plus être vraie (il est possible que seul l'un des 2 états est statique).

Oui c'est vrai qu'avec le peu de code que j'ai fourni cela n'est pas facile à comprendre... :?

Oui, le test d'intersection fonctionne bien pour le premier.

Merci pour cette réponse, je me suis dépêché de vérifier mes variables d'Etat mais aucune des deux est static

Voici le code de Crystal.java :

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
public class Crystal {
 
	int x, y;
 
	// Etat du crystal au lancement
	String Etat = "NORMAL";
 
	Image Crystal;
	ImageIcon iCrystalNormal = new ImageIcon("Images/Objets/Crystal.png");
	ImageIcon iCrystalObjectif = new ImageIcon("Images/Objets/Objectifok.gif");
 
	// Statut de l'objectif
	boolean objectifJuste = false;
 
	public Crystal(int Startx, int Starty){
		x = Startx;
		y = Starty;
	}
 
	public Rectangle getBounds(){
		Rectangle Box = new Rectangle(x, y, 28, 28);
		return Box;
	}
 
	public int getX(){
		return x;
	}
 
	public int getY(){
		return y;
	}
 
	public void setX(int newX){
		this.x = newX;
	}
 
	public void setY(int newY){
		this.y = newY;
	}
 
	public boolean getJuste(){
		return objectifJuste;
	}
 
	public void setJuste(boolean newJuste){
		this.objectifJuste = newJuste;
	}
 
	public String getEtat(){
		return Etat;
	}
 
	public void setEtat(String newEtat){
		this.Etat = newEtat;
	}
 
	public Image getImage(){
		if(Etat == "NORMAL"){
			Crystal = iCrystalNormal.getImage();
 
		}
		else if(Etat == "OBJECTIF"){
			Crystal = iCrystalObjectif.getImage();
		}
		return Crystal;
	}
}

et celui de Objectif.java :

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
public class Objectif {
 
	int x, y;
	Image Objectif;
	boolean CrystalDessus = false;
 
 
	public Objectif(int Startx, int Starty){
		x = Startx;
		y = Starty;
 
		ImageIcon iObjectif = new ImageIcon("Images/Objets/Objectif.gif");
		Objectif = iObjectif.getImage();
	}
 
	public Rectangle getBounds(){
		Rectangle Box = new Rectangle (x, y, 28, 28);
		return Box;
	}
 
	public boolean getDessus(){
		return CrystalDessus;
	}
 
	public void setDessus(boolean newDessus){
		this.CrystalDessus = newDessus;
	}
 
	public int getX(){
		return x;
	}
 
	public int getY(){
		return y;
	}
 
	public Image getImage(){
		return Objectif;
	}
 
}

Les seules variables static sont celles de mes ArrayList dans la classe principale du jeu :

Code:

1
2
3
private static ArrayList<Mur> Murs;
private static ArrayList<Objectif> Objectifs;
private static ArrayList<Crystal> Crystaux;

Je pense que je vais modifier la classe Crystal et Objectif, et résoudre un petit problème de collision que je vient de découvrir : lorsque que je colle un crystal à un autre et que je le déplace dans sa direction le premier crystal disparait.

Je vous tiendrais au courant si mes problèmes sont résolus.

Merci encore pour l'aide ;)

EDIT : Lorsque je laisse i dans la boucle, un crystal est lié avec un objectif.

Et tout les objectifs sont bon lorsque le bon crystal est posé dessus.

24/11/2013, 13h51
joel.drigo
J'ai relu ton code et je me dis que ce code pose un problème :
Code:

1 2 3 4 5 if (!crystalRec.intersects(objectifRec) && crystal.getJuste() && objectif.getDessus()){ crystal.setEtat("NORMAL"); crystal.setJuste(false); objectif.setDessus(false); }
Quand il n'y a pas collision entre le cristal et l'objectif j, et qu'il y a un cristal k!=i sur l'objectif j, tu modifies quand même l'état de l'objectif j (setDessus(false)), ce qui n'est pas correct à priori. Il faudrait le faire uniquement si le cristal posé sur l'objectif est le même que celui qu'on est en train de tester.

D'ailleurs, je ne comprends pas pourquoi tu gères un second état etat, alors que juste serait suffisant pour savoir qu'un cristal est sur un objectif, non ?

Tu pourrais d'ailleurs utiliser à la place de tes états etat, juste et dessus, un pointeur :
- le cristal à un pointeur sur un objectif (ou null s'il n'est pas sur un objectif)
- un objectif a un pointeur sur un cristal (ou null s'il n'y a pas de cristal dessus)
24/11/2013, 15h56
Caypamoi

Oui ce code et plus particulièrement le SetDessus(false) me permet de gérer le cas ou le joueur enlève la caisse de l'objectif déjà complété.

Et le setJuste me permet de vérifier si le crystal courant est bien validé. Mais à vrai dire si il est en statut "OBJECTIF", cela revient à dire qu'il est true, donc le setJuste n'aurait aucune utilité ? :roll:

J'avoue ne pas comprendre comment faire pour que le cristal ai un pointeur sur un objectif et que l'objectif ai un pointeur sur un cristal.

Je me retrouve un peu perdu dans le code avec tout sa, je tente de reprendre tout depuis le début et bien vérifier les variables et leurs utilités tout en gardant sous le coude ta réponse ;)

Merci

Je voulais juste dire, par pointeurs, qu'au lieu de gérer des booléens qui veulent dire "quelque chose", tu peux tout aussi bien dire "la même chose" avec des instances de Objectif ou Crystal.

Par exemple, au lieu de :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Objectif {
 
        ... 
	boolean CrystalDessus = false;
 
 
	public Objectif(int Startx, int Starty){
	}
 
        ... 
 
	public boolean getDessus(){
		return CrystalDessus;
	}
 
	public void setDessus(boolean newDessus){
		this.CrystalDessus = newDessus;
	}
 
        ...
 
}

Tu fais :

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
public class Objectif {
 
        ... 
	 Crystal  crystalDessus;
 
 
	public Objectif(int Startx, int Starty){
	}
 
        ... 
 
        public boolean aCrystalDessus() {
             return crystalDessus!=null;
        }
 
	public Crystal  getDessus(){
		return crystalDessus;
	}
 
	public void setDessus(Crystal newDessus){
		this.crystalDessus = newDessus;
	}
 
        ...
 
}

Pareil dans Crystal, mais avec une variable de type Objectif.

Et ainsi, en plus tu peux tester quel cristal se trouve sur l'objectif :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
// Si le rectangle de crystal intersecte le rectangle de objectif
				if (crystalRec.intersects(objectifRec) && !crystal.estJuste() && !objectif.aCrystalDessus()){
					crystal.setEtat("OBJECTIF"); // à supprimer à mon avis
					crystal.setJuste(objectif);
					objectif.setDessus(cristal);
 
				}
				// Si on enlève un crystal d'un objectif il redevient à l'état normal
				else if (!crystalRec.intersects(objectifRec) && crystal.estJuste() && cristal.equals(objectif.getDessus()) ){
					crystal.setEtat("NORMAL"); // à supprimer à mon avis
					crystal.setJuste(null);
					objectif.setDessus(null);
				}

24/11/2013, 19h05
Caypamoi
Je pense avoir réussi grâce à ton aide, je te remercie c'est vraiment sympa !

Je regarde un peu tout sa en détail ce soir car il y a quelques méthodes ou je bloque dans la compréhension mais de ce que j'ai pu rapidement tester :
- N'importe quel crystal peut aller sur n'importe quel objectif
- Un crystal enlevé d'un objectif redevient bien à l'état "crystal"
- Et ma méthode qui vérifie si le niveau est complété est maintenant beaucoup plus logique et fonctionne.
Je te tiens au courant au plus vite :ccool:

Merci

2 pièce(s) jointe(s)

Bonjour,

Après avoir bien regardé tout sa, tout est bon.

J'ai seulement un petit doute avec le else if :
Code:

1 2 3 4 else if (!crystalRec.intersects(objectifRec) && crystal.estDessus() && crystal.equals(objectif.getDessus())){ crystal.setDessus(null); objectif.setDessus(null); }
Si je comprend bien, on teste si le Rectangle de crystal n'intersecte plus avec celui de objectif. Si le crystal n'est pas null et si le crystal est bien celui qui est sur l'objectif ? :roll:

Cela peut paraitre simple mais je bloque dessus. :oops:

Autre chose, je me suis dit que grâce à cela je pourrais maintenant m'attaquer au cas ou le crystal rencontre un autre crystal. (que je n'ai pas géré).

Tout d’abord je me suis dit que j'allais gérer cette collision comme celle de mon personnage.

Ex : Si mon personnage intersecte un crystal et qu'il tente de descendre alors il vérifie s'il y a pas un mur derrière pour descendre le crystal.

En voici un extrait :
Code:

1 2 3 4 5 6 7 8 9 10 11 if (personnageRec.intersects(crystalRec)){ if(personnage.getDir() == "BAS"){ // Si il n'y a pas de mur derrière le crystal, il descend ( + sur l'axe Y = descendre) if(Game[crystalRec.x / 28][(crystalRec.y + 28) / 28] != "MUR"){ crystal.setY(crystal.getY() + 28); } // Sinon si il y a un mur on ramène le personnage à son emplacement else if (Game[crystalRec.x / 28][(crystalRec.y + 28) / 28] == "MUR"){ personnage.setY(personnage.getY() - 28); } }
Je me suis dit qu'en rajoutant un test dans la condition if cela marcherais étant donné que je souhaite tester si il y a un crystal derrière comme le cas d'un mur :

Code:

&& (Game[crystalRec.x / 28][(crystalRec.y + 28) / 28] != "CRYSTAL")

Mais vu que je teste cela sur une collection de string initialisé au début du jeu, le crystal bloque sur les cases d'initialisation des crystaux.
Avec les murs le problème n'existe pas puisqu'ils ne bougent pas

Un petit exemple :

Image du début niveau :
Pièce jointe 131644

Image qui montre ou le cristal bloque (à l'endroit ou s'initialise le premier) :
Pièce jointe 131645

Après cela j’exclus la possibilité de tester la collision par rapport à la Game[][] mais je pense plus a tester la collision avec un autre crystal de cette manière :
Code:

1 2 if (crystalRec.intersects(crystalRec2)){ }
Pour le moment je ne comprend pas comment tester un si un crystal rencontre un autre crystal mais je cherche. :D.

Merci d'avance.

25/11/2013, 15h45
joel.drigo
Citation:
Envoyé par Caypamoi

Bonjour,

Après avoir bien regardé tout sa, tout est bon.

J'ai seulement un petit doute avec le else if :

Code:

1 2 3 4 else if (!crystalRec.intersects(objectifRec) && crystal.estDessus() && crystal.equals(objectif.getDessus())){ crystal.setDessus(null); objectif.setDessus(null); }

Si je comprend bien, on teste si le Rectangle de crystal n'intersecte plus avec celui de objectif. Si le crystal n'est pas null et si le crystal est bien celui qui est sur l'objectif ? :roll:

Cela peut paraitre simple mais je bloque dessus. :oops:
C'est exactement ça :
1. pas d'intersection
2. si le cristal est sur un objectif (cristal.objectif!=null)
3. si le cristal de l'objectif est bien celui qu'on teste
On pourrait s'abstenir de faire le test 2, parce que le test 3 est forcément faux si le cristal n'est pas sur un objectif (et que tout est cohérent).
25/11/2013, 15h51
joel.drigo
Citation:

Envoyé par Caypamoi

Pour le moment je ne comprend pas comment tester un si un crystal rencontre un autre crystal mais je cherche. :D.

Soit tu fais évoluer ta grille au fur et à mesure des déplacements de cristaux, soit tu testes par intersection. Une simple double boucle :
Code:

1 2 3 4 5 6 7 pour tout les cristaux c1 pour tout les cristaux c2 si c1 différent de c2 et intersection de c1 et c2 alors collision fin si fin pour fin pour
PS: évite de tester l'égalité de chaînes de caractères par == : préfères le .equals(), tu auras moins de problèmes (ça peut fonctionner dans certains cas, mais pas dans le cas général).

Ok, je te remercie pour l'explication.
Oui, le deuxième test est un moyen d'être vraiment sur qu'il n'y est pas d'erreur.

J'ai donc essayé de traiter les collisions entre cristaux avec une double boucle mais sans réussite.

Le problème c'est qu'il faudrait plusieurs instances de Crystal qui correspondent au nombre de crystaux sur la grille,.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 for (int i = 0; i < Crystaux.size(); i++){ crystal = Crystaux.get(i); Rectangle crystalRec = crystal.getBounds(); for (int j = 0; j < Crystaux.size(); j++){ crystal = Crystaux.get(j); Rectangle crystalRec2 = crystal.getBounds(); // Tests si le Rectangle de personnage rencontre le Rectangle de crystal if (personnageRec.intersects(crystalRec)){ if(personnage.getDir() == "BAS"){ // Si il n'y a pas de mur derrière le crystal, il descend ( + sur l'axe Y = descendre) if(Game[crystalRec.x / 28][(crystalRec.y + 28) / 28] != "MUR" && !crystalRec.intersects(crystalRec2) ){ crystal.setY(crystal.getY() + 28); } // Sinon si il y a un mur on ramène le personnage à son emplacement else if (Game[crystalRec.x / 28][(crystalRec.y + 28) / 28] == "MUR" && crystalRec != crystalRec2 && crystalRec.intersects(crystalRec2) ){ personnage.setY(personnage.getY() - 28); } }
Voilà un code auquel j'avais pensé mais cela ne gère pas du tout ce que je souhaite, je vais y réfléchir et surtout commencer par tester l'égalité des chaînes de caractères avec le .equals().

Si jamais je bloque je ferais évoluer la grille, ce qui me semble être une meilleure solution. ;)

Merci pour l'astuce :ccool:

25/11/2013, 20h08
joel.drigo

Citation:

Envoyé par Caypamoi

Le problème c'est qu'il faudrait plusieurs instances de Crystal qui correspondent au nombre de crystaux sur la grille

Ce serait mieux en effet, mais si tu gères tes cristaux comme une simple liste de coordonnées et d'états (je suppose que c'est ça, parce que sinon je vois pas trop comment tu gères plusieurs cristaux qui sont à des endroits différents et leurs états (dessus)).

Le plus simple, à mon avis, est de faire un tableau à 2 dimensions de booléens : les cases false serait vides, les cases avec cristal serait true (si on ne peut mettre qu'un seul cristal par case).

Du coup, le test serait juste une combinaison du test d'occupation de la grille avec les murs et du test d'occupation de la grille avec les cristaux :

Il faudrait juste veiller à bien mettre à jour cette grille, quand tu déplaces un cristal (l'enlever de la dernière position, le mettre à la nouvelle).

Bonjour,

Encore merci pour cette aide précieuse ! Tout marche correctement désormais, l'idée du tableau de boolean m'a vraiment aidé.

Je poste ce que j'ai modifié, si jamais cela peut servir à quelqu'un d'autres un jour :

Déclaration d'un tableau à 2 dimension de booléens :

Code:

boolean CristauxPlace[][] = new boolean [12][12];

A la lecture du fichier, pour compléter le tableau de booléen :

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
public void ChargerLevel(){
		try{
			// Instancie le fichier du level concerné
			fr = new FileReader("Maps/level" + Level + ".level");
			int x = 0, y = 0, i = 0;
 
			// Initialisation des collections
			Murs = new ArrayList<Mur>();
			Crystaux = new ArrayList<Crystal>();
			Objectifs = new ArrayList<Objectif>();
 
			// Tant que -1 on continue à lire le fichier
			while((i = fr.read()) != -1){
				char strImg = (char) i;
 
				// On ajoute dans la collection de string du jeu
				if (strImg == '0'){
					Game[x][y] = "PERSONNAGE";
					CristauxPlace[x][y] = false;
					personnage = new Personnage(x * 28, y * 28);
				}
				else if (strImg == '1'){
					Game[x][y] = "CRYSTAL";
					CristauxPlace[x][y] = true;
					crystal = new Crystal(x * 28, y * 28);
					Crystaux.add(crystal);
				}
				else if (strImg == '2'){
					Game[x][y] = "OBJECTIF";
					CristauxPlace[x][y] = false;
					objectif = new Objectif(x * 28, y * 28);
					Objectifs.add(objectif);
				}
				else if (strImg == '3'){
					Game[x][y] = "MUR";
					CristauxPlace[x][y] = false;
					mur = new Mur(x * 28, y * 28);
					Murs.add(mur);
				}
				else if (strImg == ' '){
					Game[x][y] = null;
					CristauxPlace[x][y] = false;
				}
				// Retour à la ligne pour repartir depuis l'index que l'on a besoin
				else if (strImg == '\r' || strImg == '\n'){
					x--;
				}
 
				if (x == 11){
					// On passe a la ligne suivante
					y++;
					// Remise a 0
					x = 0;
				}
				else{
					x++;
				}
			}
		}
		catch(Exception ex){
 
		}
		repaint();
	}

La gestion des collisions :

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
for (int i = 0; i < Crystaux.size(); i++){
			crystal = Crystaux.get(i);
			Rectangle crystalRec = crystal.getBounds();
 
			// Tests si le Rectangle de personnage rencontre le Rectangle de crystal
			if (personnageRec.intersects(crystalRec)){
				if(personnage.getDir() == "BAS"){
					// Si il n'y a pas de mur derrière le crystal, il descend ( + sur l'axe Y = descendre)
					if(Game[crystalRec.x / 28][(crystalRec.y + 28) / 28] != "MUR" && CristauxPlace[crystalRec.x / 28][(crystalRec.y + 28) / 28] == false){
						crystal.setY(crystal.getY() + 28);
 
						CristauxPlace[crystalRec.x / 28][crystalRec.y / 28] = false;
						CristauxPlace[crystalRec.x / 28][(crystalRec.y + 28) / 28] = true;
					}
					// Sinon si il y a un mur on ramène le personnage à son emplacement
					else if (Game[crystalRec.x / 28][(crystalRec.y + 28) / 28] == "MUR" || CristauxPlace[crystalRec.x / 28][(crystalRec.y + 28) / 28] == true){
						personnage.setY(personnage.getY() - 28);
					}
				}
				else if (personnage.getDir() == "HAUT"){
					if(Game[crystalRec.x / 28][(crystalRec.y - 28) / 28] != "MUR"  && CristauxPlace[crystalRec.x / 28][(crystalRec.y - 28) / 28] == false){
						crystal.setY(crystal.getY() - 28);
 
						CristauxPlace[crystalRec.x / 28][crystalRec.y / 28] = false;
						CristauxPlace[crystalRec.x / 28][(crystalRec.y - 28) / 28] = true;
					}
					else if (Game[crystalRec.x / 28][(crystalRec.y - 28) / 28] == "MUR" || CristauxPlace[crystalRec.x / 28][(crystalRec.y - 28) / 28] == true){						
						personnage.setY(personnage.getY() + 28);
					}
				}
				else if (personnage.getDir() == "DROITE"){
					if(Game[(crystalRec.x + 28) / 28][crystalRec.y / 28] != "MUR" && CristauxPlace[(crystalRec.x + 28) / 28][crystalRec.y / 28] == false){
						crystal.setX(crystal.getX() + 28);
 
						CristauxPlace[crystalRec.x / 28][crystalRec.y / 28] = false;
						CristauxPlace[(crystalRec.x + 28) / 28][crystalRec.y / 28] = true;
					}
					else if (Game[(crystalRec.x + 28) / 28][crystalRec.y / 28] == "MUR" || CristauxPlace[(crystalRec.x + 28) / 28][crystalRec.y / 28] == true){
						personnage.setX(personnage.getX() - 28);
					}
				}	
				else if (personnage.getDir() == "GAUCHE"){
					if(Game[(crystalRec.x - 28) / 28][crystalRec.y / 28] != "MUR" && CristauxPlace[(crystalRec.x - 28) / 28][crystalRec.y / 28] == false){
						crystal.setX(crystal.getX() - 28);
 
						CristauxPlace[crystalRec.x / 28][crystalRec.y / 28] = false;
						CristauxPlace[(crystalRec.x - 28) / 28][crystalRec.y / 28] = true;
					}
					else if (Game[(crystalRec.x - 28) / 28][crystalRec.y / 28] == "MUR" || CristauxPlace[(crystalRec.x - 28) / 28][crystalRec.y / 28] == true){		
						personnage.setX(personnage.getX() + 28);
 
					}
				}
			}
		}

Problème résolu.

Merci à toi joel. :ccool: