Jeu de labyrinthe - Animation d'une balle.

**FatP0ney** · 22/05/2014, 20h25

Bien sur !

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
 
# -*- coding: utf-8 -*-
"""
Created on Tue May 20 13:35:38 2014
 
@author: BOUCHEP
"""
 
from Tkinter import *
 
 
 
def animation_de_depart():
    global X, Y
    if X <= x2 and Y <= y2:
        X += sx * dep      
        Y += sy * dep       
        can1.move(cerc1, sx * dep, sy * dep) 
        can1.after(100, animation_de_depart)
    else:
        move()
 
def move():
    global carre_balle,fin1 ,fin2 ,fin3
 
    fin1 = fin2 = fin3 = 0
 
    carre_balle = can1.bbox(cerc1)
 
    intersection = can1.find_overlapping(carre_balle[0],carre_balle[1],carre_balle[2],carre_balle[3]) 
    # la balle se retrouve-t-elle seule ?
 
    if len(intersection) >1:
        if fin1 in intersection:
                bravo()
                can1.after(800, passer_de_niveau)
 
        elif fin2 in intersection:
                bravo()
                can1.after(800, passer_de_niveau2)
 
        elif fin3 in intersection:
                super_bravo()
 
        else:
            game_over()
 
 
    else:
        can1.move(cerc1, sx*dep, sy*dep)
        can1.after(100, move)
 
 
def bravo():    
    global Widget_Bouton
    left = can1.winfo_reqwidth() // 2    
    top = can1.winfo_reqheight() // 2    
    can1.create_text(
        left, top - 40,
        text="Bravo!",
        font="sans 24 bold",
        fill="gold",
    )
 
def super_bravo():
    global Widget_Bouton
    left = can1.winfo_reqwidth() // 2    
    top = can1.winfo_reqheight() // 2    
    can1.create_text(
        left, top - 40,
        text="BIEN JOUE !",
        font="sans 60 bold",
        fill="gold",
    )
 
 
def game_over():
    global bouton,item
 
   # la partie est finie !
    left = can1.winfo_reqwidth() // 2
    top = can1.winfo_reqheight() // 2
    can1.create_text(
        left, top - 40,
        text="GAME OVER!",
        font="sans 24 bold",
        fill="gold",
    )
 
    bouton=Button(fen1, text='Relancer', command=replay)
    can1.create_window(240,180,window=bouton)
 
 
 
 
 
def replay():    
    global X ,Y,cerc1 ,fin1
 
    can1.delete(ALL)
 
    can1.create_rectangle(50,50,100,100) #dessine un rectangle
    fin1 = can1.create_rectangle(120, 280, 170, 335)   
    can1.create_line(100, 65, 160, 65, fill='medium sea green', width=4) # ligne 1
    can1.create_line(100, 85, 140, 85, fill='medium sea green', width=4) # ligne 2
    can1.create_line(140, 85, 140, 280, fill='medium sea green', width=4) # ligne 3
    can1.create_line(160, 65, 160, 280, fill='medium sea green', width=4) # ligne 4
 
    X = (x1 + x2 - diametre) / 2
    Y = (y1 + y2 - diametre) / 2
 
    cerc1 = can1.create_oval(X, Y, X + diametre, Y + diametre, fill='grey')
 
 
def passer_de_niveau():  
 
    "parcours numéro 2"
 
    can1.delete(ALL)
    parcours2()
 
def passer_de_niveau2():  
 
    "parcours numéro 3"
 
    can1.delete(ALL)
    parcours3()
 
 
 
def dep1_gauche(event=None):
    global sx, sy
    sx = -1
    sy = 0
 
def dep1_droite(event=None):
    global sx, sy
    sx = 1
    sy = 0
 
def dep1_haut(event=None):
    global sy, sx
    sy = -1
    sx = 0
 
def dep1_bas(event=None):
    global sy, sx
    sy = 1
    sx = 0
 
def start_it():
 
    animation_de_depart()
 
 
 
# les variables suivantes seront utilisees de maniere globale:
 
dep = 5         # valeur de deplacement
sx, sy = 1, 0   # sens de deplacement
 
 
# carre de depart
x1, y1 = 50, 50
x2, y2 = 100, 100
 
# diametre balle
diametre = 5
 
# coordonnees initiales de la balle
X = (x1 + x2 - diametre) / 2
Y = (y1 + y2 - diametre) / 2
 
# Creation du widget principal ("maitre"):
fen1 = Tk()
fen1.title("Super Ball")
 
# creation des widgets "esclaves":
can1 = Canvas(fen1, bg='white', height=500, width=500)
can1.pack(side=LEFT)
 
# dessin parcours no. 1
can1.create_rectangle(x1, y1, x2, y2) # dessine le rectangle de départ
fin1 = can1.create_rectangle(120, 280, 170, 335) # dessine le rectangle d'arrivé
polygone1 = [100, 65, 420, 65], [100, 85, 400, 85]
#can1.create_line(*polygone1[0], fill='red', width=4) # ligne 1
#can1.create_line(*polygone1[1], fill='red', width=4) # ligne 2
can1.create_line(100, 65, 160, 65, fill='medium sea green', width=4) # ligne 1
can1.create_line(100, 85, 140, 85, fill='medium sea green', width=4) # ligne 2
can1.create_line(140, 85, 140, 280, fill='medium sea green', width=4) # ligne 3
can1.create_line(160, 65, 160, 280, fill='medium sea green', width=4) # ligne 4
 
