Discussion :

[<arobase>]

Bonjour a tous !

Je débute en python avec excellent livre "Apprendre à programmer avec Python" de Gérard Swinnen, c'est très interresant.
Bon, je m'amuse je teste des petits programmes etc... et alors j'ai essayé d'en faire un où l'on devrait cliquer sur des balles, afin de les faire disparaitre avant qu'elles n'arrivent au bord de l'écran (classique) mais bon...

Voilà le code :

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
# -*- coding:Utf-8 -*-
#!/usr/bin/python
 
####
 
############
# Importation des fonctions externes
from Tkinter import *
from random import randrange
 
############
 
####################
# Définition locale de fonctions
####################
 
def couleur():
        pal=['purple','cyan','maroon','green','red','blue','orange','yellow']
        c = randrange(8)
        return pal[c]
 
def move():
        "Déplace la balle"
        global x1, y1, dx, dy, flag, score, vague, oval
        if oval[0]:
 
                x1[0], y1[0] = x1[0] + dx, y1[0] + dy
                if x1[0] > 500:
                        score = score -1
                        chaineScore.configure(text = "score :" +  str(score))
                        can1.delete(oval[0])
                        flag[0] = 0
                        x1[0] =10 
                        oval[0] = 0
                else:
                        can1.coords (oval[0], x1[0], y1[0], x1[0]+20, y1[0]+20)
        else:
                y1[0] = randrange(10,220)
                oval[0] = can1.create_oval(x1[0],y1[0],x1[0]+20,y1[0]+20,width=1,fill=couleur())
                vague = vague + 1
                chaineVague.configure(text='Attaquants : ' + str(vague))
                flag[0] = 1
        if flag[0] > 0:
                fen1.after(50, move)
 
def move2():
        "Déplace la balle"
        global x1, y1, dx, dy, flag, score, vague, oval
        if oval[1]:
 
                x1[1], y1[1] = x1[1] + dx, y1[1] + dy
                if x1[1] > 500:
                        score = score -1
                        chaineScore.configure(text = "score :" +  str(score))
                        can1.delete(oval[1])
                        flag[1] = 0
                        x1[1] =10 
                        oval[1] = 0
                else:
                        can1.coords (oval[1], x1[1], y1[1], x1[1]+20, y1[1]+20)
        else:
                y1[1] = randrange(10,220)
                oval[1] = can1.create_oval(x1[1],y1[1],x1[1]+20,y1[1]+20,width=1,fill=couleur())
                vague = vague + 1
                chaineVague.configure(text='Attaquants : ' + str(vague))
                flag[1] = 1
        if flag[1] > 0:
                fen1.after(50, move2)
 
def move3():
        "Déplace la balle"
        global x1, y1, dx, dy, flag, score, vague, oval
        if oval[2]:
 
                x1[2], y1[2] = x1[2] + dx, y1[2] + dy
                if x1[2] > 500:
                        score = score -1
                        chaineScore.configure(text = "score :" +  str(score))
                        can1.delete(oval[2])
                        flag[2] = 0
                        x1[2] =10 
                        oval[2] = 0
                else:
                        can1.coords (oval[2], x1[2], y1[2], x1[2]+20, y1[2]+20)
        else:
                y1[2] = randrange(10,220)
                oval[2] = can1.create_oval(x1[2],y1[2],x1[2]+20,y1[2]+20,width=1,fill=couleur())
                vague = vague + 1
                chaineVague.configure(text='Attaquants : ' + str(vague))
                flag[2] = 1
        if flag[2] > 0:
                fen1.after(50, move3)
 
def stop_it():
        "Stoppe l'animation"
        global flag
        flag = [0]*3
 
def start_it():
        "Démarre l'animation"
        global flag, test
        if flag[0] == 0:
                flag[0] = 1
                move()
        if flag[1] == 0:
                flag[1] = 1
                move2()
        if flag[2] == 0:
                flag[2] = 1
                move3()
        fen1.after(2000, start_it) #et tu boucle :p
 
 
def finDePartie():
        global test, score, flag
        if score <= 0:
                fen2 = Tk()
                fen2.title('PERDU')
                Label(fen2, text='PERDU !').pack()
                Button(fen2, text='Quitter', command=fen1.quit).pack(side=BOTTOM)
                test = 0
                flag = [0]*3
                fen2.mainloop()
 
        if test == 1:
                fen1.after(50, finDePartie) #et tu boucle :p
 
