Discussion :

[_SamSoft_]

Bonjour, avant tout je tiens à dire que le problème ne se situe pas au niveau de codes (tout compile) mais au niveau de la logique même du programme.

Voilà le code source (contient les sources et l'exécutable pour Windows):

http://sayro.free.fr/SamSoft/projets/Conway.zip

Pour ceux qui ne connaissent pas les règles ou qui veulent comparer avec un logiciel fonctionnel c'est ici : http://www.erwanhome.org/web/jeu-de-la-vie.php

Mon logiciel vous permet de cliquer pour créer/détruire une cellule.
Touche: P = pause, S = start, Q = quitter, V = vitesse, R = tout supprimer.

En fait le réel problème c'est les "côtés" de la carte. Je m'explique. Si je construit un Glider:



A la fin lorsqu'il rencontre un obstacle (chez moi le coté de la map), il se transforme en une structure stable (c'est ce qui se passe sur le site que je vous ai donné), voici la structure stable:



Mais voilà ce qui se passe chez moi:



Vous remarquez qu'au lieu de se transformer en une structure stable, le Glider se détruit.

Le truc c'est que sur ce site : http://home.sc.rr.com/lmeeker/Lee/Life_4D/objects.html

C'est apparemment ce qui doit se passer, donc mon programme serait fonctionnel mais sur le site passé au début du message c'est pas le résultat final.