fin1 = fin2 = fin3 = 0
 
 
 
def parcours2():
    global X,Y ,cerc1 ,fin2 ,polygone1, sx, sy
 
 
    # on remet les valeurs de départ
    sx, sy = 1, 0
 
 
    # dessin parcours no. 1
    can1.create_rectangle(x1, y1, x2, y2) # dessine le rectangle de départ
    fin2 = can1.create_rectangle(120, 280, 170, 335) # dessine le rectangle d'arrivé
    polygone1 = [100, 65, 420, 65], [100, 85, 400, 85]
    #can1.create_line(*polygone1[0], fill='red', width=4) # ligne 1
    #can1.create_line(*polygone1[1], fill='red', width=4) # ligne 2
    can1.create_line(100, 65, 420, 65, fill='red', width=4) # ligne 3
    can1.create_line(100, 85, 400, 85, fill='red', width=4) # ligne 3
    can1.create_line(400, 85, 400, 300, fill='red', width=4) # ligne 3
    can1.create_line(420, 65, 420, 320, fill='red', width=4) # ligne 4
    can1.create_line(170, 320, 420, 320, fill='red', width=4) # ligne 5
    can1.create_line(170, 300, 400, 300, fill='red', width=4) # ligne 6
 
    X = (x1 + x2 - diametre) / 2
    Y = (y1 + y2 - diametre) / 2
 
    cerc1 = can1.create_oval(X, Y, X + diametre, Y + diametre, fill='grey')
 
 
 
 
def parcours3():
    global X, Y, cerc1, fin3, sx, sy
 
 
    sx, sy = 1, 0
 
 
 
    can1.create_rectangle(50,50,100,100) #dessine un rectangle
    fin3=can1.create_rectangle(370,370,420,420)
 
    #trace du nouveau parcours :
    polygone1 = [100,65,420,65], [100,85,400,85]    
    can1.create_line(tuple(polygone1[0]),fill='orange',width=4)#ligne 1
    can1.create_line(tuple(polygone1[1]),fill='orange',width=4)#ligne 2
    can1.create_line(400,85,400,130,fill='orange',width=4)#ligne 3
    can1.create_line(420,65,420,150,fill='orange',width=4)#ligne 4
    can1.create_line(170,150,420,150,fill='orange',width=4)#ligne 5
    can1.create_line(150,130,400,130,fill='orange',width=4)#ligne 6
    can1.create_line(150,130,150,190,fill='orange',width=4)#ligne 7
    can1.create_line(170,150,170,220,fill='orange',width=4)#ligne 8
    can1.create_line(60,220,170,220,fill='orange',width=4)#ligne 9
    can1.create_line(30,190,150,190,fill='orange',width=4)#ligne 10
    can1.create_line(30,190,30,480,fill='orange',width=4)#ligne 11
    can1.create_line(60,220,60,450,fill='orange',width=4)#ligne 12
    can1.create_line(60,450,250,450,fill='orange',width=4)#ligne 13
    can1.create_line(30,480,270,480,fill='orange',width=4)#ligne 14
    can1.create_line(270,480,270,330,fill='orange',width=4)#ligne 15
    can1.create_line(250,450,250,310,fill='orange',width=4)#ligne 16
    can1.create_line(270,330,380,330,fill='orange',width=4)#ligne 17
    can1.create_line(250,310,400,310,fill='orange',width=4)#ligne 18
    can1.create_line(400,310,400,370,fill='orange',width=4)#ligne 19
    can1.create_line(380,330,380,370,fill='orange',width=4)#ligne 20
 
    X = (x1 + x2 - diametre) / 2
    Y = (y1 + y2 - diametre) / 2
 
    cerc1 = can1.create_oval(X, Y, X + diametre, Y + diametre, fill='grey')
 
 
# dessin balle
cerc1 = can1.create_oval(X, Y, X + diametre, Y + diametre, fill='green')
 
# balle au premier plan d'affichage
can1.tag_raise(cerc1, ALL)
can1.update()
 
# boutons à cliquer
 
 
Button(fen1, text='Démarrer', bg='white',bd=8, relief="ridge", command=start_it).pack(side=BOTTOM)
Button(fen1, text='Quitter', bg='cyan',bd=8, relief="ridge", command=fen1.destroy).pack(side=BOTTOM)
Button(fen1, text='Gauche', bg='gold',bd=8, relief="ridge", command=dep1_gauche).pack()
Button(fen1, text='Droite', bg='green',bd=8, relief="ridge", command=dep1_droite).pack()
Button(fen1, text='Haut', bg='white',bd=8, relief="ridge", command=dep1_haut).pack()
Button(fen1, text='Bas', bg='cyan',bd=8, relief="ridge", command=dep1_bas).pack()
Button(fen1, text='Accélère!', bg='gold',bd=8, relief="ridge", command=start_it).pack(side=BOTTOM)
 
 
# touches du clavier
can1.bind_all("<z>", dep1_haut)
can1.bind_all("<s>", dep1_bas)
can1.bind_all("<d>", dep1_droite)
can1.bind_all("<q>", dep1_gauche)
 
