[Jeu de la vie] : problème de coloration

**willtc** · 25/11/2015, 17h22

Bonjour,

Je traîne un problème de coloration depuis plusieurs heures et je n'arrive pas à trouver la solution, je commence un peu à déprimer et je dois présenter ce travail demain (...

), voici la partie du code qui pose problème :

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
 import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Random;
 
import javax.swing.JOptionPane;
 
public class Board{
	private int xg = 60;
	private int yg = 40;
	int gol[][] = new int [xg][yg];
	// private int golX[][] = new int [xg][yg];
	private int golY[][] = new int [xg][yg];
 
	// récupère les modifications effectuées sur l'interface graphique
	public void graphToBoard(int pos, int state){
		int x = pos % 60;
		int y = Math.abs(pos/60);
 
		this.gol[x][y] = state;
	}
 
	// initialise toutes les cellules à mortes
	public void initDef(){
		for(int y = 0 ; y < this.yg ; y++){
			for(int x = 0 ; x < this.xg ; x++){
				this.gol[x][y] = 0;
			}
		}
	}
 
	// définit une valeur aléatoire pour chaque cellule du board
	public void rdm(){		
		for (int y = 0; y < this.yg ; y++){
			for (int x = 0; x < this.xg ; x++){
				int valeurMax = 2;
				int valeurMin = 1;
				Random r = new Random();
				int target = valeurMin + r.nextInt(valeurMax);
 
				if(target == 1){
					this.gol[x][y] = 1;
				}
				else{
					this.gol[x][y] = 0;
				}
			}
		}
	}
 
	// initialise le tableau en fx d'une conf initiale (chargement fichier txt)
	public void conf(String res){
		int x, y = 0, z;
 
		try{
			InputStream is = new FileInputStream(res);
			InputStreamReader isr = new InputStreamReader(is);
			BufferedReader br = new BufferedReader(isr);
 
			String line = br.readLine();
 
			while(line != null){
				for(x = 0 ; x < 60 ; x++){
					z = Integer.parseInt("" + line.charAt(x));
					this.gol[x][y] = z;
				}
 
				line = br.readLine();
				y++;
			}
 
			br.close();
			isr.close();
			is.close();
		} catch (Exception e){
			e.printStackTrace();
			JOptionPane.showMessageDialog (null, "Erreur lors du chargement de la partie", "Oops !", JOptionPane.ERROR_MESSAGE);
		}
	}
 
	// traitements pour une génération
	public void generation(){
 
		/*
		// pour golX : n-2, golY : n-1, gol : n
		for(int i = 0 ; i < this.yg ; i++){
			for(int j = 0 ; j < this.xg ; j++){
				this.golX[j][i] = this.golY[j][i];
			}
		}
		*/
 
		// effectue les operations necessaires sur la generation actuelle
		for(int i = 0 ; i < this.yg ; i++){
			for(int j = 0 ; j < this.xg ; j++){
				this.golY[j][i] = this.gol[j][i];
			}
		}
 
		// determine les cellules vivantes et mortes
		for(int y = 0 ; y < this.yg ; y++){
			for(int x = 0 ; x < this.xg ; x++){
				lifeDeath(x, y);
			}
		}	
 
 
 
		// determine la coloration des cellules
		for(int y = 0 ; y < this.yg ; y++){
			for(int x = 0 ; x < this.xg ; x++){
				lifeDeathC(x, y);
			}
		}
 
 
	}
 
	// selon le nbre de voisins, définit à vivant ou mort
	public void lifeDeath(int x, int y){
		int bnc = this.neighbourCount(x, y, this.golY);
 
		// verifie condition mort
		if((bnc < 2) || (bnc > 3)){
			this.gol[x][y] = 0;
		}
		// verifie condition vie
		else if(bnc == 3){
			this.gol[x][y] = 1;
		}
	}
 
	// reprend les cellules vivantes de la generation pour les colorer
	public void lifeDeathC(int x, int y){		
		int bnc = this.neighbourCount(x, y, this.golY);
 
		if(bnc == 3){
			this.coloration(x, y);
		}
	}
 
