Snake avec Python 3.0 et Tkinter

**tonykart13** · 25/05/2012, 15h36

Bonjour à tous..

Je me suis lancé dans un petit projet et j'aimerais bien faire le jeu "Snake" en Python.

Voilà mon code jusqu'ici :

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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
from tkinter import *
from random import randrange
 
#############################
#                           #
#        Fonctions :        #
#                           #
#############################
 
def move():
    global x1, y1, dx, dy, flag
    x1, y1 = x1 + dx, y1 + dy
    if direction  == 'gauche':
        x1  = x1 - dx
    if direction  == 'droite':
        x1  = x1 + dx
    if y1 >470:
        y1, dx, dy = 470, -15, 0
    if x1 <10:
        x1, dx, dy = 10, 0, -15
    if y1 <10:
        y1, dx, dy = 10, 15, 0
    can.coords(rectangle, x1, y1, x1 + 10, y1 + 10)
    if flag >0:
        fen.after(70, move)
 
def start_it():
    global flag
    if flag ==0:
        flag =1
    move()
 
def newGame():
    pX = randrange(5,495)
    pY = randrange(5,495)
    can.create_oval(pX, pY, pX + 5, pY + 5, outline = 'white', fill = 'green')
    move()
    start_it()
 
def avance(gd, hb):
    global x1, y1
    x1, y1 = x1 + gd, y1 + hb
    can1.coords(oval1, x1,y1, x1+30,y1+30)
 
def left(event):
    direction = 'gauche'
 
def right(event):
    direction = 'droite'
 
def up(event):
    direction = 'haut'
 
def down(event):
    avance(0, 10)
 
#######################################
#                                     #
#        Programme principal :        #
#                                     #
#######################################
 
x1 = 245
y1 = 245
dx, dy = 15, 0
flag = 0
direction = ''
 
 
fen = Tk()
can = Canvas(fen, width = 500, height = 500, bg = '#046380')
can.pack(side = TOP, padx = 5, pady = 5)
rectangle = can.create_rectangle(x1, y1, x1 + 10, y1 + 10, outline = 'white', fill = '#C03000')
b1 = Button(fen, text = 'New Game', command = newGame)
b1.pack(side = LEFT, padx  = 5, pady = 5)
b2 = Button(fen, text = 'Quitter', command = fen.destroy)
b2.pack(side = RIGHT, padx = 5, pady  = 5)
b3 = Button(fen, text = 'Scores')
b3.pack(side = RIGHT, padx = 5, pady = 5)
tex1 = Label(fen, text='Cliquez sur \'New Game\' pour commener.', fg='#333333')
tex1.pack(padx = 0, pady = 11)
fen.bind('<Right>', right)
fen.bind('<Left>', left)
fen.bind('<Up>' , up)
fen.bind('<Down>', down)
fen.mainloop()

Je n'arrive pas à diriger mon serpent en fait.. Quelqu'un saurait me donner un coup de pouce pour que je puisse avancer ?

Merci beaucoup à vous !

**Bear the french** · 25/05/2012, 20h52

Bonjour tonykart13,

Tu peux peut-être t'inspirer de ce poste

: http://www.developpez.net/forums/d51...on-snake-like/

Bertrand

**PauseKawa** · 26/05/2012, 07h05

Bonjour,

Sur le code donné

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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
from tkinter import *
from random import randrange
 
#############################
#                           #
#        Fonctions :        #
#                           #
#############################
 
def move():
    global x
    global y
    if direction  == 'gauche':
        x  = x - dx
    elif direction  == 'droite':
        x  = x + dx
    elif direction  == 'haut':
        y  = y - dy
    elif direction  == 'bas':
        y  = y + dy
    #if y1 > 470:
    #    y1, dx, dy = 470, -15, 0
    #if x1 < 10:
    #    x1, dx, dy = 10, 0, -15
    #if y1 < 10:
    #    y1, dx, dy = 10, 15, 0
    can.coords(rectangle, x, y, x+10, y+10)
    if flag != 0:
        fen.after(70, move)
 
def newGame():
    pX = randrange(5, 495)
    pY = randrange(5, 495)
    can.create_oval(pX, pY, pX+5, pY+5, outline='white', fill='green')
    global flag
    if flag == 0:
        flag = 1
    move()
 
