Jeu de la Vie

Version imprimable

Jeu de la Vie

Bonjour tout le monde. J'ai créé un programme se basant sur le jeu de la vie. Mais il ya malgré tout quelques bug imprévus. En effet les lignes au bord du "tableau" ne communiquent pas entre elles malgré nos efforts. C'est à dire que les bords du tableau sont censés communiquer entre eux, mais cela ne fonctionne pas.
La fonction

Code:

compter_cellules_voisines

est censée compter le nombre de cellules vivantes autour de la cellule actuelle
La fonction

Code:

verif_valeurs(m,n,o,p)

vérifie que les valeurs a prendre dans le tableau ne sont pas "out of range".
Voici le programme :

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
from tkinter import *
test = 0
 
def quitter():
    fen.destroy()
 
def creation_lignes():
    for x in range(0,11):
        Canevas.create_line(64*x, 0, 64*x, 640, width=1, fill="blue")
        Canevas.create_line(0,64*x, 640, 64*x, width=1, fill="blue")
 
def clear():
    Canevas.delete("all")
    creation_lignes()
    creer_tableau()
 
def placement(n):
    m = int(n/64)
    m = 64*m
    return m
 
def creer_tableau():
    global tab
    tab = [[0 for i in range(10)] for j in range(10)]
 
def matrice_clic(X,Y):
    X = int(X/64)
    Y = int(Y/64)
    tab[Y][X] = 1
 
def Clic(event):
    # position du pointeur de la souris
    X = event.x
    Y = event.y
    X0 = placement(X)
    Y0 = placement(Y)
    X1 = X0 + 60
    Y1 = Y0 + 60
    r = 10
    Canevas.create_oval(X0+2, Y0+2, X1, Y1,fill='magenta')
    matrice_clic(X0,Y0)
 
def adapte_dessin():
    tab = tab2
    Canevas.delete("all")
    creation_lignes()
    for y in range(0,10):
        for x in range(0,10):
            z = tab[y][x]
            if z == 1:
                Canevas.create_oval(64*x, 64*y, (64*x)+60, (64*y)+60,fill='magenta')
    tab = tab2
 
 
def tour_suivant():
    global tab,tab2,x,y,test
    test = test +1
    tab2 = [[0 for i in range(10)] for j in range(10)]
    for y in range(0,9):
        for x in range(0,9):
            compter_cellules_voisines(y,x)
    tab = tab2
    adapte_dessin()
 
 
def verif_valeurs(m,n,o,p):
    if m == -1:
        m = 9
    if n == 10:
        n = 0
    if o == -1:
        o = 9
    if p == 10:
        p = 0
    return m,n,o,p
 
def adapte_matrice(y,x,z):
    tab2[y][x] = z
 
 
def cellule_actuelle(y,x,s):
    cell = tab[y][x]
    z = 0
    if cell == 0:                     # Si une cellule morte
        if s == 3:                    # possède exactement 3 voisins vivants
            z = 1                    # elle devient vivante
    else:
        if s == 2 or s == 3:           # Une cellule vivante avec 2 ou 3 voisines vivantes le reste
            z = 1                    # sinon elle meurt (z reste égal à 0)
    adapte_matrice(y,x,z)
 
 
 
def compter_cellules_voisines(y,x):
    m = y-1
    n = y+1
    o = x-1
    p = x+1
    verif_valeurs(m,n,o,p)
    a = tab[m][o]
    b = tab[m][x]
    c = tab[m][p]
    d = tab[y][o]
    e = tab[y][p]
    f = tab[n][o]
    g = tab[n][x]
    h = tab[n][p]
    s = a+b+c+d+e+f+g+h                #somme des cellules vivantes (voisines de la cellule actuelle(x,y))
    cellule_actuelle(y,x,s)
 
 
 
 
fen = Tk()                                                                        
fen.title("Le jeu de la vie")                                                     
fen.geometry("%dx%d%+d%+d" % (1105,680,80,100))
fen.resizable(width=False, height=False)
 
Canevas = Canvas(fen, width = 640, height = 640, bg = "White") 
Canevas.pack(side =LEFT, padx =18, pady =17 )
 
quitter = Button(fen, text ='Quitter le jeu', command =quitter)
quitter.pack(side =RIGHT, padx =40, pady =310)
 
clr = Button(fen, text ='Nettoyer le plateau', command =clear)
clr.pack(side =RIGHT)
 
etape = Button(fen, text ='Tour suivant', command = tour_suivant)
etape.pack(side =RIGHT, padx =30)
 
 
creation_lignes()
Canevas.bind('<Button-1>', Clic)
creer_tableau()
fen.mainloop()

Voilà.
Les bugs notables sont sur les lignes fermant le tableau.
Merci beaucoup de prendre le temps d'aider si possible.
Bonne journée,
Cordialement,
Nono-tiptop

12/01/2017, 18h43
wiztricks

Salut,

Citation:

Envoyé par nonotiptop

J'ai créé un programme se basant sur le jeu de la vie. Mais il ya malgré tout quelques bug que je ne comprends pas.

Sans détailler pas ce que vous appelez "bug" et comment les reproduire, pas grand monde prendra le temps de récupérer votre code, le faire tourner et imaginer ce qui ne va pas.

- W
12/01/2017, 19h05
BufferBob
salut,

l'ensemble a l'air de fonctionner, à l'exception d'un problème de wrapping, aux alentours de compter_cellules_voisines(); lorsqu'on considère les cellules sur les bords, à quoi peuvent bien correspondre les valeurs de x-1 ou y+1 etc. ?
il faudrait au minimum avoir des variables XMAX et YMAX qui délimitent le tableau, et spécifier un truc du genre :