	// attribue des valeurs differentes aux cellules pour determiner la coloration
	public void coloration(int x, int y){
		int bnc = this.neighbourCount(x, y, this.gol);
 
		// vert : cellules naissantes (et qui ne meurt pas à la gen suivante)
 
		// 1 : ne passe pas à bleu si a déjà vécu une gén et a deux cellules voisines
		// 2 : parfois, passe vert et disparait sans passer par rouge
		// 3 : parfois, passe vert au lieu jaune (?)
		// 4 : parfois, passe bleu et disparait sans passer par rouge
 
		if(this.golY[x][y] == 0 && (bnc ==  3 || bnc == 2)){
			this.gol[x][y] = 1;
		}
 
		// bleu : cellules en cours de vie (si a vécu à la dernière gen et continue de vivre à la gen suivante
		if((this.golY[x][y] == 1 || this.golY[x][y] == 2) && (bnc ==  3 || bnc == 2)){
			this.gol[x][y] = 2;
		}
 
		// rouge : cellules mourantes (a survécu plus d'une gen et meurt gen suivante)
		if((this.golY[x][y] == 1 || this.golY[x][y] == 2) && ((bnc < 2) || (bnc > 3))){
			this.gol[x][y] = 3;
		}
 
		// jaune : cellule ne vivant qu'une génération
		if(this.golY[x][y] == 0 && ((bnc < 2) || (bnc > 3))){
			this.gol[x][y] = 4;
		}
	}
 
	// gestion des valeurs négatives
	public static int mod (int x, int m){
		// ex. 1 : mod(y-1, yg), y = 0, yg = 40
			// ((0-1) % 40 + 40) % 40 = 0
		// ex. 2 : mod(y-1, yg), y = 4, yg = 40
			// ((5-1) % 40 + 40) % 40 = 4
		return (x % m + m) % m;
	} 
 
	// compte le nbre de voisins pour une cellule(x, y)
	public int neighbourCount(int x, int y, int gol[][]){
		int nC = 0; 
 
		// haut
		if(y-1 >= 0 && checkValues(gol, x, mod(y-1, yg))){
			nC++;
		}
 
		// bas
		if(y+1 < 40 && checkValues(gol, x, mod(y+1, yg))){
			nC++;
		}
 
		// gauche
		if(x-1 >= 0 && checkValues(gol, mod(x-1, xg), y)){
			nC++;
		}
 
		// droite
		if(x+1 < 60 && checkValues(gol, mod(x+1, xg), y)){
			nC++;
		}
 
		// haut gauche
		if(x-1 >= 0 && y-1 >= 0 && checkValues(gol, mod(x-1, xg), mod(y-1, yg))){
			nC++;
		}
 
		// haut droite
		if(x+1 < 60 && y-1 >= 0 && checkValues(gol, mod(x+1, xg), mod(y-1, yg))){
			nC++;
		}
 
		// bas gauche
		if(x-1 >= 0 && y+1 < 40 && checkValues(gol, mod(x-1, xg), mod(y+1, yg))){
			nC++;
		}
 
		// bas droite
		if(x+1 < 60 && y+1 < 40 && checkValues(gol, mod(x+1, xg), mod(y+1, yg))){
			nC++;
		}
 
		return nC;
	}
 
	// renvoie vrai si la concernée est vivante (une des quatre couleurs)
	public boolean checkValues(int gol[][], int x, int y){
		boolean check = false;
 
		if(gol[x][y] == 1 || gol[x][y] == 2 || gol[x][y] == 3 || gol[x][y] == 4){
			check = true;
		}
 
		return check;
	}
}

Le problème se situe à priori au niveau de la méthode coloration() et des variables qu'elle utilise, j'ai relevé plusieurs erreurs (pas forcément exhaustif) :

// 1 : ne passe pas à bleu si a déjà vécu une gén et a deux cellules voisines
// 2 : parfois, passe vert et disparait sans passer par rouge
// 3 : parfois, passe vert au lieu jaune
// 4 : parfois, passe bleu et disparait sans passer par rouge

Merci d'avance pour votre attention

**joel.drigo** · 25/11/2015, 17h54

Salut,

Tu parles de coloration, de bleu, de vert... et tu utilises des int à priori pour représenter ça... ce serait plus simple pour nous et plus structuré pour toi si tu utilisais des constantes pour représenter ces "couleurs". Et pour les dimensions aussi (40 et 60), que tu as fait à moitié (xg et yg ne sont pas utilisés partout où il faudrait), et toutes ces valeurs constantes.
Comme par exemple :

Code :

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

public static final int BLEU = 2;

et pour l'affectation

Code :

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

this.gol[x][y] = BLEU;