def left(event):
    global direction
    direction = 'gauche'
 
def right(event):
    global direction
    direction = 'droite'
 
def up(event):
    global direction
    direction = 'haut'
 
def down(event):
    global direction
    direction = 'bas'
 
#######################################
#                                     #
#        Programme principal :        #
#                                     #
#######################################
 
x = 245
y = 245
dx, dy = 10, 10
flag = 0
direction = 'droite'
 
 
fen = Tk()
can = Canvas(fen, width=500, height=500, bg='#046380')
can.pack(side=TOP, padx=5, pady=5)
rectangle = can.create_rectangle(x, y, x+10, y+10, outline='white', fill='#C03000')
b1 = Button(fen, text='New Game', command=newGame)
b1.pack(side=LEFT, padx=5, pady=5)
b2 = Button(fen, text='Quitter', command=fen.destroy)
b2.pack(side=RIGHT, padx=5, pady =5)
b3 = Button(fen, text='Scores')
b3.pack(side=RIGHT, padx=5, pady=5)
tex1 = Label(fen, text="Cliquez sur 'New Game' pour commencer", fg='#333333')
tex1.pack(padx=0, pady=11)
fen.bind('<Right>', right)
fen.bind('<Left>', left)
fen.bind('<Up>' , up)
fen.bind('<Down>', down)
fen.mainloop()

@+

**tonykart13** · 26/05/2012, 11h31

Super PauseKawa !

Si maintenant le serpent sort d'un côté il disparaît.. Comment pourrait-on faire pour qu'il rentre à nouveau de l'autre côté ? Ou c'est trop compliqué ?

Je comprends le code que tu m'as modifié mais je n'arrive pas à programmer.. J'ai essayé de lire et de comprendre d'autres codes du jeu Snake c'est compliqué

**PauseKawa** · 26/05/2012, 11h53

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
def move():
    global x
    global y
    if direction  == 'gauche':
        x  = x - dx
    elif direction  == 'droite':
        x  = x + dx
    elif direction  == 'haut':
        y  = y - dy
    elif direction  == 'bas':
        y  = y + dy
    if y > 500:
        y = 0
    elif y < 0:
        y = 500
    if x > 500:
        x = 0
    elif x < 0:
        x = 500
    #    y1, dx, dy = 470, -15, 0
    #if x1 < 10:
    #    x1, dx, dy = 10, 0, -15
    #if y1 < 10:
    #    y1, dx, dy = 10, 15, 0
    can.coords(rectangle, x, y, x+10, y+10)
    if flag != 0:
        fen.after(70, move)

**tonykart13** · 29/05/2012, 17h48

Merci PauseKawa !

Comment je pourrais faire pour que le serpent se ralonge lorsqu'il rencontre une pomme et qu'une nouvelle pomme apparaîsse à un autre endroit du canevas ?

Merci pour ta patience et ton aide !

**wiztricks** · 29/05/2012, 18h55

Salut,

Dans la version "vintage", le serpent se déplace sur un quadrillage construit avec des cases d'environ 10 pixels de côté.
Le quadrillage peut être définit par un ensemble de cases [1..N] x [1..N]

A chaque "tick", la tête du serpent, représentée comme une case, se déplace d'une case suivant sa direction ('Left', 'Up', 'Right', 'Down')
Et son corps est la liste de cases, initialement vide qui doit suivre... la tête.

Comment je pourrais faire pour que le serpent se ralonge lorsqu'il rencontre une pomme et qu'une nouvelle pomme apparaîsse à un autre endroit du canevas ?

Faire apparaître une pomme de façon aléatoire, c'est (à chaque tick):

constater qu'il n'y a plus de pomme,
générer deux entiers dans un intervalle 1..N via random.randint,
s'assurer que la case correspondante n'est pas occupée par le serpent,
montrer la pomme sur le grillage,

Manger une pomme c'est (à chaque tick):

détecter la collision de la tête avec la (ou une) pomme,
faire disparaître la pomme,
étendre le corps du serpent,

Etendre le corps du serpent.
A chaque tick, le serpent avance et/ou s'allonge. Si on prend l'option de dire que le "corps" du serpent est une "liste de cases":
_avancer_ :

récupérer le dernier point du "corps",
l'afficher "à la place actuelle" de la tête,
insérer la case en tête de liste "corps",
avancer la tête