def testClic(event):
        global x1, y1, flag, oval
        if event.x > x1[0] and event.x < x1[0]+30 and event.y > y1[0] and event.y < y1[0]+30:
                can1.delete(oval[0])
                flag[0] = 0
                x1[0] =10 
                oval[0] = 0
        if event.x > x1[1] and event.x < x1[1]+30 and event.y > y1[1] and event.y < y1[1]+30:
                can1.delete(oval[1])
                flag[1] = 0
                x1[1] =10
                oval[1] = 0
        if event.x > x1[2] and event.x < x1[2]+30 and event.y > y1[2] and event.y < y1[2]+30:
                can1.delete(oval[2])
                flag[2] = 0
                x1[2] =10
                oval[2] = 0
 
########################
#Corps principal du programme
########################
 
 #Variables globales :
x1 = [10]*3
y1 = [randrange(10,220), randrange(10,220), randrange(10,220)]
flag = [0]*3
oval = [0]*3
dx, dy = 5, 0#Pas du déplacement
test = 1
score = 10
vague = 0 
 
#Fenêtre
fen1 = Tk()
fen1.title("Invasion")
 
#Widgets
can1 = Canvas(fen1,bg="dark grey", height=250,width=505)
can1.bind("<Button-1>", testClic)
can1.pack(side=LEFT, padx =5, pady =5)
 
#can1.create_rectangle(500,0,505,250,width=0,fill='green')
 
 
chaineScore = Label(fen1, text='Score : 10')
chaineScore.pack(side=BOTTOM)
 
chaineVague = Label(fen1, text='Attaquants : ' + str(vague))
chaineVague.pack(side=BOTTOM)
 
Button(fen1, text='Quitter', command=fen1.quit).pack(side=BOTTOM)
Button(fen1, text='Go !', command=start_it).pack()
Button(fen1, text='Stop !', command=stop_it).pack()
 
# Démarrage du réceptionnaire d'évènements
finDePartie()
fen1.mainloop()

Ouhhhhh.... que c'est moche C'est codé avec les pied... je sais ! Et en plus c'est très lourd. Mais bon, je l'ai codé comme ça au fur et à meusure que je lisais le livre par petits bouts, en partant de l'exercice ou l'on doit faire bouger une boule

Quelques chapitres plus tard, après avoir ingurgité de gros morceaux de théorie bien indigeste, j'essaye de le recoder en POO

et voilà :

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
 
# -*- coding:Utf-8 -*-
#!/usr/bin/python
 
####
 
############
# Importation des fonctions externes
from Tkinter import *
from random import randrange
 
############
 
 
####################
# Définition des CLASSES
####################
 
class Attaquant:
        "Un attaquant"
        def __init__(self):
                self.x1 = 10
                self.y1 = randrange(10,220)
                self.flag = 0
                self.oval = 0
                self.vitesseX = 5
                self.taille = 20
                self.pal=['purple','cyan','maroon','green','red','blue','orange','yellow']
                self.c = randrange(8)
                self.couleur = self.pal[self.c]
 
        def attaque(self):
                "Créer et déplace l'attaquant"
                global score, vague
                if self.oval:
                        self.bouge()
                        if self.x1 > 500:
                                score = score -1
                                chaineScore.configure(text = "Vie : " +  str(score))
                                self.tuer()
                        self.miseAjour()
 
                else:
                        self.apparait()
                        vague = vague + 1
                        chaineVague.configure(text='Attaquants : ' + str(vague))
                if self.flag > 0:
                        fen1.after(50, self.attaque())
 
        def tuer(self):
                "Détruit l'attaquant"
                zone.delete(self.oval)
                self.flag = 0
                self.x1 =10 
                self.oval = 0
 
        def bouge(self):
                "Incrémente les coordonnées de l'attaquant pour le faire avancer"
                self.x1 = self.x1 + self.vitesseX
 
 
        def miseAjour(self):
                "Met à jour la position de l'attaquant"
                zone.coords(self.oval, self.x1, self.y1,  self.x1+self.taille, self.y1+self.taille)
 
        def apparait(self):
                "Créer l'attaquant "
                self.y1 = randrange(10,220)
                self.oval = zone.create_oval(self.x1, self.y1, self.x1+self.taille, self.y1+self.taille,width=1,fill=self.couleur)
                self.flag = 1
 
 
        def stop(self):
                "Arrête l'attaquant"
                self.flag = 0
 
