Problème de collision

**DonkeySlurp** · 24/04/2014, 20h06

Bonsoir, je suis actuellement en train de faire un Jeu style "Tron" (4 motos font une course dans une arène, le joueur dirige la moto, et laisse derrière une trainée qui, si elle est percuté par une autre moto voir la moto correspondante à la trainée, tue les joueurs). Et justement la phase de collision m'embête, je voudrais que justement que lorsqu'une moto percute une trainée (n'importe laquelle, il meurt et disparait de l'arène) j'avais pensé à entrer les différentes valeurs de la variable de la trainée dans une liste et faire en sorte que si la variable moto1 (la moto) est égale à une des valeur de la trainée alors on supprime la variable moto1 et sa trainée. Mais je n'ai pas réussi. Alors si quelqu'un aurait une idée, ça ne serait pas refus

. Merci d'avance

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
 
from tkinter import *
 
 
                                                   #Fonctions#
 
#Mouvement des motos
def JJA_Play_Move():
    global m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12,m13,m14,m15,m16,can, moto1,moto2,moto3,moto4
    if direction_1  == 'q':
        if m1!=0:
            a=can.create_rectangle(m1,m2,m3,m4, outline='light blue', fill="light blue") #création de la trainée moto1
            m1 = m1 - dx
            m3 = m3 - dx
            moto1=can.create_rectangle(m1,m2,m3,m4, outline="blue", fill="sky blue") #nouvelle position de la moto1
    if direction_1  == 'd':
        if m3!=largeur:
            a=can.create_rectangle(m1,m2,m3,m4, outline='light blue', fill="light blue")
            m1 = m1 + dx
            m3 = m3 + dx
            moto1=can.create_rectangle(m1,m2,m3,m4, outline="blue", fill="sky blue")
    if direction_1  == 'z':
        if m4!=10:
            a=can.create_rectangle(m1,m2,m3,m4, outline='light blue', fill="light blue")
            m2 = m2 - dx
            m4 = m4 - dx
            moto1=can.create_rectangle(m1,m2,m3,m4, outline="blue", fill="sky blue")
    if direction_1  == 's':
        if m2!=hauteur-10:
            a=can.create_rectangle(m1,m2,m3,m4, outline='light blue', fill="light blue")
            m2 = m2 + dx
            m4 = m4 + dx
            moto1=can.create_rectangle(m1,m2,m3,m4, outline="blue", fill="sky blue")
    if direction_2  == 'g':
        if m5!=0:
            b=can.create_rectangle(m5,m6,m7,m8,outline='light salmon', fill="light salmon") #création de la trainée moto2
            m5 = m5 - dx
            m7 = m7 - dx
            moto2=can.create_rectangle(m5,m6,m7,m8, outline="red", fill="orange") #nouvelle position de la moto2
    if direction_2  == 'j':
        if m7!=largeur:
            b=can.create_rectangle(m5,m6,m7,m8,outline='light salmon', fill="light salmon")
            m5 = m5 + dx
            m7 = m7 + dx
            moto2=can.create_rectangle(m5,m6,m7,m8, outline="red", fill="orange")
    if direction_2  == 'y':
        if m8!=0:
            b=can.create_rectangle(m5,m6,m7,m8,outline='light salmon', fill="light salmon")
            m6 = m6 - dx
            m8 = m8 - dx
            moto2=can.create_rectangle(m5,m6,m7,m8, outline="red", fill="orange")
    if direction_2  == 'h':
        if m6!=hauteur:
            b=can.create_rectangle(m5,m6,m7,m8,outline='light salmon', fill="light salmon")
            m6 = m6 + dx
            m8 = m8 + dx
            moto2=can.create_rectangle(m5,m6,m7,m8, outline="red", fill="orange")
    if direction_3 == 'Left' and V_GFR_joueurs>=3 :
        if m9!=0:
            c=can.create_rectangle(m9,m10,m11,m12,outline='light green', fill="light green") #création de la trainée moto3
            m9 = m9 - dx
            m11 = m11 - dx
            moto3=can.create_rectangle(m9,m10,m11,m12, outline="dark green", fill="green") #nouvelle position de la moto3
    if direction_3 == 'Right' and V_GFR_joueurs>=3:
        if m11!=largeur:
            c=can.create_rectangle(m9,m10,m11,m12,outline='light green', fill="light green")
            m9 = m9 + dx
            m11 = m11 + dx
            moto3=can.create_rectangle(m9,m10,m11,m12, outline="dark green", fill="green")
    if direction_3 == 'Up' and V_GFR_joueurs>=3:
        if m12!=0:
            c=can.create_rectangle(m9,m10,m11,m12,outline='light green', fill="light green")
            m10 = m10 - dx
            m12 = m12 - dx
            moto3=can.create_rectangle(m9,m10,m11,m12, outline="dark green", fill="green")
    if direction_3  == 'Down' and V_GFR_joueurs>=3 :
        if m10!=hauteur:
            c=can.create_rectangle(m9,m10,m11,m12,outline='light green', fill="light green")
            m10 = m10 + dx
            m12 = m12 + dx
            moto3=can.create_rectangle(m9,m10,m11,m12, outline="dark green", fill="green")
    if direction_4 == '4' and V_GFR_joueurs==4 :
        if m13!=0:
            d=can.create_rectangle(m13,m14,m15,m16,outline='yellow', fill="yellow") #création de la trainée moto4
            m13 = m13 - dx
            m15 = m15 - dx
            moto4=can.create_rectangle(m13,m14,m15,m16,outline='gold', fill="yellow") #nouvelle position de la moto4
    if direction_4 == '6' and V_GFR_joueurs==4:
        if m15!=largeur:
            d=can.create_rectangle(m13,m14,m15,m16,outline='yellow', fill="yellow")
            m13 = m13 + dx
            m15 = m15 + dx
            moto4=can.create_rectangle(m13,m14,m15,m16, outline='gold', fill="yellow")
    if direction_4 == '8' and V_GFR_joueurs==4:
        if m16!=0:
            d=can.create_rectangle(m13,m14,m15,m16,outline='yellow', fill="yellow")
            m14 = m14 - dx
            m16 = m16 - dx
            moto4=can.create_rectangle(m13,m14,m15,m16, outline='gold', fill="yellow")
    if direction_4  == '5' and V_GFR_joueurs==4 :
        if m14!=hauteur:
            d=can.create_rectangle(m13,m14,m15,m16,outline='yellow', fill="yellow")
            m14 = m14 + dx
            m16 = m16 + dx
            moto4=can.create_rectangle(m13,m14,m15,m16, outline='gold', fill="yellow")
    if flag == 1:
        fen.after(40, JJA_Play_Game)
 