_étendre_ :

créer une case à la place actuelle de la tête
insérer la case en tête de la liste "corps",
avancer la tête

nota, si manger une pomme fait grossir le corps de 3 cases, "manger une pomme" pourra initialiser/ajouter 3 à une variable "extend". A chaque tick, si extend est >0, on ajoute une case au serpent et on la décrémente.

Bon ce ne sont que des suggestions mais il faut bien partir de quelque chose avant de se lancer dans le codage.

Qu'en pensez vous?

Cordialement,
- W

**tonykart13** · 30/05/2012, 11h03

Merci pour ta réponse. N'y a-t-il pas moyen de réaliser le jeu sans quadriller tout l'espace de jeu ? Comment pourrait-on le faire en prenant le code de PauseKawa ? On pourrait faire une fonction qui détecte si les coordonnées de la tête du serpent sont égales aux coordonnées de la pomme ? Merci pour vôtre aide !

**wiztricks** · 30/05/2012, 12h30

Envoyé par tonykart13

Merci pour ta réponse. N'y a-t-il pas moyen de réaliser le jeu sans quadriller tout l'espace de jeu ?

Comme vous utilisez un canvas Tk, le quadrillage pourra être "implicite", "explicite", ou un peu des deux.

Reconsidérez la question de la création d'une pomme.
Disons que le canvas est un carré de PIXELS_COUNT de côté.
La pomme sera un carré de X pixels (de côté)

Pour placer la pomme de façon aléatoire sur le canvas, vous pourrez prendre
un nombre aléatoire J dans 0..PIXELS_COUNT.
Pour le dessiner, il faudra en faire la division entière par X

Soit dire il y a 1..PIXELS_COUNT/X intervalles et multiplier par X...

A vous de choisir la "forme" la plus appropriée pour représenter votre "grille".

On pourrait faire une fonction qui détecte si les coordonnées de la tête du serpent sont égales aux coordonnées de la pomme ? Merci pour vôtre aide !

Lorsque vous crééz un objet sur le canvas via .create_xxx, la méthode retourne un entier appelé item identifier qu'on abrégera par iid.

Après avoir crée la tete et les pommes vous aurez donc les iid correspondants à ces "objets" placés sur le canvas.

Pour récupérer les coordonnées d'un objet, le code de PauseKawa utilise .coords qui vous retourne les x0, y0, x1, y1.

A ces coordonnées vous pouvez appliquez .find_overlapping qui retournera l' iid des objets dont l'intersection avec le "rectangle" délimité par ces coordonnées sera non vide.
Il vous restera à trier s'ils sont "pomme" ou "corps" du serpent.

Comment pourrait-on le faire en prenant le code de PauseKawa ?

Heu?!? Dans ce film, c'est à vous que revient le rôle d'écrire le code.
Vous voulez partir de ce qu'à proposé PauseKawa: super, très bien...
A propos, si vous relisez le code de PauseKawa, vous y trouvez des choses comme:

Code :

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

1
2
3
4
5
6
7
8
9
10
...
    can.coords(rectangle, x, y, x+10, y+10)
... 
dx, dy = 10, 10
flag = 0
direction = 'droite'
 
fen = Tk()
can = Canvas(fen, width=500, height=500, bg='#046380')
...

qui sans le dire "explicitement" décrivent une grille de 500 pixels de côté avec des cases de 10 px.

Vous voulez voir un snake déjà réalisé "Bear the french" vous a déjà donné un pointeur vers un code qui fait çà.

- W

**tonykart13** · 30/05/2012, 19h27

Merci pour votre aide.

J'ai un texte à afficher mais je n'arrive pas à changer sa couleur de police...

Code :

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

pause=can1.create_text(250,150,font=('Fixedsys',18),text="PAUSE", color="red")

Quelqu'un pourrait me dire comment je pourrais faire pour que le texte s'affiche dans une autre couleur que le noir ?

Merci

**PauseKawa** · 30/05/2012, 19h32

Bonjour,

Pour un élément text l'option c'est fill="red"

@+

**tonykart13** · 30/05/2012, 20h22

Merci PauseKawa

Maintenant j'aimerais pouvoir enregistrer le score à chaque fois que le serpent touche le mur, voilà ce que j'ai fais :