####################
# Définition locale de fonctions
####################
 
def start_it():
        "Démarre le jeu"
        a1 = Attaquant()
        a1.attaque()
 
 
def finDePartie():
        "Teste le score et termine la partie"
        global test, score
        if score <= 0:
                fen2 = Tk()
                fen2.title('PERDU')
                Label(fen2, text='PERDU !').pack()
                Button(fen2, text='Quitter', command=fen1.quit).pack(side=BOTTOM)
                test = 0
                fen2.mainloop()
        if test == 1:
                fen1.after(50, finDePartie) #et tu boucle :p
 
def testClic(event):
        "Teste le clic"
        if event.x > a1.x1 and event.x < a1.x1+a1.taille and event.y > a1.y1 and event.y < a1.y1+a1.taille:
                a1.tuer()
 
 
 
########################
#Corps principal du programme
########################
 
 #Variables globales :
test = 1
score = 10
vague = 0 
 
#Fenêtre
fen1 = Tk()
fen1.title("Invasion")
 
#Widgets
zone = Canvas(fen1,bg="dark grey", height=250,width=505)
zone.bind("<Button-1>", testClic)
zone.pack(side=LEFT, padx =5, pady =5)
 
chaineScore = Label(fen1, text='Vie: 10')
chaineScore.pack(side=BOTTOM)
 
chaineVague = Label(fen1, text='Attaquants : ' + str(vague))
chaineVague.pack(side=BOTTOM)
 
baseVerte = zone.create_rectangle(500,0,505,250,width=0,fill='green')
 
Button(fen1, text='Quitter', command=fen1.quit).pack(side=BOTTOM)
Button(fen1, text='Jouer', command=start_it).pack()
 
# Démarrage du réceptionnaire d'évènements
finDePartie()
fen1.mainloop()

Seulement quand je clique sur "GO" le jeu bugue (le boutton reste enfoncé) et enfin il reprend mais, le bonhomme et déjà passé, donc le score est diminué, le nombre d'attaquants aussi mais on a pas pu jouer... pas cool !

Je pense que c'est parce que la procédure "start_it" attend que toutes les opérations soit effectuées avant de redonner la main... comment faire pour résoudre ce problème ? Merci d'avance

[luffy.luck]

Ce mess a deja quelques jours alors peut-etre a tu deja trouvé la solution. Si nan :

Quand je vais te dire ce qui ne va pas je crois que tu vas avoir envi de te pendre(genre de probleme ou on passe des heures pour rien ^^):

Regarde dans la récurcivité de ta fonction "attaque" de ta classe Attaque, il faut juste que enleve les parenthèses :

cf fen1.after(50, self.attaque)

Apres pour la fonction findepartie, tu devrais(conseil) la mettre dans ta fonction attaque et supprimer la récurcivité de facon a eviter trop de boucle.


Sinon juste deux ou trois conseils. Je sais que c'est un de tes premiers programmes mais bon je vais te les donner quand meme, ca sera fais(on m'a fais pareil ^^) )Des fois je penses( c'est mon avis) que tes indentations sont trop grandes (tu as parfois des indentations dignes du kernel linux), si tu as des vus pour un metier dans la programmation, je crois que plus de 90 % des codes en general sont en anglais, pour le shebang python #!/bin/.... il faut le placer en premier dans ton prog (switch la norme du code et le shebang).

Sinon moi aussi j'ai appris avec le meme pdf, et j'ai codé un snake en python sur le meme modèle (peut etre que ca pourra t'aider)(il est très très mal codé parce que je l'ai fais en vitesse et que c'etais mon premier programme mais ca te donnera une idée, apres si tu veux voir des codes plus propres =>vas dans ma rubrique picture viewer in python):
http://luffy.luck.free.fr/dokuwiki-r...nake_in_python

j'espere avoir pu t'aider, si jamais tu a besoin d'autre chose plus spécifiquement vas chercher mon adresse mail sur mon wiki.

Bonne chance

luffy

[luffy.luck]

PS: Je viens de reussir a le faire fonctionner, il y avait encore deux ou trois problèmes, dis moi si il te faut le script ou si tu prefere chercher seul?

luffy