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

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:

---

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 :)

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:

---

public static final int BLEU = 2;

---

et pour l'affectation

Code:

---

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:

---

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;

Salut joel.drigo,

Merci pour ta réponse.

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

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

---

Citation:

---

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.

Citation:

---

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 !

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 ?
    
  
  

Citation:

---

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:

---

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 :)) !

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.

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