Code :

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

1
2
3
4
5
6
7
8
9
# Si le serpent touche le mur la partie s'arrête
 
    if coord_serpent[0]>=490 or coord_serpent[0]<=0 or coord_serpent[1]>=290 or coord_serpent[1]<=0:
        flag=0
        flag2=1
        perdu=can1.create_text(250,150,font=('Fixedsys',18),text="Score : "+str(score), fill="#FF358B")
        oFichier = open('score.txt', 'a')
        oFichier.write(str(score)+'\n')
        oFichier.close()

Comment je pourrais faire pour que l'utilisateur puisse entrer son nom et que le programme enregistre son nom suivi d'un # et puis du score ? J'aimerais afficher les meilleurs scores après dans une petite liste

Merciiii !!

**tonykart13** · 31/05/2012, 13h45

J'ai essayé de le faire ainsi mais ça n'a pas l'air de fonctionner.

Code :

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

1
2
3
4
5
6
perdu = can1.create_text(250,150,font=('Fixedsys',18),text="Score : "+str(score), fill="#FF358B")
        nom = Entry(fen1).grid(row=8,column=1,sticky=N)
        nomJ = Button(fen1, text="Ok", width=10, command=nom.get()).grid(row=9,column=1,sticky=N)
        oFichier = open('score.txt', 'a')
        oFichier.write(str(score) + '\n')
        oFichier.close()

Ce qui serait super c'est que le champs pour entrer son nom apparaîsse au milieu du canevas. Exactement comme le score...

Merci

**wiztricks** · 31/05/2012, 16h24

Salut,

Le canvas gère sa "geometry" et la toplevel n'a pas la possibilité de placer quelque chose au dessus du canvas.

Les solutions pourraient être:
1 - créer une toplevel 'à la' pop-up pour afficher ces widgets là,
2 - incruster les widgets dans le canvas via .create_window,

Bon courage,
- W

**tonykart13** · 03/06/2012, 14h54

Bonjour à tous encore une fois..

Je n'arrive toujours pas à gérer mon fichier texte pour pouvoir enregistrer les joueurs et leurs scores...

Voilà comment j'essaie de faire :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Si le serpent touche le mur la partie s'arrête
 
    if coord_serpent[0]>=490 or coord_serpent[0]<=0 or coord_serpent[1]>=290 or coord_serpent[1]<=0:
        flag=0
        flag2=1
        perdu = can1.create_text(250,150,font=('Fixedsys',18),text="Score : "+str(score), fill="#FF358B")
        nomJ = Entry(fen1)
        nomJ.grid(row=9,column=1,sticky=N)
        entry = nomJ.get()
        b = Button(fen1, text="Envoyer", width=10, command=entry)
        b.grid(row=10,column=1,sticky=N)
        oFichier = open('score.txt', 'a')
        oFichier.write(str(entry) + '#' + str(score) + '\n')
        oFichier.close()

Quelqu'un pourrait s'il vous plaît m'aider ?

Un grand merci d'avance.

**wiztricks** · 04/06/2012, 12h23

Salut,

Pas facile de vous aider! Le code que vous nous montrez devrait fonctionner.
Qu'entendez vous par "gérer mon fichier texte pour pouvoir enregistrer les joueurs et leurs scores"?

- W

**tonykart13** · 04/06/2012, 12h49

Voici mon code en entier :

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
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
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
# -*- coding: cp1252 -*-
 
# Importations des fonctions nécessaires
 
from tkinter import *
from random import randrange
 
# Déclarations des fonctions
 
# Cette fonction permet de réinitialiser le jeu
 