# flèches du clavier
can1.bind_all("<Up>", dep1_haut)
can1.bind_all("<Down>", dep1_bas)
can1.bind_all("<Left>", dep1_gauche)
can1.bind_all("<Right>", dep1_droite)
 
 
# démarrage du gestionnaire d'événements (boucle principale):
fen1.mainloop()

Invité · 22/05/2014, 20h38

Envoyé par FatP0ney

Bien sur !

Bon voilà, je vous ai remis le code sur pied, mais il faudra quand même le dégrossir et mieux réfléchir à la répartition des tâches et des fonctions, sans quoi vous allez multiplier le code inutilement et vous embourber dans un marécage glauque.

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
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
"""
    Created on Tue May 20 13:35:38 2014
 
    @author: BOUCHEP
"""
 
from Tkinter import *
 
def animation_de_depart(sx, sy, dep):
    global X, Y
    if X <= x2 and Y <= y2:
        X += sx * dep
        Y += sy * dep
        can1.move(cerc1, sx * dep, sy * dep)
        can1.after(100, animation_de_depart, sx, sy, dep)
    else:
        move()
 
def move():
    global carre_balle
 
    carre_balle = can1.bbox(cerc1)
 
    intersection = can1.find_overlapping(carre_balle[0],carre_balle[1],carre_balle[2],carre_balle[3])
    # la balle se retrouve-t-elle seule ?
 
    if len(intersection) >1:
        if fin1 in intersection:
                bravo()
                can1.after(800, passer_de_niveau)
 
        elif fin2 in intersection:
                bravo()
                can1.after(800, passer_de_niveau2)
 
        elif fin3 in intersection:
                super_bravo()
 
        else:
            game_over()
 
 
    else:
        can1.move(cerc1, sx*dep, sy*dep)
        can1.after(100, move)
 
 
def bravo():
    global Widget_Bouton
    left = can1.winfo_reqwidth() // 2
    top = can1.winfo_reqheight() // 2
    can1.create_text(
        left, top - 40,
        text="Bravo!",
        font="sans 24 bold",
        fill="gold",
    )
 
def super_bravo():
    global Widget_Bouton
    left = can1.winfo_reqwidth() // 2
    top = can1.winfo_reqheight() // 2
    can1.create_text(
        left, top - 40,
        text="BIEN JOUE !",
        font="sans 60 bold",
        fill="gold",
    )
 
 
def game_over():
    global bouton,item
 
   # la partie est finie !
    left = can1.winfo_reqwidth() // 2
    top = can1.winfo_reqheight() // 2
    can1.create_text(
        left, top - 40,
        text="GAME OVER!",
        font="sans 24 bold",
        fill="gold",
    )
 
    bouton=Button(fen1, text='Relancer', command=replay)
    can1.create_window(240,180,window=bouton)
 
 
 
 
 
def replay():
    global X ,Y,cerc1 ,fin1, sx, sy
 
    # on remet les valeurs de départ
    sx, sy = 1, 0
 
    can1.delete(ALL)
 
    can1.create_rectangle(50,50,100,100) #dessine un rectangle
    fin1 = can1.create_rectangle(120, 280, 170, 335)
    can1.create_line(100, 65, 160, 65, fill='medium sea green', width=4) # ligne 1
    can1.create_line(100, 85, 140, 85, fill='medium sea green', width=4) # ligne 2
    can1.create_line(140, 85, 140, 280, fill='medium sea green', width=4) # ligne 3
    can1.create_line(160, 65, 160, 280, fill='medium sea green', width=4) # ligne 4
 
    X = (x1 + x2 - diametre) / 2
    Y = (y1 + y2 - diametre) / 2
 
    cerc1 = can1.create_oval(X, Y, X + diametre, Y + diametre, fill='grey')
 
 
def passer_de_niveau():
 
    "parcours numéro 2"
 
    can1.delete(ALL)
    parcours2()
 
def passer_de_niveau2():
 
    "parcours numéro 3"
 
    can1.delete(ALL)
    parcours3()
 
 
 
def dep1_gauche(event=None):
    global sx, sy
    sx = -1
    sy = 0
 
def dep1_droite(event=None):
    global sx, sy
    sx = 1
    sy = 0
 
def dep1_haut(event=None):
    global sy, sx
    sy = -1
    sx = 0
 
def dep1_bas(event=None):
    global sy, sx
    sy = 1
    sx = 0
 
def start_it():
 
    global sx, sy
 
    # on remet les valeurs de départ
    sx, sy = 1, 0
 
    animation_de_depart(sx, sy, dep)
 
 
 
# les variables suivantes seront utilisees de maniere globale:
 
