Jeu de vie minimaliste

[invited03fd8d2]

Bonjour

J'essaye de coder un p'tit jeu de la vie en Python. Pour commencer j'ai décidé d'implémenter une petite version minimaliste sur une grille de 3*3 juste pour me familiariser avec le concept. J'ai respecté les règles énoncés ici : http://fr.wikipedia.org/wiki/Jeu_de_la_vie#R.C3.A8gles et créé deux grilles (une désignant l'instant T et l'autre l'instant T-1) de la même forme que celle énoncée dans le wiki:

xxx

ooo

xxx

Résultat voulu :

xox

xox

xox

Et ainsi de suite....

(x=morte et o=vivante)

Sauf que le résultat n'est pas du tout celui espéré.

Voici mon code:

from copy import deepcopy
import time

grille=[
[0,0,0],
[1,1,1],
[0,0,0],
]

grilleAvant=[
[0,0,0],
[1,1,1],
[0,0,0],
]

def cells(L,a,b):
    compteur=0
    for x in range(a-1,a+2):
        for y in range(b-1,b+2):
            if ((0<=x<=2) and (0<=y<=2)):
                if L[x][y] and (x!=a and y!=b):
                    compteur+=1

    return compteur

def affich(L):
    for i in L:
        print(i)
    print()

for x in range(4):
    affich(grille)
    for i in range(3):
        for j in range(3):
            if grilleAvant[i][j]:
                if not(cells(grilleAvant,i,j)==2 or cells(grilleAvant,i,j)==3):
                     grille[i][j]=0
                elif not grilleAvant[i][j]:
                    if cells(grilleAvant,i,j)==3:
                        grille[i][j]=1
                        
    grilleAvant=deepcopy(grille)
    
    time.sleep(2)

Voici ce que j'obtiens au bout des 4 itérations :


[0, 0, 0]
[1, 1, 1]
[0, 0, 0]

[0, 0, 0]
[0, 0, 0]
[0, 0, 0]

[0, 0, 0]
[0, 0, 0]
[0, 0, 0]

[0, 0, 0]
[0, 0, 0]
[0, 0, 0]

De l'aide svp ? Car ça me frustre de bloquer sur un truc si simple...
-----

[invitea726d297]

Bonjour,
Marrant, ce truc, je ne connaissais pas.
Une première réaction, une cellule doit avoir 8 voisines. Ce n'est le cas que pour la cellule [1,1] dans le cas d'une grille 3x3.
Il me parait donc indispensable d'avoir une grille de grande dimension, et ajouter un article à la règle du jeu pour les cellules qui ont moins de 8 voisines. On peut aussi prévoir une grille "fermée", c'est à dire la voisine d'une cellule située au bord est celle située sur l'autre bord, d'est à dore la voisine à droite d'une celle de rang 2 est celle de rang 0. (je vais prendre cette hypothèse pour mes essais)
Une autre question que je me pose : que signifie "au tour suivant" ? Si une cellule change d'état morte<-->vivante, cela aura naturellement une répercutions sur ses 8 voisines. Dans quel ordre l'état de ces 8 cellules sera-t-il testé et/ou modifié ?
Donc en gros, il y a vraiment des trucs qui m'échappent.
Je vais essayer de le faire, je vous tiendrai au courant.
Dites-moi aussi si vous avez du nouveau.

[invited03fd8d2]

Bonjour.
Pour le nombre de voisines, bah il y en aura forcément certaines qui n'ont n'auront pas 8, vu que la taille de la grille ne sera pas infinie évidemment.

"c'est à dire la voisine d'une cellule située au bord est celle située sur l'autre bord, d'est à dore la voisine à droite d'une celle de rang 2 est celle de rang 0. (je vais prendre cette hypothèse pour mes essais) "
Non l'exemple Wikipedia ne prend pas en compte cela, et puis j'ai testé avec une feuille et un stylo sans prendre en compte ce détail et j'ai eu le résultat voulu.

"Une autre question que je me pose : que signifie "au tour suivant" ? Si une cellule change d'état morte<-->vivante, cela aura naturellement une répercutions sur ses 8 voisines. Dans quel ordre l'état de ces 8 cellules sera-t-il testé et/ou modifié ?
Donc en gros, il y a vraiment des trucs qui m'échappent."

On a par exemple à l'instant T :
0 0 0
1 1 1
0 0 0

