Snake avec deux serpents

Bonjour,

Je suis en Terminale S avec option ISN.
Alors voilà, avec un ami nous avions comme projet de faire un jeux snake, seulement il y aurait 2 serpents jouables en même.

Bref, le problème c'est quand on perd la partie, il met impossible de créer un bouton recommencer qui me permettrai de recommencer le jeux avec le serpent a 0 ( la longueur ) et la position du serpent au milieu.

Je mets le code en joint.

Le code afin de réinitialiser le jeux est à la ligne 195 jusqu'à 218.

Les variables
dx1=0
dy1=0
dx2=0
dy2=0

permettent que le serpent ne bouge pas le temps qu'on appuie sur aucune touche --> ne fonctionne, sa fait comme si c'était pas là alors que dans le programme de base sa fonctionne. Explication ?

Comme vous pouvez le remarquer, j'ai pas de bouton "recommencer" pour l'instant vu que sa fonctionne pas, c'est pour cela que je demande votre aide ! Comment faire pour que quand je dépasse les limites de la fenêtre ( donc j'ai perdu ), le jeux se "stop"/"freeze" et que quand j'appuie sur un certain bouton "recommencer", les serpents se réinitialise avec une longueur de base et qu'ils se mettent au milieu SANS BOUGER ( c'est pour ça que les variables dx1, dy1...etc sont là ).

Merci d'avance ! Hakaii.

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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
from tkinter import *
from random import randrange
 
															# Définition des fonctions
 
 
# Met le serpent en mouvement toutes les secondes
def deplacement():
    global dx1,dy1,x,y,manger,flag,dx2,dy2
    finDePartie()
 
	# Permet de manger une pomme et d'en créer une autre
    # 1er serpent
    if coord_serpent1[0]==x and coord_serpent1[1]==y: # Si les coordonnées de la pomme sont les mêmes que le serpent
        canevas.delete(pomme)						# Supprime la pomme
 
        coord=len(coord_serpent1)
 
        x1=coord_serpent1[coord-4]					# Définit les coord. du dernier carrée à rajouter
        y1=coord_serpent1[coord-3]
        x2=coord_serpent1[coord-2]
        y2=coord_serpent1[coord-1]
 
 
        coord_serpent1.append(x1)					# Rajoute les coord. du nouveau carrée à la fin de coord_serpent
        coord_serpent1.append(y1)
        coord_serpent1.append(x2)
        coord_serpent1.append(y2)
 
        serpent1.append(canevas.create_rectangle(x1,y1,x2,y2,fill="green"))		# Crée carrée à la suite du serpent
 
        repas()										# Remet une pomme dans le canevas
 
	# Chaque carré va prendre les coordonnées de celui d'avant
    i=4
    j=1
 
	# Actualise les coord. du dernier carrée
    while j<len(serpent1):
        coord_serpent1[len(coord_serpent1)-(i)]=coord_serpent1[len(coord_serpent1)-(i+4)]
        coord_serpent1[len(coord_serpent1)-(i-1)]=coord_serpent1[len(coord_serpent1)-(i+3)]
        coord_serpent1[len(coord_serpent1)-(i-2)]=coord_serpent1[len(coord_serpent1)-(i+2)]
        coord_serpent1[len(coord_serpent1)-(i-3)]=coord_serpent1[len(coord_serpent1)-(i+1)]
        i+=4
        j+=1
 
	# Actualise les coord. du premier carrée
    coord_serpent1[0]=coord_serpent1[0]+dx1
    coord_serpent1[1]=coord_serpent1[1]+dy1
    coord_serpent1[2]=coord_serpent1[0]+10
    coord_serpent1[3]=coord_serpent1[1]+10
    i=0
    j=0
 
	# Redéfinie les coordonnées de chaque carrées en leurs faisant prendre les valeurs des coord. du carrée d'avant
 
    while j<len(serpent1):
        canevas.coords(serpent1[j],coord_serpent1[i],coord_serpent1[i+1],coord_serpent1[i+2],coord_serpent1[i+3])
        i+=4
        j+=1
    # 2nd serpent 
    if coord_serpent2[0]==x and coord_serpent2[1]==y: # Si les coordonnées de la pomme sont les mêmes que le serpent
        canevas.delete(pomme)						# Supprime la pomme
 
        coord=len(coord_serpent2)
 
        x3=coord_serpent2[coord-4]					# Définit les coord. du dernier carrée à rajouter
        y3=coord_serpent2[coord-3]
        x4=coord_serpent2[coord-2]
        y4=coord_serpent2[coord-1]
 
 
        coord_serpent2.append(x3)					# Rajoute les coord. du nouveau carrée à la fin de coord_serpent
        coord_serpent2.append(y3)
        coord_serpent2.append(x4)
        coord_serpent2.append(y4)
 
        serpent2.append(canevas.create_rectangle(x3,y3,x4,y4,fill="green"))		# Crée carrée à la suite du serpent
 
        repas()										# Remet une pomme dans le canevas
 
	# Chaque carré va prendre les coordonnées de celui d'avant
    i=4
    j=1
 
	# Actualise les coord. du dernier carrée
    while j<len(serpent2):
        coord_serpent2[len(coord_serpent2)-(i)]=coord_serpent2[len(coord_serpent2)-(i+4)]
        coord_serpent2[len(coord_serpent2)-(i-1)]=coord_serpent2[len(coord_serpent2)-(i+3)]
        coord_serpent2[len(coord_serpent2)-(i-2)]=coord_serpent2[len(coord_serpent2)-(i+2)]
        coord_serpent2[len(coord_serpent2)-(i-3)]=coord_serpent2[len(coord_serpent2)-(i+1)]
        i+=4
        j+=1
 
	# Actualise les coord. du premier carrée
    coord_serpent2[0]=coord_serpent2[0]+dx2
    coord_serpent2[1]=coord_serpent2[1]+dy2
    coord_serpent2[2]=coord_serpent2[0]+10
    coord_serpent2[3]=coord_serpent2[1]+10
    i=0
    j=0
 
	# Redéfinie les coordonnées de chaque carrées en leurs faisant prendre les valeurs des coord. du carrée d'avant
 
    while j<len(serpent2):
        canevas.coords(serpent2[j],coord_serpent2[i],coord_serpent2[i+1],coord_serpent2[i+2],coord_serpent2[i+3])
        i+=4
        j+=1
 
 
    fen.after(50,deplacement)			# Fait appel à la fonction deplacement après 50 millisecondes de pause   ==> VITESSE DU SERPENT
 
 
 
# Créer une pomme avec des coordonnées au hasard
def repas():
    global manger,x,y,pomme,coord_serpent1
 
    x=randrange(10,480,10)
    y=randrange(10,280,10)
    pomme=canevas.create_oval(x,y,x+10,y+10,fill="red")
 
 
 
# Permet de diriger le serpent
def gauche(event):
    global dx1,dy1,direction1
 
    if direction1!=2:
        dx1=-10
        dy1=0
        direction1=1				# Interdit le déplacement dans le sens opposé
 
def gauche2(event):
    global dx2,dy2,direction2
 
    if direction2!=2:
        dx2=-10
        dy2=0
        direction2=1				# Interdit le déplacement dans le sens opposé
 
def droite(event):
    global dx1,dy1,direction1
 
    if direction1!=1 :
        dx1=10
        dy1=0
        direction1=2				# Interdit le déplacement dans le sens opposé
 
def droite2(event):
    global dx2,dy2,direction2
 
    if direction2!=1:
        dx2=10
        dy2=0
        direction2=2				# Interdit le déplacement dans le sens opposé
 
 
def haut(event):
    global dx1,dy1,direction1
 
    if direction1!=4:
        dx1=0
        dy1=-10
        direction1=3				# Interdit le déplacement dans le sens opposé
 
def haut2(event):
    global dx2,dy2,direction2
 
    if direction2!=4:
        dx2=0
        dy2=-10
        direction2=3				# Interdit le déplacement dans le sens opposé
 
def bas(event):
    global dx1,dy1,direction1
 
    if direction1!=3:
        dx1=0
        dy1=10
        direction1=4				# Interdit le déplacement dans le sens opposé
 
def bas2(event):
    global dx2,dy2,direction2
 
    if direction2!=3:
        dx2=0
        dy2=10
        direction2=4				# Interdit le déplacement dans le sens opposé
 
 
 
 
# Fin de la partie
def  finDePartie ():
    if coord_serpent1[2]==l or coord_serpent1[0]==0 or coord_serpent1[1]==0 or coord_serpent1[3]==h or coord_serpent2[2]==l or coord_serpent2[0]==0 or coord_serpent2[1]==0 or coord_serpent2[3]==h : #  Quand le serpent sort du canevas
        popup()
        reinitialiser()
 
 
 
# Réinitialiser le programme
def reinitialiser():
    global coord_serpent1
    global coord_serpent2
    coord_serpent1.clear()
    coord_serpent2.clear()
 
    xstart1=randrange(10,480,10)
    ystart1=randrange(10,480,10)
    coord_serpent1=[xstart1,ystart1,0,0]
 
    xstart2=randrange(10,480,10)
    ystart2=randrange(10,480,10)
    coord_serpent2=[xstart2,ystart2,0,0]
    dx1=0
    dy1=0
    dx2=0
    dy2=0
 
def popup():
    fInfos = Toplevel()
    fInfos.title('Fin de la partie')
    Button(fInfos, text='Recommencer', command=fInfos.destroy).pack(padx=50, pady=50)
    fInfos.transient(fen)      
    fInfos.grab_set()         
    fen.wait_window(fInfos)
 
 
 
 
 
 
 
 
 
 
 
 
																					# Programme
 
 
# Définition du canevas (carrée où se déplace le serpent)
h=500                                             #Hauteur
l=500                                             #Largeur
fen=Tk()                                           #Crée un objet qui est la fenêtre
fen.title("Snake ISN")                             #Nom de la fenêtre
canevas=Canvas(fen,width=l,height=h,bg="white")       #Taille de la fenêtre
 
 
 
# Définit les touches qui permettront de diriger le serpent
canevas.bind_all("<Up>",haut)
canevas.bind_all("<Left>",gauche)
canevas.bind_all("<Right>",droite)
canevas.bind_all("<Down>",bas)
 
canevas.bind_all("z",haut2)
canevas.bind_all("q",gauche2)
canevas.bind_all("d",droite2)
canevas.bind_all("s",bas2)
 
# Positionne le canevas
canevas.grid(row=0,column=0)
 
# Coordonnées de départ du serpent
xstart1=randrange(10,480,10)
ystart1=randrange(10,480,10)
coord_serpent1=[xstart1,ystart1,0,0]
 
xstart2=randrange(10,480,10)
ystart2=randrange(10,480,10)
coord_serpent2=[xstart2,ystart2,0,0]
 
# Définition des coordonnées de départ du serpent
serpent1=[canevas.create_rectangle(coord_serpent1[0],coord_serpent1[1],coord_serpent1[2],coord_serpent1[3],fill="yellow")]
serpent2=[canevas.create_rectangle(coord_serpent2[0],coord_serpent2[1],coord_serpent2[2],coord_serpent2[3],fill="blue")]
 
# Création de variables qui vont permettrent de faire manger le serpent ainsi que de le déplacer.
flag=1
 
# Création de la première pomme
x=randrange(10,480,10)
y=randrange(10,480,10)
pomme=canevas.create_oval(x,y,x+10,y+10,fill="red") # Définit les dimensions de la pomme
 
# Reste immobile au début (dx = déplacement horizontal. dy = déplacement vertical)
dx1=0
dy1=0
 
dx2=0
dy2=0
 
 
# Créer la variable direction
direction1=0
direction2=0
# Permet au serpent de se déplacer
deplacement()
 
# Création du bouton quitter
 
bouton_quitter=Button(text="Quitter",command=fen.destroy)
bouton_quitter.grid(row=310,column=0)
 
 
 
 
# Permet la fenêtre de capter les actions que l'on fait en réactulisant tout le temps
fen.mainloop()

Houla ! Je viens de remarquer que j'avais oublié de mettre le code en joint !

Désolé.

Le code que j'ai envoyé est le programme que je viens juste de faire : il permet que quand je perd il y est une fenêtre qui apparait avec un bouton recommencer .
Le bouton fonctionne sauf que les serpents sont directement en mouvement alors que normalement ils doivent être à l'arrêt !

De plus, du moment que j'ai mangé 1 pomme, et que je perd par après, j'ai une erreur de type : list index out of range a propos du "canvas.coord". Help pls !

Merci encore ^^.

Salut,

le code est difficilement lisible pour une personne externe au truc et qui ne connait pas tkinker.
Est-ce là tout le code ? Où se trouve la boucle principale ou le programme que je peux trouver ici https://docs.python.org/3/library/tk...-world-program ?
Logiquement, ton code devrait ressembler à
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 initialisation state = Idle encore de l'initialisation while 1: if state == Idle: attente de la première pression pour démarrer elif state == InGame: ça joue elif state == GameOver: game over, menu recommencer, ... désinitialisation fermeture du programme
Ensuite tu devrais avoir une fonction pour gérer l'appui de touches qui démarre le jeu si t'es Idle, ou déplace le serpent s'il est InGame.
Tu as plusieurs façon de gérer, selon ce que tu connais.
Celle que je recommande serait d'avoir une classe par état à appeler qui gèrerait toute la logique propre à cet état.
À défaut de classe, tu peux au moins avoir une fonction par état, il y aura peut-être plus de variables externes / globales pour gérer des trucs.

Et le tout sera à priori englobé dans la classe / fonction que tkinker utilise pour l'application.

https://alexandre-laurent.developpez...boucle-de-jeu/

Salut,

Citation:

Envoyé par Hakaii

Bref, le problème c'est quand on perd la partie, il met impossible de créer un bouton recommencer qui me permettrai de recommencer le jeux avec le serpent a 0 ( la longueur ) et la position du serpent au milieu.

Pour recommencer, il faut écrire une fonction qui remette le jeu dans son état initial: votre fonction réinitialiser est à priori là pour çà. Mais la plupart des variables à remettre en place sont globales (et vous connaissez ce type de variables là)...
Donc qu'est ce qui coince? (Sachant que je ne vas pas apprendre à jouer à votre truc pour comprendre ce qui cloche).

- W

J'y est déjà pensé, mais sa va être dur je pense ^^. Le temps va me rattraper du coup j'ai un peu peur de vouloir "chambouler" tout mon programme, parce que là, il faudrait que je réecris tout de la bonne façon... même si j'ai les grandes lignes, j'ai peur de mal faire ou autre.

D'ailleurs, j'avais déjà fait une fonction avec tout dedans, afin de pouvoir la rappeler dès que je voulais recommencer le jeux, malheureusement , sa fonctionnais pas ^^.

Bonne soirée ! Merci pour vos réponses et liens.
Citation:
Envoyé par Bousk
Salut,

le code est difficilement lisible pour une personne externe au truc et qui ne connait pas tkinker.
Est-ce là tout le code ? Où se trouve la boucle principale ou le programme que je peux trouver ici https://docs.python.org/3/library/tk...-world-program ?
Logiquement, ton code devrait ressembler à
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 initialisation state = Idle encore de l'initialisation while 1: if state == Idle: attente de la première pression pour démarrer elif state == InGame: ça joue elif state == GameOver: game over, menu recommencer, ... désinitialisation fermeture du programme
Ensuite tu devrais avoir une fonction pour gérer l'appui de touches qui démarre le jeu si t'es Idle, ou déplace le serpent s'il est InGame.
Tu as plusieurs façon de gérer, selon ce que tu connais.
Celle que je recommande serait d'avoir une classe par état à appeler qui gèrerait toute la logique propre à cet état.
À défaut de classe, tu peux au moins avoir une fonction par état, il y aura peut-être plus de variables externes / globales pour gérer des trucs.

Et le tout sera à priori englobé dans la classe / fonction que tkinker utilise pour l'application.

https://alexandre-laurent.developpez...boucle-de-jeu/
Merci de la réponse, je vais essayer d'implanter ça dans mon programme !
Oui c'est bien le programme en entier !

Bonne soirée.