dep = 5         # valeur de deplacement
sx, sy = 1, 0   # sens de deplacement
 
 
# carre de depart
x1, y1 = 50, 50
x2, y2 = 100, 100
 
# diametre balle
diametre = 5
 
# coordonnees initiales de la balle
X = (x1 + x2 - diametre) / 2
Y = (y1 + y2 - diametre) / 2
 
 
# c'est ici les initialisations du script
fin1 = fin2 = fin3 = 0
 
 
# Creation du widget principal ("maitre"):
fen1 = Tk()
fen1.title("Super Ball")
 
# creation des widgets "esclaves":
can1 = Canvas(fen1, bg='white', height=500, width=500)
can1.pack(side=LEFT)
 
# dessin parcours no. 1
can1.create_rectangle(x1, y1, x2, y2) # dessine le rectangle de départ
fin1 = can1.create_rectangle(120, 280, 170, 335) # dessine le rectangle d'arrivé
polygone1 = [100, 65, 420, 65], [100, 85, 400, 85]
#can1.create_line(*polygone1[0], fill='red', width=4) # ligne 1
#can1.create_line(*polygone1[1], fill='red', width=4) # ligne 2
can1.create_line(100, 65, 160, 65, fill='medium sea green', width=4) # ligne 1
can1.create_line(100, 85, 140, 85, fill='medium sea green', width=4) # ligne 2
can1.create_line(140, 85, 140, 280, fill='medium sea green', width=4) # ligne 3
can1.create_line(160, 65, 160, 280, fill='medium sea green', width=4) # ligne 4
 
fin1 = fin2 = fin3 = 0
 
 
 
def parcours2():
    global X,Y ,cerc1 ,fin2 ,polygone1, sx, sy
 
    # on remet les valeurs de départ
    sx, sy = 1, 0
 
    # dessin parcours no. 1
    can1.create_rectangle(x1, y1, x2, y2) # dessine le rectangle de départ
    fin2 = can1.create_rectangle(120, 280, 170, 335) # dessine le rectangle d'arrivé
    polygone1 = [100, 65, 420, 65], [100, 85, 400, 85]
    #can1.create_line(*polygone1[0], fill='red', width=4) # ligne 1
    #can1.create_line(*polygone1[1], fill='red', width=4) # ligne 2
    can1.create_line(100, 65, 420, 65, fill='red', width=4) # ligne 3
    can1.create_line(100, 85, 400, 85, fill='red', width=4) # ligne 3
    can1.create_line(400, 85, 400, 300, fill='red', width=4) # ligne 3
    can1.create_line(420, 65, 420, 320, fill='red', width=4) # ligne 4
    can1.create_line(170, 320, 420, 320, fill='red', width=4) # ligne 5
    can1.create_line(170, 300, 400, 300, fill='red', width=4) # ligne 6
 
    X = (x1 + x2 - diametre) / 2
    Y = (y1 + y2 - diametre) / 2
 
    cerc1 = can1.create_oval(X, Y, X + diametre, Y + diametre, fill='grey')
 
 
 
 
def parcours3():
    global X, Y, cerc1, fin3, sx, sy
 
    sx, sy = 1, 0
 
    can1.create_rectangle(50,50,100,100) #dessine un rectangle
    fin3=can1.create_rectangle(370,370,420,420)
 
    #trace du nouveau parcours :
    polygone1 = [100,65,420,65], [100,85,400,85]
    can1.create_line(tuple(polygone1[0]),fill='orange',width=4)#ligne 1
    can1.create_line(tuple(polygone1[1]),fill='orange',width=4)#ligne 2
    can1.create_line(400,85,400,130,fill='orange',width=4)#ligne 3
    can1.create_line(420,65,420,150,fill='orange',width=4)#ligne 4
    can1.create_line(170,150,420,150,fill='orange',width=4)#ligne 5
    can1.create_line(150,130,400,130,fill='orange',width=4)#ligne 6
    can1.create_line(150,130,150,190,fill='orange',width=4)#ligne 7
    can1.create_line(170,150,170,220,fill='orange',width=4)#ligne 8
    can1.create_line(60,220,170,220,fill='orange',width=4)#ligne 9
    can1.create_line(30,190,150,190,fill='orange',width=4)#ligne 10
    can1.create_line(30,190,30,480,fill='orange',width=4)#ligne 11
    can1.create_line(60,220,60,450,fill='orange',width=4)#ligne 12
    can1.create_line(60,450,250,450,fill='orange',width=4)#ligne 13
    can1.create_line(30,480,270,480,fill='orange',width=4)#ligne 14
    can1.create_line(270,480,270,330,fill='orange',width=4)#ligne 15
    can1.create_line(250,450,250,310,fill='orange',width=4)#ligne 16
    can1.create_line(270,330,380,330,fill='orange',width=4)#ligne 17
    can1.create_line(250,310,400,310,fill='orange',width=4)#ligne 18
    can1.create_line(400,310,400,370,fill='orange',width=4)#ligne 19
    can1.create_line(380,330,380,370,fill='orange',width=4)#ligne 20
 
    X = (x1 + x2 - diametre) / 2
    Y = (y1 + y2 - diametre) / 2
 
    cerc1 = can1.create_oval(X, Y, X + diametre, Y + diametre, fill='grey')
 
 