La cellule (0;0) à 2 voisines vivantes, elle sera toujours morte à l'instant T+1.
La cellule (0;1) à 3 voisines vivantes, elle renaîtra à l'instant T+1.
La cellule (0;2) à 2 voisines vivantes, elle sera toujours morte...
La cellule (1;0) à 1 voisine vivante, elle mourra...
La cellule (1;1) à 2 voisines vivantes, elle sera toujours vivante.
La cellule (1;2) à 1 voisine vivante, elle mourra...
La cellule (2;0) à 2 voisines vivantes, elle sera toujours morte...
La cellule (2;1) à 3 voisines vivantes, elle renaîtra...
La cellule (2;2) à 2 voisine vivantes, elle sera toujours morte...

Donc on n'a plus qu'a reconstruire une grille avec ces états, ce qui donne :
0 1 0
0 1 0
0 1 0

Et ainsi de suite...

[invited03fd8d2]

Finalement en fouillant un peu, je pense que le problème vient de ma fonction cells qui est censée retourner le nombre de voisines vivantes.

>>> L=[[1,1,1]]*3 # On crée une grille 3*3 remplie de 1
>>> cells(L,1,1)
>>> 4 # Elle censée retourner 8...

En changeant un tout p'tit ma fonction....:

def cells(L,a,b):
    compteur=0
    for x in range(a-1,a+2):
        for y in range(b-1,b+2):
            if ((0<=x<=2) and (0<=y<=2)):
                if L[x][y]==1:
                    compteur+=1
    if L[a][b]:
        compteur-=1
    return compteur

... Mon programe retourne le résultat convoité :

[0, 1, 0]
[0, 1, 0]
[0, 1, 0]

[0, 0, 0]
[1, 1, 1]
[0, 0, 0]

[0, 1, 0]
[0, 1, 0]
[0, 1, 0]

[A voir en vidéo sur Futura]

[invitea726d297]

Donc, il y a une grille "avant" et une grille "après", pourquoi pas ?
Moi, j'avais plutôt imaginé un adressage cellule par cellule, aléatoirement, avec prise en compte immédiate.

Maintenant, j'ai lu votre code. Je ne connais pas ce langage, mais il y a des choses que je ne comprends pas.

    for x in range(a-1,a+2):

Est que ça veut dire que x peut prendre les valeurs de a-1 à a+2 (si a = 1 alors x=[0,1,2,3]) ce qui ne me semble pas correct.
Ou au contraire ça veut dire a-1 <= x < a+2 ?

[invited03fd8d2]

Oui, ça veut dire a-1 <= x < a+2 (la grande borne n'est pas incluse).

J'ai aussi du changer carrément le système pour que mon programme fonctionne :

from copy import deepcopy
import time


grilleAvant=[
[0,0,0],
[1,1,1],
[0,0,0],
]

def cells(L,a,b):
    compteur=0
    for x in range(a-1,a+2):
        for y in range(b-1,b+2):
            if ((0<=x<=2) and (0<=y<=2)):
                if L[x][y]==1:
                    compteur+=1
    if L[a][b]:
        compteur-=1
    return compteur

def affich(L):
    for i in L:
        print(i)
    print()

grille=[]
for x in range(4):
    affich(grille)
    grille=[]
    for i in range(3):
        grille.append([])
        for j in range(3):
            if grilleAvant[i][j]:
                if (cells(grilleAvant,i,j)==2 or cells(grilleAvant,i,j)==3):
                    grille[i].append(1)
                else:
                    grille[i].append(0)
            elif not grilleAvant[i][j]:
                if cells(grilleAvant,i,j)==3:
                    grille[i].append(1)
                else:
                    grille[i].append(0)
                        
    grilleAvant=deepcopy(grille)
    
    time.sleep(2)

(même si c'est un peu lourd de recréer une liste à chaque fois...)

[invitea726d297]

Bonjour,
Vous en êtes où avec votre développement ?
Il est évident que mes questions étaient idiotes : j'avais juste lu le tout début de l'article.
Le mien marche pas mal, j'ai une grille 36x36.
J'ai essayé avec 2 approches, d'abord 4 planeurs qui partent de chaque angle, puis avec une initialisation aléatoire. Ce dernier est assez amusant, on se dit, "ça va se terminer", mais non, il y a d'autres structures qui se créent, de jolies étoiles, et finalement on arrive à des structures soit fixes, soit stables.