A part ce problème de côté, tout fonctionne en gros tant que mes cellules ne rencontrent pas les côtés de la map, elles se comportent toutes de la même façon (pour pouvoir dire cela j'ai comparé avec deux logiciels trouvés sur le net dont un présent sur le site donnée au début du message).

Merci d'avance

PS: Ceci n'est pas un projet que je dois rendre, j'ai que 16ans et je programme (pour le moment) par passion

[Plomeg]

C'est juste une impression mais on dirait que le gilder sort du champ de vision et continue d'exister quand même (case qui apparaît). Il doit peut-être y avoir des connexions (enfin je veux dire pour passer d'une case à l'autre, la manière dont est calculée la case suivante, et qui ne prendrai pas en compte le mur, après l'implémentation je sais pas du tout) qui ne devraient pas exister dans la manière dont tes cases sont organisées (et qui permet de faire le tour du coup). Peut-être qu'en plus tu as des cases qui ne sont pas affichées.

En gros, je pense qu'il faut vérifier la manière dont tu vérifies les cases adjacentes et comment tu les définies (les tests ou la manière dont leur adjacence est faite).

Désolé de ne pas regarder le code mais si tu n'y arrives pas je m'y mettrai^^

Sinon le fait que ta structure se détruise parait normal comme sur l'animation de ce lien : http://fr.wikipedia.org/wiki/Vaissea...te_cellulaire)

[_SamSoft_]

Merci, après réflexion c'est possible mais je vérifierai cela demain ou la semaine prochaine (trop de contrôles) en attendant voilà le code pour les calculs de possibilités:

z correspond au nombre de voisins, i est une case en largeur et j une case en longueur.

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
 
int check_position(int map[L_WINDOW][H_WINDOW], int i, int j) /* On calcul les possibilites de la cellule en position i,j */
{
    int z = 0;
 
    if((i+1) < L_WINDOW)
    {
        if(map[i+1][j] != BLANK || map[i+1][j] == DEAD)
        {
            z++;
        }
    }
 
    if((j+1) < H_WINDOW)
    {
        if(map[i][j+1] == FULL || map[i][j+1] == DEAD)
        {
            z++;
        }
    }
 
    if((i+1) < L_WINDOW && (j+1) < H_WINDOW)
    {
        if(map[i+1][j+1] == FULL || map[i+1][j+1] == DEAD)
        {
            z++;
        }
    }
 
    if((i-1) > 1)
    {
        if(map[i-1][j] == FULL || map[i-1][j] == DEAD)
        {
            z++;
        }
    }
 
    if((i-1) > 1 && (j+1) < H_WINDOW)
    {
        if(map[i-1][j+1] == FULL || map[i-1][j+1] == DEAD)
        {
            z++;
        }
    }
 
    if((j-1) > 1)
    {
        if(map[i][j-1] == FULL || map[i][j-1] == DEAD)
        {
            z++;
        }
    }
 
    if((i+1) < L_WINDOW && (j-1) > 0)
    {
        if(map[i+1][j-1] == FULL || map[i+1][j-1] == DEAD)
        {
            z++;
        }
    }
 
    if((i-1) > 1 && (j-1) > 1)
    {
        if(map[i-1][j-1] == FULL || map[i-1][j-1] == DEAD)
        {
            z++;
        }
    }
 
    return z;
}

PS: Si sur 2/3 sites ca fait cela alors c'est que c'est ok normalement

[Plomeg]

Je crois que l'erreur se situe dans ton test de la valeur de i-1>1. Le premier terme d'un tableau est tab[0] (ou tab[0][0] ici) et tab[1] n'est pas non plus illégal (alors que là tu ne permets que des valeurs supérieures ou égales à 2 pour i+1). Tu devrais faire:

Code :

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

1
2
3
if((i-1) >= 0)
 //ou bien
if((i-1) > -1)

Sinon on dirait que tu as mal entretenu ton code (ou mal recopié, mais apparemment c'est une modification d'après si j'ai bien compris la logique) car le premier test utilise différent de BLANK plutôt que égal à FULL. Si elle naissante (donc pas encore vivante) le test est vrai alors qu'à ce tour la case devrait être considérée comme vide. Du moins si j'ai bien compris...

J'espère ne pas m'être planté^^

[_SamSoft_]

Merci, en fait ces "erreurs" (qui ne font pas que le programme fonctionne mal) sont le fruit d'un grand nombre de tests. En fait, au début, pour une case FULL on comptait 8 voisins FULL alors que dans mes tests la case était isolé. En fait c'était une erreur de logique (genre oubli de conditions). J'ai corrigé cela est oublié de le faire pour tout.

Voilà les états possibles de mes cases:

BLANK /* case vide */
NEAR /* J'ai pas trouvé d'autre nom m'enfin ca veut dire naissante mais pas encore*/
DEAD /* En train de mourir mais pas encore */
FULL /* case pleine */

Voilà

Je poste résolu car je crois que mon programme fonctionne maintenant très bien, ce qui me gênait c'était que le glider ne devenait pas une structure stable maintenant que je sais que ce ne doit pas être le cas, c'est résolu. Maintenant si vous avez des suggestions sur le code lui même, je suis pas contre

[EDIT]

Voilà le code:

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
 
int check_position(int map[L_WINDOW][H_WINDOW], int i, int j) /* On calcul les possibilites de la cellule en position i,j */
{
    int z = 0;
 
    if((i+1) < L_WINDOW)
    {
        if(map[i+1][j] == FULL || map[i+1][j] == DEAD)
        {
            z++;
        }
    }
 
    if((j+1) < H_WINDOW)
    {
        if(map[i][j+1] == FULL || map[i][j+1] == DEAD)
        {
            z++;
        }
    }
 
    if((i+1) < L_WINDOW && (j+1) < H_WINDOW)
    {
        if(map[i+1][j+1] == FULL || map[i+1][j+1] == DEAD)
        {
            z++;
        }
    }
 
    if((i-1) >= 0)
    {
        if(map[i-1][j] == FULL || map[i-1][j] == DEAD)
        {
            z++;
        }
    }
 
    if((i-1) >= 0 && (j+1) < H_WINDOW)
    {
        if(map[i-1][j+1] == FULL || map[i-1][j+1] == DEAD)
        {
            z++;
        }
    }
 
    if((j-1) >= 0)
    {
        if(map[i][j-1] == FULL || map[i][j-1] == DEAD)
        {
            z++;
        }
    }
 
    if((i+1) < L_WINDOW && (j-1) >= 0)
    {
        if(map[i+1][j-1] == FULL || map[i+1][j-1] == DEAD)
        {
            z++;
        }
    }
 
    if((i-1) >= 0 && (j-1) >= 0)
    {
        if(map[i-1][j-1] == FULL || map[i-1][j-1] == DEAD)
        {
            z++;
        }
    }
 
    return z;
}

Le projet est librement téléchargeable ici (pour le moment c'est à l'adresse indiquée après ce sera sur mon site) :
http://sayro.free.fr/SamSoft/projets/Conway.zip