# dessin balle
cerc1 = can1.create_oval(X, Y, X + diametre, Y + diametre, fill='green')
 
# balle au premier plan d'affichage
can1.tag_raise(cerc1, ALL)
can1.update()
 
# boutons à cliquer
 
 
Button(fen1, text='Démarrer', bg='white',bd=8, relief="ridge", command=start_it).pack(side=BOTTOM)
Button(fen1, text='Quitter', bg='cyan',bd=8, relief="ridge", command=fen1.destroy).pack(side=BOTTOM)
Button(fen1, text='Gauche', bg='gold',bd=8, relief="ridge", command=dep1_gauche).pack()
Button(fen1, text='Droite', bg='green',bd=8, relief="ridge", command=dep1_droite).pack()
Button(fen1, text='Haut', bg='white',bd=8, relief="ridge", command=dep1_haut).pack()
Button(fen1, text='Bas', bg='cyan',bd=8, relief="ridge", command=dep1_bas).pack()
Button(fen1, text='Accélère!', bg='gold',bd=8, relief="ridge", command=start_it).pack(side=BOTTOM)
 
 
# touches du clavier
can1.bind_all("<z>", dep1_haut)
can1.bind_all("<s>", dep1_bas)
can1.bind_all("<d>", dep1_droite)
can1.bind_all("<q>", dep1_gauche)
 
# flèches du clavier
can1.bind_all("<Up>", dep1_haut)
can1.bind_all("<Down>", dep1_bas)
can1.bind_all("<Left>", dep1_gauche)
can1.bind_all("<Right>", dep1_droite)
 
 
# démarrage du gestionnaire d'événements (boucle principale):
fen1.mainloop()

PS: après les épreuves du bac, je publierais ici une version perso de votre jeu, en essayant de garder le style d'origine du script.

**FatP0ney** · 22/05/2014, 20h51

Bon voilà, je vous ai remis le code sur pied, mais il faudra quand même le dégrossir et mieux réfléchir à la répartition des tâches et des fonctions, sans quoi vous allez multiplier le code inutilement et vous embourber dans un marécage glauque.

C'est super merci beaucoup! En fait si j'ai bien compris ce que vous avez fait, vous avez comme vous m'aviez demandé de le faire, remplacé certains éléments de manière à ce que l'on ne puisse plus modifier le déplacement de la balle au début !

Serait il possible de m'expliquer en quoi cela change le déplacement de rajouter ces éléments? Par ce que même si j'observe le résultat j'ai un peu du mal à comprendre d'ou il vient

PS: après les épreuves du bac, je publierais ici une version perso de votre jeu, en essayant de garder le style d'origine du script.

Je pense que j'aurais moi aussi un peu de temps après le bac pour rajouter deux trois options marrantes à ce projet

! Même si je suis à l'informatique ce que Chantal Goya est à la musique francaise je me suis vraiment bien amusé en réalisant ce petit jeu avec votre aide, j'essaierais surement de recommencer peut être sur une autre idée! Je suis impatient de voir à quoi votre jeu va avoir l'air

@ + et merci pour tout!!

Ps : je me met au nettoyage dès maintenant et si ça ne vous dérange pas je pense que je vous publierai le résultat final pour que vous me disiez ce que je pourrais améliorer

Invité · 22/05/2014, 21h19

Envoyé par FatP0ney

Serait il possible de m'expliquer en quoi cela change le déplacement de rajouter ces éléments? Par ce que même si j'observe le résultat j'ai un peu du mal à comprendre d'ou il vient

Le "truc" (si on peut dire), c'est de figer les variables globales sx, sy et dep en les passant en paramètres de fonction :

Code :

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

1
2
3
4
5
6
def start_it():
    global sx, sy
    # on remet les valeurs de départ
    sx, sy = 1, 0
 
    animation_de_depart(sx, sy, dep) # <-- on passe les variables globales sx, sy et dep en paramètres à la fonction animation_de_depart()

ensuite, il nous suffit de définir la fonction animation_de_depart() avec les arguments sx, sy et dep et dès lors ce ne seront plus les variables globales sx, sy, dep qui seront utilisées dans la fonction mais les paramètres sx, sy et dep.

Code :

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

1
2
3
4
5
6
7
8
9
def animation_de_depart(sx, sy, dep):
    global X, Y
    if X <= x2 and Y <= y2:
        X += sx * dep
        Y += sy * dep
        can1.move(cerc1, sx * dep, sy * dep)
        can1.after(100, animation_de_depart, sx, sy, dep) # on relance la fonction avec ses paramètres et non pas les variables globales
    else:
        move()

c'est une facilité de notation qui peut porter à confusion, surtout quand on débute.