def left1(event): # Changement de sens de la moto du J1 vers la gauche
    global direction_1
    direction_1 = 'q'
 
def right1(event): # Changement de sens de la moto du J1 vers la droite
    global direction_1
    direction_1 = 'd'
 
def up1(event): # Changement de sens de la moto du J1 vers le haut
    global direction_1
    direction_1 = 'z'
 
def down1(event): # Changement de sens de la moto du J1 vers le bas
    global direction_1
    direction_1 = 's'
 
def left2(event): # Changement de sens de la moto du J2 vers la gauche
    global direction_2
    direction_2 = 'g'
 
def right2(event): # Changement de sens de la moto du J2 vers la droite
    global direction_2
    direction_2 = 'j'
 
def up2(event): # Changement de sens de la moto du J2 vers le haut
    global direction_2
    direction_2 = 'y'
 
def down2(event): # Changement de sens de la moto du J2 vers le bas
    global direction_2
    direction_2 = 'h'
 
def left3(event): # Changement de sens de la moto du J3 vers la gauche
    global direction_3
    direction_3 = 'Left'
 
def right3(event): # Changement de sens de la moto du J3 vers la droite
    global direction_3
    direction_3 = 'Right'
 
def up3(event): # Changement de sens de la moto du J3 vers le haut
    global direction_3
    direction_3 = 'Up'
 
def down3(event): # Changement de sens de la moto du J3 vers le bas
    global direction_3
    direction_3 = 'Down'
 
def left4(event): # Changement de sens de la moto du J4 vers la gauche
    global direction_4
    direction_4 = '4'
 
def right4(event): # Changement de sens de la moto du J4 vers la droite
    global direction_4
    direction_4 = '6'
 
def up4(event): # Changement de sens de la moto du J4 vers le haut
    global direction_4
    direction_4 = '8'
 
def down4(event): # Changement de sens de la moto du J4 vers le bas
    global direction_4
    direction_4 = '5'
 
def JJA_Play_Game(): # Lance le jeu
    global flag
    if flag == 0:
        flag = 1
    JJA_Play_Move()
 
def JJA_Play_Go():
    global largeur,hauteur,can,fen
    fen = Tk()
    can = Canvas(fen, width=largeur, height=hauteur,bg="white")
    can.pack(padx=5, pady=5)
    b1 = Button(fen, text='Go !!', command=JJA_Play_Game)
    b1.pack(side=LEFT, padx=5, pady=5)
    b2 = Button(fen, text='Quitter', command=fen.destroy)
    b2.pack(side=RIGHT, padx=5, pady =5)
    tex1 = Label(fen, text="Cliquez sur 'Go' pour la Retron-lution .. Bon j'avoue le jeu de mot n'est pas terrible mais bon c'est un peu mieux que 'Riz-volution' de la pub Lustucru.", fg='#333333')
    tex1.pack(padx=0, pady=11)
    fen.bind('<d>', right1)
    fen.bind('<q>', left1)
    fen.bind('<z>' , up1)
    fen.bind('<s>', down1)
    fen.bind('<j>', right2)
    fen.bind('<g>', left2)       #Contrôle des touches
    fen.bind('<y>' , up2)
    fen.bind('<h>', down2)
    fen.bind('<Right>', right3)
    fen.bind('<Left>', left3)
    fen.bind('<Up>' , up3)
    fen.bind('<Down>', down3)
    fen.bind('4', left4)
    fen.bind('6', right4)
    fen.bind('8', up4)
    fen.bind('5', down4)
    fen.mainloop()
 