def new_game():
    global dx,dy,x,y,eat,flag,serpent,coord_serpent,direction,coord_yeux,yeux,score,f,flag2
 
    flag2=0
 
    can1.delete(ALL)
 
    can1.create_rectangle(0,0,10,300,fill="black")
    can1.create_rectangle(0,0,500,10,fill="black")
    can1.create_rectangle(490,0,500,300,fill="black")
    can1.create_rectangle(0,300,500,290,fill="black")
 
    coord_serpent=[50,50,60,60]
 
    coord_yeux=[coord_serpent[0]+6,coord_serpent[1]+2,coord_serpent[2]-2,coord_serpent[3]-6,coord_serpent[0]+6,coord_serpent[1]+6,coord_serpent[2]-2,coord_serpent[3]-2]
    serpent=[can1.create_rectangle(coord_serpent[0],coord_serpent[1],coord_serpent[2],coord_serpent[3],fill="#01B0F0")]
 
    yeux=[can1.create_oval(coord_yeux[0],coord_yeux[1],coord_yeux[2],coord_yeux[3],fill="black")]
    yeux.append(can1.create_oval(coord_yeux[4],coord_yeux[5],coord_yeux[6],coord_yeux[7],fill="black"))
 
    eat=0
 
    x=randrange(10,480,10)
    y=randrange(10,280,10)
    f=can1.create_oval(x,y,x+10,y+10,fill="#AEEE00")
 
    dx=10
    dy=0
    direction=2
    score=0
 
    if flag==0:
        flag=1
        move()
 
# Cette fonction permet d'effectuer une pause en cours de partie
 
def pause(event):
    global flag,pause,flag2
    if flag2!=1:
        if flag==1:
            pause=can1.create_text(250,150,font=('Fixedsys',18),text="PAUSE", fill="#FF358B")
            flag=0
        elif flag==0:
            flag=1
            can1.delete(pause)
            move()
 
def update_score_file(name_var, score):
 
    with open('score.txt', 'a') as score_file:
        score_file.write(name_var.get() + '#' + str(score) + '\n')
 
# Cette fonction va permettre de mettre le serpent en mouvement de manière automatique
 