si vous préférez bien distinguer les paramètres des variables globales, vous pouvez noter la définition comme suit :

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
def animation_de_depart(sensX, sensY, deplacement):
    """en changeant le nom des arguments de fonction, vous distinguez mieux un paramètre d'une variable globale"""
    global X, Y
    if X <= x2 and Y <= y2:
        X += sensX * deplacement # ici ce sont les paramètres qui jouent
        Y += sensY * deplacement # et non pas les globales
        can1.move(cerc1, sensX * deplacement, sensY * deplacement) # idem
        can1.after(100, animation_de_depart, sensX, sensY, deplacement) # on relance la fonction avec ses paramètres et non pas les variables globales
    else:
        move()
 
# et toujours :
 
def start_it():
    global sx, sy
    # on remet les valeurs de départ
    sx, sy = 1, 0
 
    # on ne change rien ici, puisqu'on initialise la fonction avec les valeurs des globales sx, sy et dep
 
    animation_de_depart(sx, sy, dep) # <-- on passe les variables globales sx, sy et dep en paramètres à la fonction animation_de_depart()

cette technique permet de figer des valeurs - y compris des globales - le temps d'une animation, afin que le joueur ne vienne pas interférer avec le bon déroulement de la fonction animation_de_depart().

en fait, les globales peuvent bien changer durant l'exécution de animation_de_depart() cela n'aura plus d'impact sur la fonction une fois qu'elle sera lancée.

Ps : je me met au nettoyage dès maintenant et si ça ne vous dérange pas je pense que je vous publierai le résultat final pour que vous me disiez ce que je pourrais améliorer

Ca marche. Bon courage !

@+.

Invité · 18/06/2014, 08h43

Envoyé par tarball69

PS: après les épreuves du bac, je publierais ici une version perso de votre jeu, en essayant de garder le style d'origine du script.

Bonjour,

Etant donné que je pars en vacances dès demain, je publie comme promis la version "post-Bac" de votre jeu :

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
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
"""
    this is a Python2 script;
 
    created on Tue May 06 13:32:10 2014 by fatponey et al.
 
    powered up by tarball69;
 
    caution: this software uses MS-Windows specifics (winsound);
 
    please, comment 'import winsound' and 'winsound.PlaySound()' in
    jouer_son() function to get a linux/UNIX compatible script;
"""
 
# lib imports
 
#~ import winsound
 
from Tkinter import *
 
 
def init_jeu ():
    """
        c'est ici que tout commence - point de départ
    """
 
    # on déclare uniquement
    # les variables globales que l'on modifie
    global fenetre, canvas
 
    # création de la fenêtre principale
    fenetre = Tk()
    fenetre.title("Super Ball")
    fenetre.resizable(width=False, height=False)
 
    # canevas graphique
    canvas = Canvas(fenetre, bg="alice blue", height=500, width=500)
    canvas.pack()
 
    # info
    Label(
 
        fenetre,
 
        text="Info : utilisez les flèches du clavier "
        "pour orienter la balle"
 
    ).pack(side=LEFT, padx=10, pady=5)
 
    # bouton 'quitter'
    Button(
 
        fenetre, text="Quitter", command=fenetre.destroy
 
    ).pack(side=RIGHT, padx=5, pady=5)
 
    # initialisation du premier niveau
    init_premier_niveau()
 
    # on déclare toujours les événements en dernier
 
    # flèches du clavier
    canvas.bind_all("<Up>", deplacer_haut)
    canvas.bind_all("<Down>", deplacer_bas)
    canvas.bind_all("<Left>", deplacer_gauche)
    canvas.bind_all("<Right>", deplacer_droite)
 
    # démarrage du gestionnaire d'événements (boucle principale)
    fenetre.mainloop()
 
# end def
 
 
def init_premier_niveau ():
    """
        initialisation du tout premier niveau de jeu
    """
 
    # on déclare uniquement
    # les variables globales que l'on modifie
    global niveau
 
    # init premier parcours
    niveau = 1
 
    # on affiche le parcours pour faire joli
    tracer_parcours(niveau)
 
    # bouton 'démarrer' dans le canevas
    canvas.create_window(
 
        xy_centre(canvas),
 
        window=Button(canvas, text="Démarrer", command=demarrer_partie)
    )
 
# end def
 
 
def xy_centre (widget):
    """
        calcul du point central d'un widget
    """
    return (widget.winfo_reqwidth() / 2, widget.winfo_reqheight() / 2)
 
# end def
 
 
def demarrer_partie():
    """
        démarrage d'une partie
    """
 
    # on dessine le parcours actuel
    tracer_parcours(niveau)
 
    # on lance une animation de départ
    # mais on ne veut pas que le joueur
    # puisse modifier la trajectoire de la balle
    # durant cette animation;
    # c'est pourquoi on "fige" sx, sy et dep
    # en paramètres d'initialisation :
 
    animation_de_depart(sx, sy, dep)
 
