Bonjour, nous avons un programme à coder en C, j'utilise codeblocks. Nous devons coder le "jeux de la vie" dont voici les règles :  
 
----------------------------------------------------------------------------------------
Le jeu de la vie évolue normalement sur un damier infini. Chaque case est occupée par une cellule qui peut être vivante ou morte.
A chaque génération, chaque cellule peut naître, mourir, ou rester dans son état. Les règles qui permettent de passer d'une
génération à l'autre sont précises et ont été choisies avec soin pour que l'évolution des organismes soit intéressante et imprévisible.
En premier lieu, notons que sur un damier infini, chaque case a exactement 8 voisins. Pour créer la génération suivante à partir
de la génération courante, J. Conway a fixé les règles suivantes :
 
    Une cellule ayant exactement 2 ou 3 voisins vivants survit la génération suivante.
    Une cellule ayant au moins 4 cellules voisines vivantes meurt d'étouffement à la génération suivante.
    Une cellule ayant au plus une cellule voisine vivante meurt d'isolement à la génération suivante.
    Sur une case vide ayant exactement 3 voisins vivants, une cellule naîtra à la génération suivante.
 
Afin d'implémenter ce jeu, on considère le damier infini comme une matrice "torique". Le damier sera représenté par une matrice
dont les bords droite et gauche sont reliés entre eux, ainsi que les bords supérieur et inférieur.  
----------------------------------------------------------------------------------------
 
J'ai bien avancé sur le code, mais j'ai un petit soucis, la génération suivante de ma matrice, ici j'ai pris une matrice 10*10 est complètement fausse. En effet, toutes les cellules sont vivantes dans ma deuxième matrice excepté la dernière cellule. Je ne trouve pas l'erreur. Je pense qu'elle vient de la fonction "next_gen" ou "nb_voisin". Pour faire une matrice torique (calcul du nb de voisins à la premiere ligne/colonne ou derniere, puisque pour la premiere ligne, il faut regarder les voisins de la derniere ligne par exemple, j'ai utilisé un modulo, je ne sais pas si cela fonctionne correctement)
 
Merci d'avance à ceux qui pourront m'aider et qui auront pris le temps de me lire.
 
Voici mon code:

Tu devrais compiler ton programme avec tous les avertissements activés (-Wall, dans C::B, ça se configure dans Projects => Build options => Compiler settings => Compiler flags). Avec ton code, ça donne :

 
Particulièrement les "suggest parentheses around assignment used as truth value". Erreur classique.

Enfin la, l'erreur est clairement entre = et ==
 
D'autre part
char damier[TAILLE][TAILLE];
if(rand()%100<20) {damier[i][j]='0';} //un maximum de 20% de cellule vivante
      else {damier[i][j]='-';}
C'est pas une très bonne idée
 
int damier[TAILLE][TAILLE];
if(rand()%100<20) {damier[i][j]= 1;} //un maximum de 20% de cellule vivante
      else {damier[i][j]= 0;}
C'est mieux pour les tests, les évaluations...
Il y a qu'au moment de l'affichage qu'on a besoin de faire
if (damier[i][j])  
    printf("0" );
else
    printf("-" );
 
A+,

Merci tpierron, j'ai corrigé et ça à l'air de marcher. Par contre je n'arrive pas à activer tous les avertissements dans project, la case build options est grisée.  
 
Merci pour le conseil gilou

Alors après réflexion, ça marche bien sur les lignes et les colonnes qui ne sont pas à l'extremité de la matrice, je dois avoir un problème sur les bords avec mon modulo, quelqu'un aurait une idée ?

Attention à la différence entre = (un seul signe égal) qui est une affectation, une association, un chargement, et == (deux signes égal) qui est un test d'égalité.  
Dans les if, il faut toujours mettre des ==, sauf dans des cas très particuliers et très rares.

yep merci olivthill, j'avais corrigé cette erreur suite aux erreurs que m'a montré tpierron!

Ton pb vient probablement de cette ligne ci:
else if (*cellule=='-'); //Si la cellule est morte
 
En utilisant des tableaux d'entier, on peut nettement simplifier la procédure nb_voisin:
 

Note en faisant
void init_damier(int (*damier)[TAILLE][TAILLE]);
je passe le tableau damier par pointeur ce qui est bien plus léger que passer le tableau tout entier comme tu le fais.
Dans un deuxième temps, plutôt que de se coltiner un int (*damier)[TAILLE][TAILLE] partout, on peut définir un type ad-hoc avec un typedef.
 
A+,

Et apres avoir change, ca marche toujours pas? A priori ca devrait, vu que ce qui se passait c'est que dans ta methode nb_voisins, tu affectais un "0" a tous les voisins de la cellule... Verifies que t'en a pas oublie.

Sinon, une fois que t'auras regle ce probleme, je pense que ton algo sera toujours faux, mais ca sera plus fourbe. En effet, tu parcours la matrice en la rafraichissant dynamiquement, et tu reutilises immediatement les nouvelles valeurs pour faire evoluer d'autres cellules. Ce qui veut dire que tu ne calcules pas la nouvelle generation en te basant sur l'ancienne, mais plutot en te basant sur un mix de l'ancienne et de la nouvelle. En details:
- ta premiere "nouvelle" cellule aura ses 8 voisins de la generation precedente, et tu la feras evoluer correctement
- ta seconde cellule par contre n'aura que 7 voisins de la generation precedente, alors que le 8eme (celui que tu as deja fait evoluer) aura peut-etre deja change de valeur, et du coup tu ne vas pas calculer la seconde cellule corectement
- pareil pour toute la premiere ligne de la matrice, sauf la derniere cellule de la ligne ou deux des voisins n'auront plus leur valeur originale (a cause du tore)
- seconde ligne, ca s'empire: la premiere cellule a trois voisins (les trois de la premiere ligne) qui ont deja change, le reste de la ligne en aura quatre et la derniere cellule de la ligne cinq
- pareil jusqu'a la ligne 10 ou ca devient la fete du slip: a cause du tore, t'as de base 6 voisins qui ont deja evolue au debut de la ligne, puis 7, et bingo pour la derniere cellule qui aura ses 8 voisins deja evolues.

Je peux me tromper mais a mon avis, tu dois baser toute ta nouvelle generation sur l'ancienne - en gros, avoir un mecanisme qui te permet d'acceder pour chaque cellule a la valeur de l'ancienne generation, au moins jusqu'a ce que tu aies calcule la nouvelle entierement, moment a partir duquel les anciennes valeurs n'ont plus d'importance.

Edit: pour appuyer mes dires: si tu prends une meme matrice de depart, avec tes methodes, le resultat va etre different selon ton sens de parcours de la matrice, ce qui n'est pas normal.

Bien vu, ça.
La correction est simple a faire, s'il ajoute un 2e tableau, qui contient le nb de voisins au lieu de faire un calcul dynamique.
 
A+,

Il devrait faire 2 buffers (matrices), chacun représentant une génération et un pointeur qui, une fois sur 2 (ie, un tour de boucle sur 2), pointe sur l'un ou l'autre, un peu comme on fait dans les jeux vidéo avec le double buffering