Discussion :

[luonaar]

Bonjour,

J'essai de faire un algorithme pour faire reproduire le conways game of life, je le réalise sur la console pour l'élaborer, le tester afin d'être qu'il soit fonctionnel, car je vais ensuite le réaliser sur SDL. Il s'agit donc d'une version "Brouillon" de mon code.

Le code en lui même est presque finit, la seul chose qu'il lui manque c'est un fonctionnement correct. Après tout les test que j'ai fais sur mon code j'en suis venus a la conclusion tout semblait fonctionner plutôt bien, a part sur la vérification de l'état(vivante ou morte) des cellules voisines. En effet il ne doit pas fonctionner correctement vu que les pattern comme le planeur ne se comporte pas normalement. Si ça peut vous aidez je suis sur windows 7 32-bit et j'utilise code::blocks 13.12.

voila mon code(j'ai mit les pattern de test en commentaire si vous voulez tester décommenter):

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
#include <stdio.h>
#include <stdlib.h>
#include "checkCell.h"
#include "boucleTab.h"
 
void tabInit(int tab[63][127])   //fonction initialisant le tableau
{
    int i = 0, j = 0;
for(j=0; j<7; j++)
{
    for(i=0; i<15; i++)
    {
        tab[j][i] = 0;
    }
}
}
 
int main()
{
int tabCase[63][127];
 
tabInit(tabCase);
/*
tabCase[30][20]= 1;
tabCase[29][19]= 1;
tabCase[28][19]= 1;    //pattern du planneur du jeu de la vie.
tabCase[28][20]= 1;   //Normalement pour X itération 5 cellule restent vivantes.
tabCase[28][21]= 1;
*/
 
/*
tabCase[1][3]= 1;   //pattern du nid d'abeill il est censé comporter 6 case vivante au bout de 2 itérations.
tabCase[2][1]= 1;
tabCase[2][2]= 1;
tabCase[2][3]= 1;
*/
 
int iteration = 0, a =0, x =0, y = 0;
 
a = countCell(tabCase);
printf("Nombre de cellule viante avant : %d\n", a);
 
    for(iteration=0; iteration<1; iteration++)
    {
        boucleTab(tabCase, x, y);
        a = countCell(tabCase);
    }
 
 printf("Nombre de cellule viante : %d\n", a);
 
    return 0;
}

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
#include <stdio.h>
#include <stdlib.h>
#include "checkCell.h"
 
 
int checkCell(int tab[63][127], int x, int y) //fonction qui test les cellules voisines.
{
    int v1 = x + 1, v2 = x - 1;
    int w1 = y + 1, w2 = y - 1;
    int celvie = 0;
    if(tab[w2][v2] == 1)
    {
        celvie = celvie + 1;
    }
    if(tab[w2][v2] == 1)
    {
        celvie = celvie + 1;
    }
    if(tab[w2][x] == 1)
    {
 
        celvie = celvie + 1;
    }
    if(tab[w2][v1] == 1)
    {
 
        celvie = celvie + 1;
    }
    if(tab[y][v2] == 1)
    {
 
        celvie = celvie + 1;
    }
    if(tab[y][v1] == 1)
    {
        celvie = celvie + 1;
    }
    if(tab[w1][v2] == 1)
    {
        celvie = celvie + 1;
    }
    if(tab[w1][x] == 1)
    {
        celvie = celvie + 1;
    }
      if(tab[w1][v1] == 1)
    {
        celvie = celvie + 1;
    }
 
 
return celvie;
}

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
#include <stdio.h>
#include <stdlib.h>
#include "boucleTab.h"
#include "checkCell.h"
 
void cellDie(int tab[63][127], int x, int y, int cell) //fonction pour tuer une cellule
{
  if(cell != 2 && cell != 3)
    {
        tab[y][x] = 0;
    }
cell = 0;
}
 
 
void cellBirth(int tab[63][127], int x, int y, int cell)  //fonction qui donne vie a une cellule
{
    if(cell == 3)
    {
        tab[y][x] = 1;
    cell = 0;
    }
 
}
 
int countCell(int tab[63][127])  //fontion qui compte le nombre de cellule en vie
{
int i = 0, j = 0, count = 0;
    for(i=0; i<7; i++){
        for(j=0; j<15; j++)
        {
 
            if(tab[i][j] == 1)
            {
            count = count + 1;
            }
 
        }
  }
return count;
}
 
 
void boucleTab(int tab[63][127], int x, int y)  //boucle qui permet de scaner case par case l'état des celulles.
{
    int cellAlive = 0;
        for(y=0; y<7; y++)
        {
            for(x= 0; x<15; x++)
                {
                if(tab[y][x] == 1){
 
                cellAlive = checkCell(tab, x, y);
                cellDie(tab, x, y, cellAlive);
                }
                else if(tab[y][x] == 0)
                {
 
                cellAlive = checkCell(tab, x, y);
                cellBirth(tab, x, y, cellAlive);
                }
 
 
            }
    }
 
}

Code :

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

1
2
3
4
5
6
#ifndef CHECKCELL_H_INCLUDED
#define CHECKCELL_H_INCLUDED
 
int checkCell(int tab[63][127], int x, int y);
 
#endif // CHECKCELL_H_INCLUDED

Code :

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

1
2
3
4
5
6
7
8
9
10
#ifndef BOUCLETAB_H_INCLUDED
#define BOUCLETAB_H_INCLUDED
 
void cellDie(int tab[63][127], int x, int y, int cell);
void cellBirth(int tab[63][127], int x, int y, int cell);
void boucleTab(int tab[63][127], int x, int y);
int countCell(int tab[63][127]);
 
 
#endif // BOUCLETAB_H_INCLUDED

[dinobogan]

Dans checkCell, tu as deux fois "if(tab[w2][v2] == 1)".
Sinon, cette fonction devrait utiliser deux boucles for (de -1 à +1 sur X, idem sur Y) au lieu de dérouler tous les tests. Ce serait plus lisible et plus facile pour le debug.

Autre chose : les tailles des tableaux, passe par des #define, il y aura moins de sources d'erreurs.

[luonaar]

Merci, j'avais pas vu et je vais mettre des define si tu dit que c'est moins risquer.

[Médinoc]

À ma connaissance, les automates cellulaires ne sont pas faits pour qu'une itération soit faite "à même le plateau": Le résultat de la cellule en cours ne doit pas affecter les entrées des cellules suivantes à la même itération (contrairement à, par exemple, un tramage à diffusion d'erreur qui compte justement dessus pour tout faire en une seule itération).