def JJA_Play_Choc():
    global a, moto1, flag
    if m1==00:
        del moto1, a
        flag==2
    if flag != 0:
        fen.after(1, JJA_Play_Choc)
 
                                              #Programme principal#
 
dx= 10 #Le pas des moto
flag = 0
 
traine1=[]
 
direction_1 = 'd'
direction_2 = 'g'    #Direction initiale de la moto
direction_3= 'Up'
direction_4= '5'
 
largeur=1200
hauteur=650
 
V_GFR_joueurs=2 #Nombre de moto dans l'arène par défaut(sans choix dans les options)
 
m1=10
m2=10
m3=20             #Coordonnées Moto J1
m4=20
 
m5=largeur-20
m6=hauteur-20
m7=largeur-10     #Coordonnées Moto J2
m8=hauteur-30
 
m9=10
m10=hauteur-10
m11=20            #Coordonnées Moto J3
m12=hauteur-20
 
m13=largeur-20
m14=30
m15=largeur-10    #Coordonnées Moto J4
m16=20

**LittleWhite** · 25/04/2014, 08h10

Bonjour,

La meilleure technique serait d'écrire la trainée dans une image blanche. Ainsi, lorsque vous devez vérifier pour la collision, il suffit de lire les pixels de l'image à l'endroit voulu, pour voir s'ils sont différent de blancs

**DonkeySlurp** · 25/04/2014, 12h07

Houla.. J'ai dû mal à comprendre votre technique :p. Vous entendez quoi par "écrire la trainée dans une image blanche" ?

**LittleWhite** · 25/04/2014, 13h05

La trainée de la moto, vous savez ... "le mur" après le passage de la moto.
La texture permet de sauvegarder où les motos sont passés et cela, sans grande difficulté.

**DonkeySlurp** · 25/04/2014, 13h13

Donc si j'ai bien compris, dans ma fonction je dis que si la couleur de la moto1 est égale à la couleur d'une trainée de quelconque moto alors la variable moto1 est supprimé ?

Désolé si j'ai dû mal à comprendre, c'est la première que j'entends parler de ce genre de technique, ma prof d'ISN nous l'a pas appris :p.

**LittleWhite** · 25/04/2014, 13h34

Ok, je vais essayer de reprendre à partir de la base.
Vous avez N moto, avec N couleur pour chaque moto. Chaque moto laisse une trainée (un mur), dans lequel les autres motos peuvent foncer dedans et notamment, s'exploser dedans.

Le principal soucis est de savoir quand une moto fonce dans le mur. Sachant qu'un mur peut avoir une forme bizarroïde (même si cela reste une suite de lignes), il sera compliqué d'utiliser des variables. Toutefois, vous pouvez vous en sortir avec une liste chainées de lignes et lorsque vous avez besoin de vérifier si la moto rentre dans un mur, faire un test de collision ligne VS ligne, sur toutes les lignes présente dans le jeu. Les soucis de cette méthode sont :

un nombre énorme de lignes après une grande partie, faisant que le test va potentiellement devenir de plus en plus lent ;
une solution finalement difficile à mettre en place.

Et donc, je vous ai proposé une autre solution.
La seconde solution repart de la base. Qu'est ce qu'un mur ? Dans un Tron 2D, c'est juste un pixel d'une couleur définie sur l'écran. La moto peut continuer tant que le pixel devant elle, n'est pas allumé. Ok, c'est déjà un bon début. Le test est simple : "tester la couleur d'un pixel à l'écran".
Je suis aller plus loin et je me suis dit, c'est cool, mais j'aimerai que le jeu affiche une image de fond (qui peut avoir une couleur autre que unie). Donc, ma technique précédente n'est pas applicable : en effet, tous les pixels sont potentiellement allumés et pourraient être considérés comme des murs. Pour gérer ce cas, il ne suffit plus de tester les pixels à l'écran, mais les pixels dans une texture. À chaque fois qu'une moto avant, on va écrire dans une texture, la couleur de la moto, faisant apparaître "logiquement" un mur. À chaque fois que l'on déplace la moto, on test le pixel (dans la texture) devant elle, pour voir s'il y a un mur. Le principe est resté le même, juste que l'on a changé l'endroit (en mémoire) d'où les murs sont récupérés.

Chez moi, une texture, au final, c'est juste un tableau 2D, de la taille de la fenêtre de jeu. Cela pourrait en être autrement, mais en théorie, c'est toujours un tableau 2D.

Voilà, j'espère avoir été un peu plus clair.

**DonkeySlurp** · 25/04/2014, 13h54

Alors cette fois, si j'ai bien compris en plus du canevas, on fait un tableau de 2d de la taille du canevas et dont les cases équivaut à la moto, à chaque fois que la moto avance d'une case dans le canevas, dans le tableau on ajoute à cette case la couleur de la moto correspondante (on aura le mur). Et à chaque fois que la moto avance, on vérifie la couleur de la prochaine case et on en détermine la collision (moto1 bleu percute mur rouge donc moto1 supprimé). C'est ça ?