def move():
    global dx,dy,x,y,eat,flag,f,serpent,coord_serpent,direction,coord_yeux,yeux,score,flag2
 
    # Si le serpent mange une proie on l'allonge d'un carré et cela
    # en fonction de la direction afin que le nouveau carré soit bien
    # dessiné à la suite du dernier carré composant le serpent
 
    if coord_serpent[0]==x and coord_serpent[1]==y:
        can1.delete(f)
        eat=1
        coord=len(coord_serpent)
        score=score+100
        if direction==1:
 
            x1=coord_serpent[coord-4]
            y1=coord_serpent[coord-3]
            x2=coord_serpent[coord-2]
            y2=coord_serpent[coord-1]
 
            x1=x1+10
            x2=x2+10
            y2=y2+10
 
            coord_serpent.append(x1)
            coord_serpent.append(y1)
            coord_serpent.append(x2)
            coord_serpent.append(y2)
 
            serpent.append(can1.create_rectangle(x1,y1,x2,y2,fill="#01B0F0"))
 
        elif direction==2:
 
            x1=coord_serpent[coord-4]
            y1=coord_serpent[coord-3]
            x2=coord_serpent[coord-2]
            y2=coord_serpent[coord-1]
 
            x1=x1-10
            x2=x2-10
            y2=y2+10
 
            coord_serpent.append(x1)
            coord_serpent.append(y1)
            coord_serpent.append(x2)
            coord_serpent.append(y2)
 
            serpent.append(can1.create_rectangle(x1,y1,x2,y2,fill="#01B0F0"))
 
 
        elif direction==3:
 
            x1=coord_serpent[coord-4]
            y1=coord_serpent[coord-3]
            x2=coord_serpent[coord-2]
            y2=coord_serpent[coord-1]
 
            y1=y1+10
            y2=y2+10
 
            coord_serpent.append(x1)
            coord_serpent.append(y1)
            coord_serpent.append(x2)
            coord_serpent.append(y2)
 
            serpent.append(can1.create_rectangle(x1,y1,x2,y2,fill="#01B0F0"))
 
 
        elif direction==4:
 
            x1=coord_serpent[coord-4]
            y1=coord_serpent[coord-3]
            x2=coord_serpent[coord-2]
            y2=coord_serpent[coord-1]
 
            x2=x2+10
            y2=y2-10
 
            coord_serpent.append(x1)
            coord_serpent.append(y1)
            coord_serpent.append(x2)
            coord_serpent.append(y2)
 
            # On rajoute un nouveau carré dans notre liste de carrés
 
            serpent.append(can1.create_rectangle(x1,y1,x2,y2,fill="#01B0F0"))
 
 
    food()
 
    # Les coordonnées de chaque carré prendront les coordonnées du carré qui le succède
    # cela permettra à chacun des carré de se suivre et d'obtenir l'effet du serpent :)
 
 
    i=4
    j=1
 
    while j<len(serpent):
        coord_serpent[len(coord_serpent)-(i)]=coord_serpent[len(coord_serpent)-(i+4)]
        coord_serpent[len(coord_serpent)-(i-1)]=coord_serpent[len(coord_serpent)-(i+3)]
        coord_serpent[len(coord_serpent)-(i-2)]=coord_serpent[len(coord_serpent)-(i+2)]
        coord_serpent[len(coord_serpent)-(i-3)]=coord_serpent[len(coord_serpent)-(i+1)]
        i+=4
        j+=1
 
 
    # On fait le serpent avancer
 
    coord_serpent[0]=coord_serpent[0]+dx
    coord_serpent[1]=coord_serpent[1]+dy
    coord_serpent[2]=coord_serpent[0]+10
    coord_serpent[3]=coord_serpent[1]+10
 
    # Histoire que le serpent ne perde pas ses yeux en route on les fait
    # également avancer avec lui XD mais cela en fonction de la direction
    # choisi sinon ses yeux risquent de se ballader n'importe où :)
 
    if direction==1:
        coord_yeux[0]=coord_serpent[0]+2
        coord_yeux[1]=coord_serpent[1]+2
        coord_yeux[2]=coord_serpent[2]-6
        coord_yeux[3]=coord_serpent[3]-6
        coord_yeux[4]=coord_serpent[0]+2
        coord_yeux[5]=coord_serpent[1]+6
        coord_yeux[6]=coord_serpent[2]-6
        coord_yeux[7]=coord_serpent[3]-2
 
    elif direction==2:
        coord_yeux[0]=coord_serpent[0]+6
        coord_yeux[1]=coord_serpent[1]+2
        coord_yeux[2]=coord_serpent[2]-2
        coord_yeux[3]=coord_serpent[3]-6
        coord_yeux[4]=coord_serpent[0]+6
        coord_yeux[5]=coord_serpent[1]+6
        coord_yeux[6]=coord_serpent[2]-2
        coord_yeux[7]=coord_serpent[3]-2
 
    elif direction==3:
        coord_yeux[0]=coord_serpent[0]+2
        coord_yeux[1]=coord_serpent[1]+2
        coord_yeux[2]=coord_serpent[2]-6
        coord_yeux[3]=coord_serpent[3]-6
        coord_yeux[4]=coord_serpent[0]+6
        coord_yeux[5]=coord_serpent[1]+2
        coord_yeux[6]=coord_serpent[2]-2
        coord_yeux[7]=coord_serpent[3]-6
 
    elif direction==4:
        coord_yeux[0]=coord_serpent[0]+2
        coord_yeux[1]=coord_serpent[1]+6
        coord_yeux[2]=coord_serpent[2]-6
        coord_yeux[3]=coord_serpent[3]-2
        coord_yeux[4]=coord_serpent[0]+6
        coord_yeux[5]=coord_serpent[1]+6
        coord_yeux[6]=coord_serpent[2]-2
        coord_yeux[7]=coord_serpent[3]-2
 
    i=4
    j=1
 
    # Si le serpent touche le mur la partie s'arrête
 
    if coord_serpent[0]>=490 or coord_serpent[0]<=0 or coord_serpent[1]>=290 or coord_serpent[1]<=0:
        flag=0
        flag2=1
        perdu = can1.create_text(250,150,font=('Fixedsys',18),text="Score : "+str(score), fill="#FF358B")
 
        name_var = StringVar()
        name_var.set('Nobody')
        nomJ = Entry(fen1, textvariable=name_var, bg='white')
        nomJ.grid(row=9,column=1,sticky=N)
        nomJ.focus_set()
 
        cmd_update_score = partial(update_score_file, name_var, score)
        b = Button(fen1, text="Envoyer", width=10, command=cmd_update_score)
        b.grid(row=10,column=1,sticky=N)
 
    # Si les coordonnées du 1er carré sont égales aux coordonnées d'un des autres carrés composant le serpent
    # cela signifie qu'il s'est recoupé par conséquent la partie s'arrête :p
 
 
    while j<len(serpent):
        if coord_serpent[0]==coord_serpent[i] and coord_serpent[1]==coord_serpent[i+1] and coord_serpent[2]==coord_serpent[i+2] and coord_serpent[3]==coord_serpent[i+3]:
            flag=0
            flag2=1
            perdu=can1.create_text(250,150,font=('Fixedsys',18),text="Score : "+str(score), fill="#FF358B")
            oFichier = open('score.txt', 'a')
            oFichier.write(str(score) + '\n')
            oFichier.close()
        i+=4
        j+=1
 
    i=0
    j=0
 
    if flag!=0:
 
        # On redéfinie les coordonnées des yeux de notre cher serpent
 
        can1.coords(yeux[0],coord_yeux[0],coord_yeux[1],coord_yeux[2],coord_yeux[3])
        can1.coords(yeux[1],coord_yeux[4],coord_yeux[5],coord_yeux[6],coord_yeux[7])
 
        while j<len(serpent):
 
            # On redéfinie les coordonnées de chacun des carré
            # composant le corps du serpent
 
            can1.coords(serpent[j],coord_serpent[i],coord_serpent[i+1],coord_serpent[i+2],coord_serpent[i+3])
 
            i+=4
            j+=1
 
    if flag>0:
        fen1.after(50,move)
 