# end def
 
 
def tracer_parcours (numero):
    """
        initialisations et tracé d'un parcours pré-stocké
    """
 
    # on déclare uniquement
    # les variables globales que l'on modifie
    global sx, sy, dep, id_carre_final
 
    # initialisation du parcours sélectionné
    parcours = init_parcours(numero)
 
    # extraction de données du parcours sélectionné
 
    sx = parcours["sx"]     # sens de déplacement
    sy = parcours["sy"]     # sens de déplacement
    dep = parcours["dep"]   # quantité de déplacement (step)
 
    diametre_balle = parcours["diametre_balle"]
    carre_depart = parcours["carre_depart"]
    carre_final = parcours["carre_final"]
    couleur = parcours["couleur"]           # couleur des murs
 
    # dessin parcours
 
    # on efface d'abord tout le canevas
    canvas.delete(ALL)
 
    # init options des carrés
    options = dict(fill="lemon chiffon", outline=couleur, width=3)
 
    # dessin du carré de départ
    canvas.create_rectangle(carre_depart, **options)
 
    # dessin du carré final (arrivée)
    id_carre_final = canvas.create_rectangle(carre_final, **options)
 
    # init options des murs
    options = dict(fill=couleur, width=3)
 
    # init murs du parcours
    canvas.create_line(parcours["mur1"], **options)
    canvas.create_line(parcours["mur2"], **options)
 
    # on place une balle d'un certain diamètre
    # au centre du carré de départ
    init_balle(diametre_balle, carre_depart)
 
# end def
 
 
def init_parcours (numero):
    """
        c'est ici que sont stockés tous les parcours
        le paramètre @numero commence à 1
    """
 
    # on déclare uniquement
    # les variables globales que l'on modifie
    global max_parcours
 
    # parcours pré-stockés
    parcours = (
 
        # parcours no. 1
        dict(
 
            # déplacements
            sx=1, sy=0, dep=5,
 
            # diamètre balle
            diametre_balle = 10,
 
            # carré de départ
            carre_depart = (120, 100, 170, 150),
 
            # carré final (arrivée)
            carre_final = (230, 350, 280, 400),
 
            # tracé mur1
            mur1 = (170, 110, 270, 110, 270, 350),
 
            # tracé mur2
            mur2 = (170, 140, 240, 140, 240, 350),
 
            # couleur du tracé des murs
            couleur = "dark sea green",
 
        ), # fin parcours no. 1
 
        # parcours no. 2
        dict(
 
            # déplacements
            sx=1, sy=0, dep=5,
 
            # diamètre balle
            diametre_balle = 10,
 
            # carré de départ
            carre_depart = (50, 50, 100, 100),
 
            # carré final (arrivée)
            carre_final = (370, 370, 420, 420),
 
            # tracé mur1
            mur1 = (
                100,60, 430,60, 430,160, 180,160, 180,220, 60,220,
                60,450, 240,450, 240,300, 410,300, 410,370,
            ),
 
            # tracé mur2
            mur2 = (
                100,90, 400,90, 400,130, 150,130, 150,190, 30,190,
                30,480, 270,480, 270,330, 380,330, 380,370,
            ),
 
            # couleur du tracé des murs
            couleur = "orange",
 
        ), # fin parcours no. 2
 
    ) # fin parcours
 
    # calcul nb total de parcours
    max_parcours = len(parcours)
 
    # extraction du parcours demandé
    return parcours[numero - 1]
 
# end def
 
 
def init_balle (diametre, carre):
    """
        initialisations et tracé de la balle au centre d'un carré
    """
 
    # on déclare uniquement
    # les variables globales que l'on modifie
    global x1, y1, x2, y2
    global X, Y, id_balle
 
    # init coordonnées du carré
    x1, y1, x2, y2 = carre
 
    # calcul du point central
    # réajusté au coin supérieur gauche
    # pour des raisons de contraintes de tracé
    X = (x1 + x2 - diametre) / 2
    Y = (y1 + y2 - diametre) / 2
 
    # dessin de la balle
    id_balle = canvas.create_oval(
 
        X, Y, X + diametre, Y + diametre,
 
        fill="red", width=1,
    )
 
    # on passe la balle au premier plan d'affichage
    canvas.tag_raise(id_balle, ALL)
 
    # réajustement des coordonnées du carré
    # pour faciliter les tests dans animation_de_depart()
    x1 -= diametre + 2
    y1 -= diametre + 2
    x2 += 2
    y2 += 2
 
# end def
 
 
def animation_de_depart(sx, sy, dep):
    """
        petite animation de départ
        amenant la balle du carré de départ
        vers le premier couloir du parcours
        quel que soit le parcours dessiné;
    """
 
    # on déclare uniquement
    # les variables globales que l'on modifie
    global X, Y
 
    # toujours dans le carré de départ ?
    if x1 <= X <= x2 and y1 <= Y <= y2:
 
        # mise à jour coordonnées
        X += sx * dep
        Y += sy * dep
 
        # on déplace la balle d'un pas
        canvas.move(id_balle, sx * dep, sy * dep)
 
        # on appelle le pas suivant au bout
        # d'un certain délai (en millisecondes)
        # avec les mêmes paramètres qu'au départ
        fenetre.after(100, animation_de_depart, sx, sy, dep)
 
    # la balle est sortie du carré ?
    else:
 
        # on lance la fonction de déplacement
        # où le joueur peut modifier
        # la trajectoire de la balle
        deplacer_balle()
 