Ainsi, on n'aurait pas à passer des heures à essayer de comprendre tout ton code et on t'aiderait plus volontiers. Soit également plus explicite dans la description du problème. Par exemple, tu nous dit : "1 : ne passe pas à bleu si a déjà vécu une gén et a deux cellules voisines", mais qu'est-ce qui se passe d'autre ?

Il y a un problème avec ces tests : l'effet se cumul, donc c'est comme si tu avais plusieurs générations dans une dans certains cas. Si la première condition est vraie alors this.gol[x][y] change,

Sinon, vite vu (ce n'est peut-être pas ça), mais avec int bnc = this.neighbourCount(x, y, this.gol);, tu détermines le voisinage sur le tableau gol et dans

Code :

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

1
2
3
if(this.golY[x][y] == 0 && (bnc ==  3 || bnc == 2)){
			this.gol[x][y] = 1;
		}

tu contrôle l'état de la cellule dans le tableau golY et tu modifies gol... donc le voisinage de la cellule suivante sera fait sur un tableau en cours de modification incomplet. Le voisinage ne devrait-il pas être évalué sur golY ? Ici, tu vois si le nom des tableaux était, par exemple, generationActuelle et nouvelleGeneration, l'erreur sauterait aux yeux, à défaut de ne même pas être faite.

Par ailleurs ta fonction de cyclage sur les coordonnées peut être simplifiée : return (x + m) % m;

**willtc** · 25/11/2015, 18h17

Salut joel.drigo,

Merci pour ta réponse.

Comme suggéré, j'ai mis le code à jour :

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Random;
 
import javax.swing.JOptionPane;
 
public class Board{
	// dimensions
	private int xg = 60;
	private int yg = 40;
 
	// generation actuelle
	int gol[][] = new int [xg][yg];
 
	// copie de la generation actuelle
	private int golCopy[][] = new int [xg][yg];
 
	// etat des cellules
	public static final int BLANC = 0;
	public static final int VERT = 1;
	public static final int BLEU = 2;
	public static final int ROUGE = 3;
	public static final int JAUNE = 4;
 
	// récupère les modifications effectuées sur l'interface graphique
	public void graphToBoard(int pos, int state){
		int x = pos % 60;
		int y = Math.abs(pos/60);
 
		this.gol[x][y] = state;
	}
 
	// initialise toutes les cellules à mortes
	public void initDef(){
		for(int y = 0 ; y < this.yg ; y++){
			for(int x = 0 ; x < this.xg ; x++){
				this.gol[x][y] = 0;
			}
		}
	}
 
	// définit une valeur aléatoire pour chaque cellule du board
	public void rdm(){		
		for (int y = 0; y < this.yg ; y++){
			for (int x = 0; x < this.xg ; x++){
				int valeurMax = 2;
				int valeurMin = 1;
				Random r = new Random();
				int target = valeurMin + r.nextInt(valeurMax);
 
				if(target == 1){
					this.gol[x][y] = 1;
				}
				else{
					this.gol[x][y] = 0;
				}
			}
		}
	}
 
	// initialise le tableau en fx d'une conf initiale (chargement fichier txt)
	public void conf(String res){
		int x, y = 0, z;
 
		try{
			InputStream is = new FileInputStream(res);
			InputStreamReader isr = new InputStreamReader(is);
			BufferedReader br = new BufferedReader(isr);
 
			String line = br.readLine();
 
			while(line != null){
				for(x = 0 ; x < 60 ; x++){
					z = Integer.parseInt("" + line.charAt(x));
					this.gol[x][y] = z;
				}
 
				line = br.readLine();
				y++;
			}
 
			br.close();
			isr.close();
			is.close();
		} catch (Exception e){
			e.printStackTrace();
			JOptionPane.showMessageDialog (null, "Erreur lors du chargement de la partie", "Oops !", JOptionPane.ERROR_MESSAGE);
		}
	}
 
	// traitements pour une génération
	public void generation(){
 
		// effectue les operations necessaires sur la generation actuelle
		for(int i = 0 ; i < this.yg ; i++){
			for(int j = 0 ; j < this.xg ; j++){
				this.golCopy[j][i] = this.gol[j][i];
			}
		}
 
		// determine les cellules vivantes et mortes
		for(int y = 0 ; y < this.yg ; y++){
			for(int x = 0 ; x < this.xg ; x++){
				lifeDeath(x, y);
			}
		}	
 
		// determine la coloration des cellules
		for(int y = 0 ; y < this.yg ; y++){
			for(int x = 0 ; x < this.xg ; x++){
				lifeDeathC(x, y);
			}
		}
	}
 
	// selon le nbre de voisins, définit à vivant ou mort
	public void lifeDeath(int x, int y){
		int bnc = this.neighbourCount(x, y, this.golCopy);
 
		// verifie condition mort
		if((bnc < 2) || (bnc > 3)){
			this.gol[x][y] = BLANC;
		}
		// verifie condition vie
		else if(bnc == 3){
			this.gol[x][y] = VERT;
		}
	}
 
	// reprend les cellules vivantes de la generation pour les colorer
	public void lifeDeathC(int x, int y){		
		int bnc = this.neighbourCount(x, y, this.golCopy);
 
		if(bnc == 3){
			this.coloration(x, y);
		}
	}
 
	// attribue des valeurs differentes aux cellules pour determiner la coloration
	public void coloration(int x, int y){
		// compte le nbre de voisins pour la generation suivante
		int bnc = this.neighbourCount(x, y, this.gol);
 
		// vert : cellules naissantes (et qui ne meurt pas à la gen suivante)
		if(this.golCopy[x][y] == BLANC && (bnc ==  3 || bnc == 2)){
			this.gol[x][y] = VERT;
		}
 
		// bleu : cellules en cours de vie (si a vécu à la dernière gen et continue de vivre à la gen suivante
		if((this.golCopy[x][y] == VERT || this.golCopy[x][y] == BLEU) && (bnc ==  3 || bnc == 2)){
			this.gol[x][y] = BLEU;
		}
 
		// rouge : cellules mourantes (a survécu plus d'une gen et meurt gen suivante)
		if((this.golCopy[x][y] == VERT || this.golCopy[x][y] == BLEU) && ((bnc < 2) || (bnc > 3))){
			this.gol[x][y] = ROUGE;
		}
 
		// jaune : cellule ne vivant qu'une génération
		if(this.golCopy[x][y] == BLANC && ((bnc < 2) || (bnc > 3))){
			this.gol[x][y] = JAUNE;
		}
	}
 
	// gestion des valeurs négatives
	public static int mod (int x, int m){
		return (x + m) % m;
	} 
 
	// compte le nbre de voisins pour une cellule(x, y)
	public int neighbourCount(int x, int y, int gol[][]){
		int nC = 0; 
 
		// haut
		if(y-1 >= 0 && checkValues(gol, x, mod(y-1, yg))){
			nC++;
		}
 
		// bas
		if(y+1 < 40 && checkValues(gol, x, mod(y+1, yg))){
			nC++;
		}
 
		// gauche
		if(x-1 >= 0 && checkValues(gol, mod(x-1, xg), y)){
			nC++;
		}
 
		// droite
		if(x+1 < 60 && checkValues(gol, mod(x+1, xg), y)){
			nC++;
		}
 
		// haut gauche
		if(x-1 >= 0 && y-1 >= 0 && checkValues(gol, mod(x-1, xg), mod(y-1, yg))){
			nC++;
		}
 
		// haut droite
		if(x+1 < 60 && y-1 >= 0 && checkValues(gol, mod(x+1, xg), mod(y-1, yg))){
			nC++;
		}
 
		// bas gauche
		if(x-1 >= 0 && y+1 < 40 && checkValues(gol, mod(x-1, xg), mod(y+1, yg))){
			nC++;
		}
 
		// bas droite
		if(x+1 < 60 && y+1 < 40 && checkValues(gol, mod(x+1, xg), mod(y+1, yg))){
			nC++;
		}
 
		return nC;
	}
 
	// renvoie vrai si la concernée est vivante (une des quatre couleurs)
	public boolean checkValues(int gol[][], int x, int y){
		boolean check = false;
 
		if(gol[x][y] == VERT || gol[x][y] == BLEU || gol[x][y] == ROUGE || gol[x][y] == JAUNE){
			check = true;
		}
 
		return check;
	}
}

Ainsi, on n'aurait pas à passer des heures à essayer de comprendre tout ton code et on t'aiderait plus volontiers. Soit également plus explicite dans la description du problème. Par exemple, tu nous dit : "1 : ne passe pas à bleu si a déjà vécu une gén et a deux cellules voisines", mais qu'est-ce qui se passe d'autre ?

J'ai juste remarqué que, à certains moments les couleurs s'attribuent correctement, à d'autres moments la mauvaise couleur s'affiche : par exemple vert alors que ça devrait être rouge parce que la cellule meurt à la prochaine génération. Ou bleu alors que ça devrait être rouge pour la même raison, ou vert alors que ça devrait être bleu parce que la cellule a vécu à la dernière génération et continue de vivre à la prochaine.

Il y a un problème avec ces tests : l'effet se cumul, donc c'est comme si tu avais plusieurs générations dans une dans certains cas. Si la première condition est vraie alors this.gol[x][y] change,

Sinon, vite vu (ce n'est peut-être pas ça), mais avec int bnc = this.neighbourCount(x, y, this.gol);, tu détermines le voisinage sur le tableau gol et dans (code) tu contrôle l'état de la cellule dans le tableau golY et tu modifies gol... donc le voisinage de la cellule suivante sera fait sur un tableau en cours de modification incomplet. Le voisinage ne devrait-il pas être évalué sur golY ? Ici, tu vois si le nom des tableaux était, par exemple, generationActuelle et nouvelleGeneration, l'erreur sauterait aux yeux, à défaut de ne même pas être faite.

Ca ne pose pas problème parce que la vérification faite par la fonction neighbourCount vérifie uniquement si les cellules alentours sont vivantes ou non, la fonction coloration ne va faire passer une cellule de vivante à morte ou de morte à vivante mais seulement préciser son état en tant que cellule vivante. Je ne pense pas que cela devrait gêner le comptage. J'ai tout de même essayé en remplaçant gol par golY mais ce n'est pas mieux.

Merci encore pour ta réponse !

**joel.drigo** · 25/11/2015, 18h40

Le code est déjà beaucoup plus lisible (entendre compréhensible).

Donc en gros :

on sauvegarde l'état courant dans golCopy
on modifie l'état dans gol (vie et mort)
on "colorise"
- on compte les cellules voisines dans golCopy
- dans lifeDeathC(), si on trouve 3, on colorise gol. Pourquoi pas si on trouve 2 ? 3 c'est une condition de naissance n'est-ce-pas ? et 2 de non mort à priori ?
  ça veut dire qu'on ne change la couleur que des nouvelles cellules, ou des anciennes, mais seulement celles qui ont 3 voisines. Mais les anciennes qui en ont que 2 ?

**willtc** · 25/11/2015, 19h01

Pourquoi pas si on trouve 2 ? 3 c'est une condition de naissance n'est-ce-pas ? et 2 de non mort à priori ?
ça veut dire qu'on ne change la couleur que des nouvelles cellules, ou des anciennes, mais seulement celles qui ont 3 voisines. Mais les anciennes qui en ont que 2 ?

C'est exactement le problème, je n'y ai pas du tout pensé....

J'ai supprimé lifedeathC et j'ai modifié la 2ème boucle pour reprendre toutes les cellules vivantes et les colorer, j'ai testé rapidement et le comportement semble être celui attendu !

Code :

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

1
2
3
4
5
6
7
8
9
		// determine la coloration des cellules
		for(int y = 0 ; y < this.yg ; y++){
			for(int x = 0 ; x < this.xg ; x++){
				if (this.gol[x][y] == 1){
					coloration(x, y);
				}
				// lifeDeathC(x, y);
			}
		}

Je vais faire encore quelques vérifications, merci beaucoup, tu es brillant (ou je suis étourdi, ou les deux

) !

**joel.drigo** · 25/11/2015, 19h14

C'est dans ces cas-là qu'un découpage "sémantique" fin de l'algorithme simplifie la mise à point : avec une méthode estEnVie() qui teste 2 et 3, on a plus besoin de se rappeler, ou on peut se permettre d'oublier par étourderie qu'il faut tester les 2 cas. En tout cas, si l'implémentation de la condition est incorrecte, elle l'est partout (où on l'utilise, mais comme il faut l'utiliser partout où c'est nécessaire, c'est donc partout), ce qui multiplie les cas d'erreurs. On a donc plus de chance de tomber sur un code où il est plus facile de comprendre l'erreur et sa correction a un impact partout. Et en plus ça rend la compréhension du code plus facile à la simple lecture, ce qui aide toujours au débogage, sans parler des évolutions.

**willtc** · 25/11/2015, 19h41

Je comprends, je vais m'efforcer de suivre ça à l'avenir, merci encore !

[Jeu de la vie] : problème de coloration

Java

Discussions similaires

Partager

Partager