# Cette fonction va permettre de générer au hasard de la nourriture dans le canevas
 
def food():
    global eat,x,y,f,coord_serpent
    if eat==1:
        x=randrange(10,480,10)
        y=randrange(10,280,10)
        i=0
        i2=0
 
        # Afin d'éviter de générer de la nourriture sur le serpent
        # j'utilise ce bout de code qui s'occupera de générer un nouveau de tas de nourriture
        # si les coordonnées du précédent sont égales aux coordonnées d'un carré composant
        # le corps du serpent
 
        while i<len(coord_serpent):
            i2=1
            if x==coord_serpent[i] and y==coord_serpent[i+1]:
                while x==coord_serpent[i] and y==coord_serpent[i+1]:
                    x=randrange(10,480,10)
                    y=randrange(10,280,10)
                i=0
                i2=0
            if i2==1:
                i+=4
        f=can1.create_oval(x,y,x+10,y+10,fill="#AEEE00")
        tex1 = Label(fen1, text=score, fg='#FF358B').grid(row=8,column=1,sticky=N)
        eat=0
 
 
# Ces fonction vont permettrent de contrôler le serpent
# à l'aide des touches fléchées du clavier
 
def left(event):
    global dx,dy,direction,coord_serpent,coord_yeux,yeux
    if direction!=2:
        dx=-10
        dy=0
        direction=1
 
 
 
def right(event):
    global dx,dy,direction
    if direction!=1:
        dx=10
        dy=0
        direction=2
 
 
 
def up(event):
    global dx,dy,direction
    if direction!=4:
        dx=0
        dy=-10
        direction=3
 
 
def down(event):
    global dx,dy,direction
    if direction!=3:
        dx=0
        dy=10
        direction=4
 
 
# Programme principal
 
# Définition du canevas (espace de jeu)
 
fen1=Tk()
fen1.title("SNAKE")
can1=Canvas(fen1,width=500,height=300,bg="#5D5D5D")
 
# Définition des touches qui permettront de déplacer le serpent
 
can1.bind_all("<Left>",left)
can1.bind_all("<Right>",right)
can1.bind_all("<Up>",up)
can1.bind_all("<Down>",down)
can1.bind_all("<p>",pause)
 
can1.grid(row=0,column=0,rowspan=10)
 
# Affichage du Label 'Score : '
 
tex2 = Label(fen1, text='Score : ', fg='#FF358B').grid(row=7,column=1)
 
# On crée le bouton New game qui va permettre de réinitialiser la partie
 
Button(fen1,text="New game",font=("Fixedsys"),command=new_game).grid(row=4,column=1,sticky=N,padx=5)
Button(fen1,text="Quit",font=("Fixedsys"),command=fen1.destroy).grid(row=5,column=1,sticky=N)
 
# Délimitations des limites (Création des murs)
# que le serpent ne doit outre passer pour ne pas finir dans le mur XD !!
 
can1.create_rectangle(0,0,10,300,fill="black")
can1.create_rectangle(0,0,500,10,fill="black")
can1.create_rectangle(490,0,500,300,fill="black")
can1.create_rectangle(0,300,500,290,fill="black")
 