# end def
 
 
def deplacer_balle():
    """
        procédure principale de déplacement de la balle
        le joueur peut modifier la trajectoire de la balle
        durant cette procédure;
    """
 
    # détection de collisions
    collisions = canvas.find_overlapping(*canvas.bbox(id_balle))
 
    # la balle a-t-elle heurté le carré final ?
    if id_carre_final in collisions:
 
        # bravo, c'est gagné !
        bravo()
 
    # la balle a-t-elle heurté un mur ?
    elif len(collisions) > 1:
 
        # dommage, c'est perdu !
        game_over()
 
    # la balle n'a rien heurté ?
    else:
 
        # on continue de déplacer la balle
        canvas.move(id_balle, sx * dep, sy * dep)
 
        # on rappelle cette procédure
        # au bout d'un certain délai (en millisecondes)
        fenetre.after(100, deplacer_balle)
 
# end def
 
 
def bravo():
    """
        le joueur a atteint son objectif
        procédure de félicitations;
    """
 
    # affichage d'un message
    canvas.create_text(
        xy_centre(canvas),
        text="BRAVO !",
        font="sans 24 bold",
        fill="steel blue",
    )
 
    # on émet un son
    jouer_son("SystemExclamation")
 
    # on passe automatiquement au niveau suivant
    # au bout d'un certain délai (en millisecondes)
    fenetre.after(2000, niveau_suivant)
 
# end def
 
 
def game_over():
    """
        le joueur a perdu
        procédure de fin de partie;
    """
 
    # calcul du point central du canevas
    x, y = xy_centre(canvas)
 
    # affichage d'un message
    canvas.create_text(
        x, y - 20,
        text="GAME OVER",
        font="sans 24 bold",
        fill="firebrick",
    )
 
    # bouton 'rejouer'
    canvas.create_window(
        x, y + 20,
        window=Button(canvas, text="Rejouer", command=demarrer_partie),
    )
 
    # on émet un son
    jouer_son("SystemExit")
 
# end def
 
 
def jouer_son (nom):
    """
        joue un son système de MS-Windows
    """
 
    #~ winsound.PlaySound(nom, winsound.SND_ALIAS|winsound.SND_ASYNC)
    pass
 
# end def
 
 
def niveau_suivant ():
    """
        passage au niveau supérieur
        si l'index de niveaux dépasse le nombre maximum
        de parcours pré-stockés, on aiguille sur une procédure
        de félicitations - le joueur a tout gagné;
    """
 
    # on déclare uniquement
    # les variables globales que l'on modifie
    global niveau
 
    # mise à jour niveau suivant
    niveau += 1
 
    # le joueur a tout gagné ?
    if niveau > max_parcours:
 
        # faites péter le feu d'artifice !
        bouquet_final()
 
    # il reste encore un niveau à jouer ?
    else:
 
        # on redémarre une nouvelle partie
        demarrer_partie()
 
    # end if
 
# end def
 
 
def bouquet_final ():
    """
        procédure de félicitations
        le joueur a tout gagné dans tous les niveaux !
    """
 
    # on efface le canevas
    canvas.delete(ALL)
 
    # calcul du point central du canevas
    x, y = xy_centre(canvas)
 
    # affichage d'un message
    canvas.create_text(
        x, y - 50,
        text="TROP FORT !",
        font="sans 32 bold",
        fill="medium sea green",
    )
 
    canvas.create_text(
        x, y - 10,
        text="Vous avez tout gagné !",
        font="sans 12 bold",
        fill="indian red",
    )
 
    # bouton 'recommencer'
    canvas.create_window(
        x, y + 30,
        window=Button(
            canvas, text="Recommencer", command=init_premier_niveau
        ),
    )
 
    # on émet un son
    jouer_son("SystemExclamation")
 
# end def
 
 
def deplacer_gauche (event=None):
    """
        sens de déplacement de la balle : vers la gauche
    """
    global sx, sy
    sx = -1
    sy = 0
 
# end def
 
 
def deplacer_droite (event=None):
    """
        sens de déplacement de la balle : vers la droite
    """
    global sx, sy
    sx = 1
    sy = 0
 
# end def
 
 
def deplacer_haut (event=None):
    """
        sens de déplacement de la balle : vers le haut
    """
    global sy, sx
    sy = -1
    sx = 0
 
# end def
 
 
def deplacer_bas (event=None):
    """
        sens de déplacement de la balle : vers le bas
    """
    global sy, sx
    sy = 1
    sx = 0
 
# end def
 
 
# si ce script est directement appelé
if __name__ == "__main__":
 
    # lancer le jeu
    init_jeu()
 
# end if

Note : vous pouvez ajouter autant de nouveaux parcours que vous le souhaitez dans la fonction init_parcours() / variable parcours à la suite des autres déclarations de parcours (en copiant/collant un parcours précédent et en le modifiant ensuite, par exemple), la gestion des parcours est automatique : vous n'avez pas besoin d'ajouter autre chose dans le code que les déclarations de parcours pour que cela fonctionne.

Bon Bacho, bonnes vacances à tutti.

Amusez-vous bien !

@+.

Jeu de labyrinthe - Animation d'une balle.

Tkinter Python

Discussions similaires

Partager

Partager