Tu dois donc avoir une fonction d'itération avec un tableau d'entrée qui ne change pas, et un tableau de sortie:

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
int CoordonneesValides(int x, int y)
{
	return (x >= 0 && x < 127 && y >= 0 && y < 63);
}
int ContientCelluleVivante(int const etat[63][127], int x, int y)
{
	if(!CoordonneesValides(x, y))
		return 0;
	return etat[y][x] != 0;
}
 
int CompterVoisins(int const etat[63][127], int x, int y)
{
	int nVoisins = 0;
	/*Sens des aiguilles d'une montre, en partant du nord*/
	if(ContientCelluleVivante(etat, x, y-1))
		nVoisins++;
	if(ContientCelluleVivante(etat, x+1, y-1))
		nVoisins++;
	if(ContientCelluleVivante(etat, x+1, y))
		nVoisins++;
	if(ContientCelluleVivante(etat, x+1, y+1))
		nVoisins++;
	if(ContientCelluleVivante(etat, x, y+1))
		nVoisins++;
	if(ContientCelluleVivante(etat, x-1, y+1))
		nVoisins++;
	if(ContientCelluleVivante(etat, x-1, y))
		nVoisins++;
	if(ContientCelluleVivante(etat, x-1, y-1))
		nVoisins++;
	return nVoisins;
}
 
void CalculVie(int const ancienEtat[63][127], int nouvelEtat[63][127])
{
	int y;
	for(y=0 ; y<63 ; y++)
	{
		int x;
		for(x=0 ; x<127 ; x++)
		{
			int nVoisins = CompterVoisins(ancienEtat, x, y);
			switch(nVoisins)
			{
			case 0:
			case 1:
				/*Pas assez de voisins: Mort*/
				nouvelEtat[y][x] = 0;
				break;
			case 2:
				/*Deux voisins: état précédent conservé*/
				nouvelEtat[y][x] = ancienEtat[y][x];
				break;
			case 3:
				/*Exactement trois voisins: Vie/Naissance*/
				nouvelEtat[y][x] = 1;
				break;
			case 4:
			case 5:
			case 6:
			case 7:
			case 8:
				/*Trop de voisins: Mort*/
				nouvelEtat[y][x] = 0;
				break;
			}
		}
	}
}

Et une fois que tu as tout calculé, tu peux écraser l'ancien avec le nouveau.

[ternel]

Voire, simplement permuter les deux pointeurs, pour pouvoir faire une séquence d'itérations sans réallouer de tableaux.