# Liste des coordonnées du serpent
 
coord_serpent=[50,50,60,60]
 
# Yeux du serpent
 
coord_yeux=[coord_serpent[0]+6,coord_serpent[1]+2,coord_serpent[2]-2,coord_serpent[3]-6,coord_serpent[0]+6,coord_serpent[1]+6,coord_serpent[2]-2,coord_serpent[3]-2]
 
# Définition des coordonnées de départ du serpent
 
serpent=[can1.create_rectangle(coord_serpent[0],coord_serpent[1],coord_serpent[2],coord_serpent[3],fill="#01B0F0")]
 
# On lui dessine ses jolies yeux :)
 
yeux=[can1.create_oval(coord_yeux[0],coord_yeux[1],coord_yeux[2],coord_yeux[3],fill="black")]
yeux.append(can1.create_oval(coord_yeux[4],coord_yeux[5],coord_yeux[6],coord_yeux[7],fill="black"))
 
# Définition du drapeau ( indicateur permettant d'arrêter le programme )
 
flag=1
eat=0
 
# On dessine le 1er tas de nourriture
 
x=randrange(10,480,10)
y=randrange(10,280,10)
f=can1.create_oval(x,y,x+10,y+10,fill="#AEEE00")
 
# Définition des pas d'avancement du serpent
 
dx=10
dy=0
 
# Etant donné que le serpent avance vers la droite
# on assigne 2 à direction qui correspond à la
# fonction right() afin que rien ne soit chamboulé
 
direction=2
 
# Le compteur de score
 
score=0
pause=0
 
# Ce compteur va permettre de ne pas remettre
# le jeu en route à l'aide de la touche pause
# dans le cas où le joueur aurait perdu :p
 
flag2=0
 
move()
 
fen1.mainloop()

J'aimerais que à chaque fois que le serpent touche le mur ou qu'il se touche soit même, le programme demande à l'utilisateur d'entrer son nom pour l'enregistrer dans un fichier texte. Dans le fichier texte, chaque ligne correspondra à une entrée d'un joueur et sera inscrit ainsi : Joueur # Score.

Ensuite je voudrais retrouver les 10 meilleurs scores du fichier et les afficher à l'aide d'un bouton score.

Merci

**wiztricks** · 04/06/2012, 19h16

Salut,

Vous avez déjà réalisé la fonction:

Code :

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

1
2
3
4
def update_score_file(name_var, score):
 
    with open('score.txt', 'a') as score_file:
        score_file.write(name_var.get() + '#' + str(score) + '\n')

Pour relire, le fichier vous pourriez écrire une fonction scores_top10 qui retourne les dix meilleurs scores sous la forme d'une liste d'items de la forme (name, score):

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
# version pépère
def scores_top10():
     items = []
     with open('scores.txt', 'r') as f:
         for line in f.readlines():
              n, s = line.split('#')
              items.append( (n, int(s)) )
     items = sorted(items, key= lambda s: s[1], reverse=True)
     return items[:10]
 
# un peu plus speed:
def scores_top10():
    with open('scores.txt', 'r') as f:
        lines = (line.split('#') for line in f.readlines())
        items = ( (n, int(s)) for n, s in lines )
    return sorted(items, key= lambda s: s[1], reverse=True)[:10]

- W

**tonykart13** · 10/06/2012, 21h55

Merci beaucoup.

Le projet est à rendre demain et il ne me reste plus qu'à afficher les scores..

Quelqu'un pourrait m'aider en me disant comme afficher les scores qui sont retournés par la fonction suivante :

Code :

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

1
2
3
4
5
6
7
8
def scores_top10():
     items = []
     with open('scores.txt', 'r') as f:
         for line in f.readlines():
              n, s = line.split('#')
              items.append( (n, int(s)) )
     items = sorted(items, key= lambda s: s[1], reverse=True)
     return items[:10]

Un très grand merci à tous ceux qui m'ont aidés, et aussi merci pour les Cours et tutoriels pour apprendre Python , comme celui la surtout : Apprendre à programmer avec Python 3 par Gérard Swinnen !!

Snake avec Python 3.0 et Tkinter

Tkinter Python

Discussions similaires

Partager

Partager