Code:

1 2 3 4 if m < 0: m = YMAX if n > YMAX: n = 0 if o < 0: o = XMAX if p > XMAX: p = 0

edit: ok c'est le propos de verif_valeurs() en fait, j'ai mal lu

Salut,

Je n'ai pas regardé en détail mais ceci m'a sauté aux yeux:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
def verif_valeurs(m,n,o,p):
    if m == -1:
        m = 9
    if n == 10:
        n = 0
    if o == -1:
        o = 9
    if p == 10:
        p = 0
    return m,n,o,p
 
... 
def compter_cellules_voisines(y,x):
    m = y-1
    n = y+1
    o = x-1
    p = x+1
    verif_valeurs(m,n,o,p)

Tu ignores le retour de la fonction verif_valeurs qui ne sert donc à rien.

Essaye comme ceci:

Code:

1
2
 
    m, n, o, p = verif_valeurs(m,n,o,p)

12/01/2017, 19h19
BufferBob
en plus de la remarque de VinsS, il suffit de modifier tour_suivant() comme suit :
Code:

1 2 3 tab2 = [[0 for i in range(10)] for j in range(10)] for y in range(10): for x in range(10):
normalement le tout fonctionne ensuite convenablement

Merci à tous

Merci à tous les membres du forum et administrateurs popur vos conseils précieux, qui nous auront permis de terminer ce mini-projet.
wiztricks le conseil est noté ;)
BufferBob et VinnsS, on a corrigé le code grâce à vous et cela fonctionne désormais ! Je laisse le code ici, au cas ou certains voudraient s'en inspirer et j'essaierai de le mettre à jour si j'effectue des améliorations. Bonne soirée à tout les amis du site !

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
from tkinter import *
test = 0
 
def quitter():
    fen.destroy()
 
def creation_lignes():
    for x in range(0,11):
        Canevas.create_line(64*x, 0, 64*x, 640, width=1, fill="blue")
        Canevas.create_line(0,64*x, 640, 64*x, width=1, fill="blue")
 
def clear():
    Canevas.delete("all")
    creation_lignes()
    creer_tableau()
 
def placement(n):
    m = int(n/64)
    m = 64*m
    return m
 
def creer_tableau():
    global tab
    tab = [[0 for i in range(10)] for j in range(10)]
 
def matrice_clic(X,Y):
    X = int(X/64)
    Y = int(Y/64)
    tab[Y][X] = 1
 
def Clic(event):
    # position du pointeur de la souris
    X = event.x
    Y = event.y
    X0 = placement(X)
    Y0 = placement(Y)
    X1 = X0 + 60
    Y1 = Y0 + 60
    r = 10
    Canevas.create_oval(X0+2, Y0+2, X1, Y1,fill='magenta')
    matrice_clic(X0,Y0)
 
def adapte_dessin():
    tab = tab2
    Canevas.delete("all")
    creation_lignes()
    for y in range(0,10):
        for x in range(0,10):
            z = tab[y][x]
            if z == 1:
                Canevas.create_oval(64*x+2, 64*y+2, (64*x)+60, (64*y)+60,fill='magenta')
    tab = tab2
 
 
def tour_suivant():
    global tab,tab2,x,y,test
    test = test +1
    tab2 = [[0 for i in range(10)] for j in range(10)]
    for y in range(10):
        for x in range(10):
            compter_cellules_voisines(y,x)
    tab = tab2
    adapte_dessin()
 
 
def verif_valeurs(m,n,o,p):
    if m == -1:
        m = 9
    if n == 10:
        n = 0
    if o == -1:
        o = 9
    if p == 10:
        p = 0
    return m,n,o,p
 
def adapte_matrice(y,x,z):
    tab2[y][x] = z
 
 
def cellule_actuelle(y,x,s):
    cell = tab[y][x]
    z = 0
    if cell == 0:                     # Si une cellule morte
        if s == 3:                    # possède exactement 3 voisins vivants
            z = 1                    # elle devient vivante
    else:
        if s == 2 or s == 3:           # Une cellule vivante avec 2 ou 3 voisines vivantes le reste
            z = 1                    # sinon elle meurt (z reste égal à 0)
    adapte_matrice(y,x,z)
 
 
 
def compter_cellules_voisines(y,x):
    m = y-1
    n = y+1
    o = x-1
    p = x+1
    m, n, o, p = verif_valeurs(m,n,o,p)
    a = tab[m][o]
    b = tab[m][x]
    c = tab[m][p]
    d = tab[y][o]
    e = tab[y][p]
    f = tab[n][o]
    g = tab[n][x]
    h = tab[n][p]
    s = a+b+c+d+e+f+g+h                #somme des cellules vivantes (voisines de la cellule actuelle(x,y))
    cellule_actuelle(y,x,s)
 
 
 
 
fen = Tk()                                                                        
fen.title("Le jeu de la vie")                                                     
fen.geometry("%dx%d%+d%+d" % (1105,680,80,100))
fen.resizable(width=False, height=False)
 
Canevas = Canvas(fen, width = 640, height = 640, bg = "White") 
Canevas.pack(side =LEFT, padx =18, pady =17 )
 
quitter = Button(fen, text ='Quitter le jeu', command =quitter)
quitter.pack(side =RIGHT, padx =40, pady =310)
 
clr = Button(fen, text ='Nettoyer le plateau', command =clear)
clr.pack(side =RIGHT)
 
etape = Button(fen, text ='Tour suivant', command = tour_suivant)
etape.pack(side =RIGHT, padx =30)
 
 
creation_lignes()
Canevas.bind('<Button-1>', Clic)
creer_tableau()
fen.mainloop()