Détecter Collisions / Superposition d'objets (Triangles)

Version imprimable

Bonjour à tous !

Je suis en train de créer un jeu d'infiltration, certes rudimentaire, mais qui, dans l'idée, disposerait tout de même de la base de ce genre de jeux: un cône de détection pour des gardes.

Voilà pour le moment mon programme:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
 
from tkinter import*
from math import*
 
# Cette partie sert à déterminer dans quelle position est le garde.
 
gauche = False
droite = False
haut = False
bas = False
 
#Cette partie sert à déterminer les coordonnées d'origine du garde.
 
y1=250
x1=250
 
#Cette partie sert à déterminer les coordonnées d'origine du joueur.
 
x2=100
y2=100
 
#Cette fonction sert à déplacer le garde, en créant et en modifiant également le champ de vision, et à détecter.
 
def deplacement (evt):
#Cette partie permet de modifier les valeurs des variables suivantes:
    global detecte 
    global x1 
    global y1 
    global x2 
    global y2 
    global gauche 
    global droite 
    global haut 
    global bas
    global angle
    drawzone.delete(ALL) #On commence par nettoyer le canevas, pour éviter les superpositions des objets.
    player=drawzone.create_oval(x2,x2,x2+10,y2+10, fill="blue") #On recrée le joueur à sa place initiale. On ne le met pas à la fin, car ses coordonnées interviennent dans la détection.
    if evt.keycode==38: #Si jamais on presse la flèche directionnelle "Haut"
        detecte=0 #Ce petit ajout permet d'éviter le flood de "détectés" dans le moniteur.
        haut=True # Le garde passe en position haute
        gauche = False
        droite = False
        bas = False
 #On modifie les coordonnées du garde
        y1=y1-5 #Coordonnées en y du garde
        xf1=x1-a*y1 #Coordonnées en x du premier point du champ de vision
        yf1=0 #Cordonnées en y du premier point du champ de vision
        xf2=x1+a*y1 #Coordonnées en x du second point du champ de vision
        yf2=0 #Coordonnées en y du second point du champ de vision
#On recrée le champ de vision
        field2=drawzone.create_polygon(xf1, 0,xf2, 0, x1, y1, fill="yellow")
#On recrée le garde (après la champ de vision pour ne pas que celui-ci ne l'efface partiellement)
        point=drawzone.create_oval(x1-5,y1-5,x1+5,y1+5, fill="black")
#Cette partie sert à détecter le joueur 
#>>>>>>> LE PROBLEME EST ICI <<<<<<<< !!!!
        if x2>=xf1 and x2<=xf2 and y2>=yf2 and y2>=yf2 and y1>=y2: 
#Cela nous donne un champ de vision effectif RECTANGULAIRE, ce qui fait que si jamais le joueur est placé juste à côté du garde (en fait, entre le champ de vision et la courbe y=yf1 ou y=yf2), il sera quand même détecté, donc pour se faufiler c'est... Mort. Et ça m'ennuie.
            print("detecte")
            detecte = 1
    elif evt.keycode==40:
        detecte=0
        bas=True
        gauche = False
        droite = False
        haut = False
        y1=y1+5
        xf1=a*500+x1-a*y1 #faisceau côté droit
        yf1=500           # faisceau côté droit
        xf2=-a*500+x1+a*y1 #faiseau côté gauche
        yf2=500            # faisceau côté gauche
        field1=drawzone.create_polygon(xf1, yf1, xf2, yf2, x1, y1, fill="yellow")
        point=drawzone.create_oval(x1-5,y1-5,x1+5,y1+5, fill="black")
        if x2<=xf1 and x2>=xf2 and y2<=yf2 and y2<=yf2 and y1<=y2 and detecte==0:
            print("detecte")
            detecte = 1 #Ceci évite de se faire flooder par les "detecte" ;D
#Et on y retourne ! C'est plus ou prou la même chose pour les trois "elif qui suivent"
    elif evt.keycode==39: #Garde se dirige vers la droite
        detecte=0
        droite=True
        gauche = False
        haut = False
        bas = False
        x1=x1+5
        xf1= 500 # faisceau bas
        yf1= a*500+y1-a*x1 # faisceau bas
        xf2= 500 # faisceau haut
        yf2= -a*500+y1+a*x1 #faisceau haut
        field3=drawzone.create_polygon(xf1, yf1, x1, y1, xf2, yf2, fill="yellow")
        point=drawzone.create_oval(x1-5,y1-5,x1+5,y1+5, fill="black")
        if x2>=xf1 and x2>=xf2 and y2<=yf1 and y2>=yf2 and detecte==0:
            detecte = 1
            print("detecte")
    elif evt.keycode==37: #Garde se dirige vers la gauche
        detecte=0
        gauche=True
        droite = False
        haut = False
        bas = False
        x1=x1-5
        xf1= 0       #faisceau haut
        yf1= y1-a*x1 #faisceau haut
        xf2= 0       #faisceau bas
        yf2= y1+a*x1 #faisceau bas
        field4=drawzone.create_polygon(xf1, yf1, x1, y1, xf2, yf2, fill="yellow")
        point=drawzone.create_oval(x1-5,y1-5,x1+5,y1+5, fill="black")
        if x2<=xf1 and x2<=xf2 and y2>=yf1 and y2<=yf2 & detecte==0:
            detecte = 1
            print("detecte")
    drawzone.tag_raise(player) #On remet le joueur en premier plan pour des raisons évidentes de visibilité.
 
 
 
a= sqrt(3)/3 #Ceci est le coefficient de chaque droite qui compose le champ de vision, avec un angle de 60°
 
 
 
fen=Tk() # On installe la fenêtre
fen.geometry("500x500") #On donne ses dimensions
fen.bind("<Key>", deplacement) #On la lie à l'évènement clavier
 
drawzone=Canvas(height=500, width=500, bg="White") #On initie le canevas
drawzone.place(x=0,y=0)
 
point=drawzone.create_oval(245,245,255,255, fill="black") #On place le joueur
player=drawzone.create_oval(x2,y2,y2+10,y2+10, fill="blue") #On place le garde
fen.mainloop()

Le problème étant, qu'actuellement, la détection souffre de quelques bugs, et, pour les triangles, la comparaison des coordonnées ne semble pas fonctionner. Serait-il possible de trouver une méthode plus fiable ?
Ps: Je tiens à rappeler que ce sont là des cônes de vision, et non pas des rectangles, car j'ai vu plusieurs astuces quant à l'utilisation de la méthode find_overlapping, mais celle-ci ne s'adresse qu'aux rectangles, et non pas aux trianlges...

Merci d'avance !

07/03/2016, 07h47
wiztricks

Salut,

Citation:

Envoyé par e.Saad

Ps: Je tiens à rappeler que ce sont là des cônes de vision, et non pas des rectangles, car j'ai vu plusieurs astuces quant à l'utilisation de la méthode find_overlapping, mais celle-ci ne s'adresse qu'aux rectangles, et non pas aux trianlges...

.find_overlapping permet de savoir si les rectangles qui recouvrent vos triangles se chevauchent. Si c'est le cas, il faut alors calculer plus précisément s'ils se chevauchent vraiment (ou pas) et c'est une question d'algo. (ou de géométrie). Il y a des tas de bonnes idées à glaner avec votre moteur de recherche favori (mots clés: triangle intersection 2D).

- W
07/03/2016, 09h40
e.Saad

Merci Google... Mais y'a un hic.

Citation:

Envoyé par wiztricks

Salut,

.find_overlapping permet de savoir si les rectangles qui recouvrent vos triangles se chevauchent. Si c'est le cas, il faut alors calculer plus précisément s'ils se chevauchent vraiment (ou pas) et c'est une question d'algo. (ou de géométrie). Il y a des tas de bonnes idées à glaner avec votre moteur de recherche favori (mots clés: triangle intersection 2D).

- W

Je vous remercie pour votre rapide réponse !

Cela dit, je m'excuse: Je me suis mal exprimé.

L'idée n'est pas de trouver quand deux triangles se superposent, mais quand un triangle (le cône de vision d'un garde) et le joueur (un cercle) se chevauchent... Je ne sais pas si les formules que j'ai trouvé sont adaptables !

Enfin, je suppose qu'entre trouver l'intersection d'une ligne avec un cercle ne devrait pas être trop compliquée si on considère la manière qu'a Tkinter de définir les cercles.
Je vous remercie encore pour votre réponse, et vais tester cela dès que j'aurai un peu de temps libre !

Merci encore ! :D

EDIT: Non, il reste un problème... Même si je trouve comment définir si ma ligne et mon cercle ont une intersection, comment pourrais je déterminer si le cercle se trouve dans l'espace délimité par les trois lignes qui forment mon triangle ?
C'est justement là qu'est le problème, car j'avais trouvé une manière plutôt efficace de détecter le joueur s'il est dans le champ de vision du garde, le hic était que, s'il se trouvait juste à côté, même hors de son champ de vision, le garde pouvait quand même le "voir". J'ai peur que le problème ne se répète.
Si vous avez deux minutes, je vous invite à tester le programme, que vous puissiez voir quel est le soucis... Je vais éditer le code pour qu'il soit un peu moins fastidieux à tester, et je vais améliorer les commentaires.
07/03/2016, 10h31
wiztricks

Citation:

Envoyé par e.Saad

L'idée n'est pas de trouver quand deux triangles se superposent, mais quand un triangle (le cône de vision d'un garde) et le joueur (un cercle) se chevauchent... Je ne sais pas si les formules que j'ai trouvé sont adaptables !

Ah ben, vous avez des objets "métier" (cône de vision d'un garde, joueur,...) mais côté code, on ne voit que la représentation que vous en avez fait: "cercle", "triangle".

Citation:

Envoyé par e.Saad

Enfin, je suppose qu'entre trouver l'intersection d'une ligne avec un cercle ne devrait pas être trop compliquée si on considère la manière qu'a Tkinter de définir les cercles.

Le triangle étant convexe, il suffit qu'un de ses sommets soit à une distance (euclidienne) du centre du cercle inférieure à son rayon.

C'est de la géométrie: tkinter ne fait que "représenter" plus ou moins bien cela avec des tas de pixels et vous donne accès à des optimisations comme .find_overlapping pour éviter de calculer vos distances euclidiennes à tous les coups.

- W
07/03/2016, 10h59
e.Saad

Citation:

Envoyé par wiztricks

Le triangle étant convexe, il suffit qu'un de ses sommets soit à une distance (euclidienne) du centre du cercle inférieure à son rayon.

- W

Oh... Oh attendez, je crois que je comprends. (j'ai pas mal gambergé là dessus, vous m'avez posé une colle au début ! J'ai besoin d'un café ^^" )

Si jamais le joueur entre dans le champ de vision, c'est qu'il est à une certaine distance soit du point supérieur gauche, soit du point supérieur droit, soit du point d'origine du champ (le garde).

Mais du coup, compte tenu de la taille du triangle, est-ce que ça sera applicable à l'intérieur du cercle ?
Parce que bon, éviter de le détecter hors du champ, c'est bien sympa, mais le détecter à l'intérieur c'est quand même primordial ! :D

Je vois encore un hic: Si jamais je colle à cela une distance minimale pour la détection, cela aggrave encore le problème, à savoir que si jamais le joueur se déplace hors du champ, mais à une distance inférieure à la distance minimale, il sera quand même détecté.
Adieu du coup les pas de loups pour rester hors de vision du garde, quand il peut vous détecter dans le dos, et même légèrement hors de son champ de vision...

Je vois un professeur de mathématiques, ce soir, je lui demanderai à cette occasion, mais en attendant, je vais gamberger là dessus.

Merci pour votre réponse, encore une fois !
Vous êtes rapide ! :D Et clair, avec ça !
07/03/2016, 11h10
wiztricks

Citation:

Envoyé par e.Saad

Je vois un professeur de mathématiques, ce soir, je lui demanderai à cette occasion, mais en attendant, je vais gamberger là dessus.

Prenez aussi rendez vous avec un "psy" au cas où car vous êtes plutôt embrouillé/compliqué :mrgreen::mrgreen::mrgreen:

- W
07/03/2016, 12h16
e.Saad

God dammit...

Citation:

Envoyé par wiztricks

Prenez aussi rendez vous avec un "psy" au cas où car vous êtes plutôt embrouillé/compliqué :mrgreen::mrgreen::mrgreen:

- W

Bon sang, ça se voit tant que ça ? 8O

J'ai très mal expliqué mon problème, non ? ><"

J'ai modifié mon programme, je tente une nouvelle méthode !

Cette fois-ci, c'est une comparaison d'aire !
En étant logique, si jamais le point est à l'intérieur du triangle, alors la somme des aires des trois triangles définis par deux points du cône et le point est égale à l'aire totale du cône.
Sauf que voilà, de nouveau, couille dans le pâté.
J'ai des erreurs de float, et surtout un résultat qui n'est pas, mais alors pas du tout ce que j'attendais.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
from tkinter import*
from math import*
 
# Cette partie sert à déterminer dans quelle position est le garde.
 
tarea = 0
gauche = False
droite = False
haut = False
bas = False
 
detecte=False
 
#Cette partie sert à déterminer les coordonnées d'origine du garde.
 
y1 = 250
x1 = 250
 
#Cette partie sert à déterminer les coordonnées d'origine du joueur.
 
x2 = 100
y2 = 100
 
# On calcule les aires des triangles.
def tarea(x1,x2,y,y1):
    global tarea
    tbase = x1-x2
    thauteur = y-y1
    tarea = (tbase*thauteur)/2
def areas(x,x1,x2,x3,y,y1,y2,y3):
 
    base1= (x1-x2) + (y2-y1)
    if  base1<0 :
        base1=base1*-1
    xm1= (x1+x2)/2
    if  xm1<0 :
        xm1=xm1*-1
    ym1= (y1+y2)/2
    if  ym1<0 :
        ym1=ym1*-1
    hauteur1=(x-xm1)+(y-ym1)
    if  hauteur1<0 :
        hauteur1=hauteur1*-1
    area1= (base1*hauteur1)/2
    if  area1<0 :
        area1=area1*-1
 
    base2= (x1-x3) + (y1-y3)
    if  base2<0 :
        base2=base2*-1
    xm2= (x1+x3)/2
    if  xm2<0 :
        xm2=xm2*-1
    ym2= (y1+y3)/2
    if  ym2<0 :
        ym2=ym2*-1
    hauteur2=(x-xm2)+(y-ym2)
    if  hauteur2<0 :
        hauteur2=hauteur2*-1
    area2= (base2*hauteur2)/2
    if  area2<0 :
        area2=area2*-1
 
    base3= (x2-x3) + (y2-y3)
    if base3<0 :
        base3=base3*-1
    xm3= (x2+x3)/2
    if  xm3<0 :
        xm3=xm3*-1
    ym3= (y2+y3)/2
    if  ym3<0 :
        ym3=ym3*-1
    hauteur3=(x-xm2)+(y-ym3)
    if  hauteur3<0 :
        hauteur3=hauteur3*-1
    area3= (base3*hauteur3)/2
    if  area3<0 :
        area3=area3*-1
 
    totalarea=area3+area2+area1
    print(totalarea)
    print(tarea)
 
 
#                           ***********
#                           DEPLACEMENT
#                           ***********
 
def deplacement (evt):
#Cette partie permet de modifier les valeurs des variables suivantes:
    global detecte
    global x1
    global y1
    global x2
    global y2
    global gauche
    global droite
    global haut
    global bas
    global angle
    drawzone.delete(ALL) #On commence par nettoyer le canevas, pour éviter les superpositions des objets.
    player=drawzone.create_oval(x2,x2,x2+10,y2+10, fill="blue") #On recrée le joueur à sa place initiale. On ne le met pas à la fin, car ses coordonnées interviennent dans la détection.
    if evt.keycode==38: #Si jamais on presse la flèche directionnelle "Haut"
        if haut==False:
            detecte=False #Ce petit ajout permet d'éviter le flood de "détectés" dans le moniteur.
            haut=True # Le garde passe en position haute
            gauche = False
            droite = False
            bas = False
 #On modifie les coordonnées du garde
        y1=y1-5 #Coordonnées en y du garde
        xf1=x1-a*y1 #Coordonnées en x du premier point du champ de vision
        yf1=0 #Cordonnées en y du premier point du champ de vision
        xf2=x1+a*y1 #Coordonnées en x du second point du champ de vision
        yf2=0 #Coordonnées en y du second point du champ de vision
 
#On recrée le champ de vision
        field2=drawzone.create_polygon(xf1, 0,xf2, 0, x1, y1, fill="yellow")
 
#On recrée le garde (après la champ de vision pour ne pas que celui-ci ne l'efface partiellement)
        point=drawzone.create_oval(x1-5,y1-5,x1+5,y1+5, fill="black")
 
 
 
 
#Cette partie sert à détecter le joueur
 
#>>>>>>> LE PROBLEME EST ICI <<<<<<<< !!!!
        #if x2>=xf1 and x2<=xf2 and y2>=yf2 and y2>=yf2 and y1>=y2 and detecte==False:
#Cela nous donne un champ de vision effectif RECTANGULAIRE, ce qui fait que si jamais le joueur est placé juste à côté du garde (en fait, entre le champ de vision et la courbe y=yf1 ou y=yf2), il sera quand même détecté, donc pour se faufiler c'est... Mort. Et ça m'ennuie.
 
#On tente de remplacer cette méthode avec un calcul d'aires
        tarea(xf2,xf1,y1,yf1)
        areas(x2,x1,xf2,xf2,y2,y1,yf1,yf2)
 
#Et on y retourne ! C'est plus ou prou la même chose pour les trois "elif qui suivent"
    elif evt.keycode==40:
        if bas==False:
            bas=True
            gauche = False
            droite = False
            haut = False
            detecte=0
        y1=y1+5
        xf1=a*500+x1-a*y1 #faisceau côté droit
        yf1=500           # faisceau côté droit
        xf2=-a*500+x1+a*y1 #faiseau côté gauche
        yf2=500            # faisceau côté gauche
        field1=drawzone.create_polygon(xf1, yf1, xf2, yf2, x1, y1, fill="yellow")
        point=drawzone.create_oval(x1-5,y1-5,x1+5,y1+5, fill="black")
        if x2<=xf1 and x2>=xf2 and y2<=yf2 and y2<=yf2 and y1<=y2 and detecte==0:
            print("detecte")
            detecte = 1 #Ceci évite de se faire flooder par les "detecte" ;D
 
 
    elif evt.keycode==39: #Garde se dirige vers la droite
        detecte=0
        droite=True
        gauche = False
        haut = False
        bas = False
        x1=x1+5
        xf1= 500 # faisceau bas
        yf1= a*500+y1-a*x1 # faisceau bas
        xf2= 500 # faisceau haut
        yf2= -a*500+y1+a*x1 #faisceau haut
        field3=drawzone.create_polygon(xf1, yf1, x1, y1, xf2, yf2, fill="yellow")
        point=drawzone.create_oval(x1-5,y1-5,x1+5,y1+5, fill="black")
        if x2>=xf1 and x2>=xf2 and y2<=yf1 and y2>=yf2 and detecte==0:
            detecte = 1
            print("detecte")
 
    elif evt.keycode==37: #Garde se dirige vers la gauche
        detecte=0
        gauche=True
        droite = False
        haut = False
        bas = False
        x1=x1-5
        xf1= 0       #faisceau haut
        yf1= y1-a*x1 #faisceau haut
        xf2= 0       #faisceau bas
        yf2= y1+a*x1 #faisceau bas
        field4=drawzone.create_polygon(xf1, yf1, x1, y1, xf2, yf2, fill="yellow")
        point=drawzone.create_oval(x1-5,y1-5,x1+5,y1+5, fill="black")
        if x2<=xf1 and x2<=xf2 and y2>=yf1 and y2<=yf2 & detecte==0:
            detecte = 1
            print("detecte")
    drawzone.tag_raise(player) #On remet le joueur en premier plan pour des raisons évidentes de visibilité.
 
 
#                               ***********
#                              FIN  DEPLACEMENT
#                               ***********
 
 
a= sqrt(3)/3 #Ceci est le coefficient de chaque droite qui compose le champ de vision, avec un angle de 60°
 
 
 
fen=Tk() # On installe la fenêtre
fen.geometry("500x500") #On donne ses dimensions
fen.bind("<Key>", deplacement) #On la lie à l'évènement clavier
 
drawzone=Canvas(height=500, width=500, bg="White") #On initie le canevas
drawzone.place(x=0,y=0)
 
point=drawzone.create_oval(245,245,255,255, fill="black") #On place le joueur
player=drawzone.create_oval(x2,y2,y2+10,y2+10, fill="blue") #On place le garde
fen.mainloop()

2 problèmes majeurs avec ce code !
Tout d'abord, quand on bouge une première fois, tout va bien, la console affiche comme prévu les deux aires attendues (la somme des aires des trois triangle, et l'aire du cône de vision).
Et quand on rebouge... Eh ben ça veut pas, et ça nous met une erreur "float object is not callable"
Wut.

Deuxième "wut":
L'aire a l'air (lol) de faire n'importe quoi, à savoir qu'elle ne donne absolument pas les résultats attendus. Je suis sans voix sur ce coup, je ne sais pas quoi faire.

08/03/2016, 10h06
wiztricks
Salut,

Citation:

Envoyé par e.Saad

Sauf que voilà, de nouveau, couille dans le pâté.
J'ai des erreurs de float, et surtout un résultat qui n'est pas, mais alors pas du tout ce que j'attendais..

Si vous écrivez:
Code:

1 2 3 4 5 6 7 tarea = 0 ... def tarea(x1,x2,y,y1): global tarea tbase = x1-x2 thauteur = y-y1 tarea = (tbase*thauteur)/2
vous avez oublié que Python vous laisse assigner ce que vous voulez à une variable: tarea est déclaré comme entier, puis fonction, puis écrasé par ce que devrait retourner la fonction....

Citation:

Envoyé par e.Saad

En étant logique, si jamais le point est à l'intérieur du triangle, alors la somme des aires des trois triangles définis par deux points du cône et le point est égale à l'aire totale du cône.

C'est une bonne idée. Ca pourrait se traduire par une fonction qui prenne triangle et point en paramètre pour retourner un booléen après avoir effectué les différents calculs d'aire.
La difficulté est d'arriver à traduire çà en Python. Mais c'est aussi tout l'intérêt de l'exercice: vous obliger à revoir variables, fonctions, listes, ... pour arriver à coder çà.

- W

Sujet clôturé !

Merci pour votre aide !

Mon programme de détection est terminé, et j'y ai même adjoint un garde bougeant tout seul, la possibilité de se déplacer, et une vérification de détection sonore !

Si vous voulez tester le jeu en pré-alpha ( ;D ):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
# -*- coding: utf-8 -*-
"""
Created on Thu Mar 10 12:39:25 2016
 
@author: esaadeddine1
"""
 
from tkinter import*
from math import*
from random import*
 
haut = False
bas = False
droite = False
gauche= False
 
 
 
boucledeplacement=0
boucledeplacement2=0
 
x1=100
y1=100
x2=300
y2=100
x3=300
y3=300
x4=100
y4=300
 
#Cette partie sert à déterminer les coordonnées d'origine du garde.
 
xgarde=650
ygarde=350
 
#Cette partie sert à déterminer les coordonnées d'origine du joueur.
 
xjoueur = 50
yjoueur = 50
 
a= sqrt(3)/3
 
 
fen=Tk()
largeurfenetre=fen.winfo_screenwidth()
hauteurfenetre=fen.winfo_screenheight()
fen.geometry(str(largeurfenetre-100)+"x"+str(hauteurfenetre-100))
 
drawzone=Canvas(height=hauteurfenetre-100, width=largeurfenetre-100, bg="White") #On initie le canevas
drawzone.place(x=0,y=0)
 
garde=drawzone.create_oval(xgarde-5,ygarde-5,xgarde+5,ygarde+5, fill="blue") #On place le joueur
joueur=drawzone.create_oval(xjoueur-5, xjoueur-5,yjoueur+5,yjoueur+5, fill="black") #On place le garde
 
xgarde=650
ygarde=350
 
building_r1_c1=drawzone.create_polygon(x1,y1,x2,y2,x3,y3,x4,y4, fill="black")
building_r1_c2=drawzone.create_polygon(x1+300,y1,x2+300,y2,x3+300,y3,x4+300,y4, fill="black")
building_r1_c3=drawzone.create_polygon(x1+600,y1,x2+600,y2,x3+600,y3,x4+600,y4, fill="black")
building_r1_c4=drawzone.create_polygon(x1+900,y1,x2+900,y2,x3+900,y3,x4+900,y4, fill="black")
 
building_r2_c1=drawzone.create_polygon(x1,y1+300,x2,y2+300,x3,y3+300,x4,y4+300, fill="black")
building_r2_c2=drawzone.create_polygon(x1+300,y1+300,x2+300,y2+300,x3+300,y3+300,x4+300,y4+300, fill="black")
building_r2_c3=drawzone.create_polygon(x1+600,y1+300,x2+600,y2+300,x3+600,y3+300,x4+600,y4+300, fill="black")
building_r2_c4=drawzone.create_polygon(x1+900,y1+300,x2+900,y2+300,x3+900,y3+300,x4+900,y4+300, fill="black")
 
 
field1=drawzone.create_polygon(0,0,0,0,0,0)
field2=drawzone.create_polygon(0,0,0,0,0,0)
field3=drawzone.create_polygon(0,0,0,0,0,0)
field4=drawzone.create_polygon(0,0,0,0,0,0)
 
 
 
def décor():
    balise=drawzone.create_oval(500,500,550,550, fill="green")
    building_r1_c1=drawzone.create_polygon(x1,y1,x2,y2,x3,y3,x4,y4, fill="black")
    building_r1_c2=drawzone.create_polygon(x1+300,y1,x2+300,y2,x3+300,y3,x4+300,y4, fill="black")
    building_r1_c3=drawzone.create_polygon(x1+600,y1,x2+600,y2,x3+600,y3,x4+600,y4, fill="black")
    building_r1_c4=drawzone.create_polygon(x1+900,y1,x2+900,y2,x3+900,y3,x4+900,y4, fill="black")
 
    building_r2_c1=drawzone.create_polygon(x1,y1+300,x2,y2+300,x3,y3+300,x4,y4+300, fill="black")
    building_r2_c2=drawzone.create_polygon(x1+300,y1+300,x2+300,y2+300,x3+300,y3+300,x4+300,y4+300, fill="black")
    building_r2_c3=drawzone.create_polygon(x1+600,y1+300,x2+600,y2+300,x3+600,y3+300,x4+600,y4+300, fill="black")
    building_r2_c4=drawzone.create_polygon(x1+900,y1+300,x2+900,y2+300,x3+900,y3+300,x4+900,y4+300, fill="black")
 
 
 
def deplacementjoueur(evt):
    global xjoueur
    global yjoueur
    global joueur
    drawzone.delete(ALL)
    garde=drawzone.create_oval(xgarde-5,ygarde-5,xgarde+5,ygarde+5, fill="blue")
    décor()
    if evt.keycode==87: # "W" = "Whistle" = "Siffler" : Bruit fort
        sonfort=drawzone.create_oval(xjoueur-120, yjoueur-120, xjoueur+120, yjoueur+120, fill="orange")
        joueur=drawzone.create_oval(xjoueur-5,yjoueur-5,xjoueur+5,yjoueur+5, fill="black")
        zoneaudition=drawzone.create_oval(xgarde-60, ygarde-60, xgarde+60, ygarde+60, fill="green")
        if sqrt((xgarde-xjoueur)**2+(yjoueur-ygarde)**2)<=180:
            zoneaudition=drawzone.create_oval(xgarde-60, ygarde-60, xgarde+60, ygarde+60, fill="red")
            sonfort=drawzone.create_oval(xjoueur-120, yjoueur-120, xjoueur+120, yjoueur+120, fill="red")
            joueur=drawzone.create_oval(xjoueur-5,yjoueur-5,xjoueur+5,yjoueur+5, fill="black")
    if evt.keycode==88: # "X" : Bruit léger
        sonleger=drawzone.create_oval(xjoueur-60, yjoueur-60, xjoueur+60, yjoueur+60, fill="yellow")
        joueur=drawzone.create_oval(xjoueur-5,yjoueur-5,xjoueur+5,yjoueur+5, fill="black")
        zoneaudition=drawzone.create_oval(xgarde-60, ygarde-60, xgarde+60, ygarde+60, fill="green")
        if sqrt((xjoueur-xgarde)**2+(yjoueur-ygarde)**2)<=120:
            zoneaudition=drawzone.create_oval(xgarde-60, ygarde-60, xgarde+60, ygarde+60, fill="red")
            sonleger=drawzone.create_oval(xjoueur-60, yjoueur-60, xjoueur+60, yjoueur+60, fill="red")
    if evt.keycode==38:
        yjoueur=yjoueur-5 #HAUT
        joueur=drawzone.create_oval(xjoueur-5,yjoueur-5,xjoueur+5,yjoueur+5, fill="black")
    elif evt.keycode==40: #BAS
        yjoueur=yjoueur+5
        joueur=drawzone.create_oval(xjoueur-5,yjoueur-5,xjoueur+5,yjoueur+5, fill="black")
    elif evt.keycode==39: #DROITE
        xjoueur=xjoueur+5
        joueur=drawzone.create_oval(xjoueur-5,yjoueur-5,xjoueur+5,yjoueur+5, fill="black")
    elif evt.keycode==37: #GAUCHE
        xjoueur=xjoueur-5
        joueur=drawzone.create_oval(xjoueur-5,yjoueur-5,xjoueur+5,yjoueur+5, fill="black")
    garde=drawzone.create_oval(xgarde-5,ygarde-5,xgarde+5,ygarde+5,fill="blue")
 
def orientation():
    global haut
    global bas
    global gauche
    global droite
    direction=randint(1,4)
    haut = False
    bas = False
    droite = False
    gauche= False
    if direction==1:
        haut=True
    elif direction==2:
        bas=True
    elif direction==3:
        gauche=True
    elif direction==4:
        droite=True
    print(direction)
 
def trianglearea(x,x1,x2,y,y1,y2):
    global tarea
    cote1=sqrt((x-x1)**2+(y-y1)**2)
    cote2=sqrt((x1-x2)**2+(y1-y2)**2)
    cote3=sqrt((x-x2)**2+(y-y2)**2)
    p=(cote1+cote2+cote3)/2
    tarea= sqrt(p*(p-cote1)*(p-cote2)*(p-cote3))
 
def areas(x,x1,x2,x3,y,y1,y2,y3):
    global totalarea
    cote1_1=sqrt((x-x1)**2+(y-y1)**2)
    cote2_1=sqrt((x1-x2)**2+(y1-y2)**2)
    cote3_1=sqrt((x-x2)**2+(y-y2)**2)
    p1=(cote3_1+cote2_1+cote1_1)/2
    area1= sqrt(p1*(p1-cote1_1)*(p1-cote2_1)*(p1-cote3_1))
 
    cote1_2=sqrt((x-x2)**2+(y-y2)**2)
    cote2_2=sqrt((x2-x3)**2+(y2-y3)**2)
    cote3_2=sqrt((x-x3)**2+(y-y3)**2)
    p2=(cote3_2+cote2_2+cote1_2)/2
    area2= sqrt(p2*(p2-cote1_2)*(p2-cote2_2)*(p2-cote3_2))
 
    cote1_3=sqrt((x-x1)**2+(y-y1)**2)
    cote2_3=sqrt((x1-x3)**2+(y1-y3)**2)
    cote3_3=sqrt((x-x3)**2+(y-y3)**2)
    p3=(cote3_3+cote2_3+cote1_3)/2
    area3= sqrt(p3*(p3-cote1_3)*(p3-cote2_3)*(p3-cote3_3))
 
    totalarea=area3+area2+area1
 
 
def deplacement():
    global xgarde
    global ygarde
    global garde
    global droite
    global gauche
    global bas
    global haut
    global field1
    global field2
    global field3
    global field4
    drawzone.delete(ALL)
    décor()
    joueur=drawzone.create_oval(xjoueur-5,yjoueur-5,xjoueur+5,yjoueur+5, fill="black")
    if (((xgarde==350) or(xgarde==650 )or(xgarde==950 ) or (xgarde==50) or (xgarde==1350)) and ygarde==350) or (((xgarde==350) or(xgarde==650 )or(xgarde==950 ) or (xgarde==50) or (xgarde==1350)) and ygarde==50) or (((xgarde==350) or(xgarde==650 )or(xgarde==950 ) or (xgarde==50) or (xgarde==1350)) and ygarde==650):
        orientation()
        if haut==True:
            ygarde=ygarde-10
            xf1=xgarde-a*ygarde #Coordonnées en x du premier point du champ de vision
            yf1=0 #Cordonnées en y du premier point du champ de vision
            xf2=xgarde+a*ygarde #Coordonnées en x du second point du champ de vision
            yf2=0 #Coordonnées en y du second point du champ de vision
 
#On recrée le champ de vision
            field2=drawzone.create_polygon(xf1, yf1,xf2, yf1, xgarde, ygarde, fill="yellow")
 
#On recrée le garde (après le champ de vision pour ne pas que celui-ci ne l'efface partiellement)
            garde=drawzone.create_oval(xgarde-5,ygarde-5,xgarde+5,ygarde+5, fill="blue")
 
            trianglearea (xgarde,xf1,xf2,ygarde,yf1,yf2)
            areas (xjoueur,xgarde,xf1,xf2,yjoueur,ygarde,yf1,yf2)
            if int(tarea)==int(totalarea):
                print("Détecté !")
        elif bas==True:
            ygarde=ygarde+10
            xf1=a*(hauteurfenetre-100)+xgarde-a*ygarde #faisceau côté droit
            yf1=hauteurfenetre-100           # faisceau côté droit
            xf2=-a*(hauteurfenetre-100)+xgarde+a*ygarde #faiseau côté gauche
            yf2=hauteurfenetre-100            # faisceau côté gauche
            field1=drawzone.create_polygon(xf1, yf1, xf2, yf2, xgarde, ygarde, fill="yellow")
            garde=drawzone.create_oval(xgarde-5,ygarde-5,xgarde+5,ygarde+5, fill="blue")
            trianglearea (xgarde,xf1,xf2,ygarde,yf1,yf2)
            areas (xjoueur,xgarde,xf1,xf2,yjoueur,ygarde,yf1,yf2)
            if int(tarea)==int(totalarea):
                print("Détecté !")
 
        elif gauche==True:
            xgarde=xgarde-10
            xf1= 0       #faisceau haut
            yf1= ygarde-a*xgarde #faisceau haut
            xf2= 0       #faisceau bas
            yf2= ygarde+a*xgarde #faisceau bas
            field4=drawzone.create_polygon(xf1, yf1, xgarde, ygarde, xf2, yf2, fill="yellow")
            garde=drawzone.create_oval(xgarde-5,ygarde-5,xgarde+5,ygarde+5, fill="blue")
            trianglearea (xgarde,xf1,xf2,ygarde,yf1,yf2)
            areas (xjoueur,xgarde,xf1,xf2,yjoueur,ygarde,yf1,yf2)
            if int(tarea)==int(totalarea):
                print("Détecté !")
        elif droite==True:
            xgarde=xgarde+10
            xf1= largeurfenetre-100 # faisceau bas
            yf1= a*(largeurfenetre-100)+ygarde-a*xgarde # faisceau bas
            xf2= largeurfenetre-100 # faisceau haut
            yf2= -a*(largeurfenetre-100)+ygarde+a*xgarde #faisceau haut
            field3=drawzone.create_polygon(xf1, yf1, xgarde, ygarde, xf2, yf2, fill="yellow")
            garde=drawzone.create_oval(xgarde-5,ygarde-5,xgarde+5,ygarde+5, fill="blue")
            trianglearea (xgarde,xf1,xf2,ygarde,yf1,yf2)
            areas (xjoueur,xgarde,xf1,xf2,yjoueur,ygarde,yf1,yf2)
            if int(tarea)==int(totalarea):
                print("Détecté !")
    elif xgarde<=0:
        gauche=False
        droite=True
        haut=False
        bas=False
    elif xgarde>=largeurfenetre-100:
        droite=False
        bas=False
        haut=False
        gauche=True
    elif ygarde<=0:
        droite=False
        haut=False
        gauche=False
        bas=True
    elif ygarde>=hauteurfenetre-100:
        droite=False
        gauche=False
        bas=False
        haut=True
    elif haut==True:
        ygarde=ygarde-10
        xf1=xgarde-a*ygarde #Coordonnées en x du premier point du champ de vision
        yf1=0 #Cordonnées en y du premier point du champ de vision
        xf2=xgarde+a*ygarde #Coordonnées en x du second point du champ de vision
        yf2=0 #Coordonnées en y du second point du champ de vision
 
#On recrée le champ de vision
        field2=drawzone.create_polygon(xf1, yf1,xf2, yf1, xgarde, ygarde, fill="yellow")
 
#On recrée le garde (après le champ de vision pour ne pas que celui-ci ne l'efface partiellement)
        garde=drawzone.create_oval(xgarde-5,ygarde-5,xgarde+5,ygarde+5, fill="blue")
 
        trianglearea (xgarde,xf1,xf2,ygarde,yf1,yf2)
        areas (xjoueur,xgarde,xf1,xf2,yjoueur,ygarde,yf1,yf2)
        if int(tarea)==int(totalarea):
            print("Détecté !")
    elif bas==True:
        ygarde=ygarde+10
        xf1=a*(hauteurfenetre-100)+xgarde-a*ygarde #faisceau côté droit
        yf1=hauteurfenetre-100           # faisceau côté droit
        xf2=-a*(hauteurfenetre-100)+xgarde+a*ygarde #faiseau côté gauche
        yf2=hauteurfenetre-100            # faisceau côté gauche
        field1=drawzone.create_polygon(xf1, yf1, xf2, yf2, xgarde, ygarde, fill="yellow")
        garde=drawzone.create_oval(xgarde-5,ygarde-5,xgarde+5,ygarde+5, fill="blue")
        trianglearea (xgarde,xf1,xf2,ygarde,yf1,yf2)
        areas (xjoueur,xgarde,xf1,xf2,yjoueur,ygarde,yf1,yf2)
        if int(tarea)==int(totalarea):
            print("Détecté !")
 
    elif gauche==True:
        xgarde=xgarde-10
        xf1= 0       #faisceau haut
        yf1= ygarde-a*xgarde #faisceau haut
        xf2= 0       #faisceau bas
        yf2= ygarde+a*xgarde #faisceau bas
        field4=drawzone.create_polygon(xf1, yf1, xgarde, ygarde, xf2, yf2, fill="yellow")
        garde=drawzone.create_oval(xgarde-5,ygarde-5,xgarde+5,ygarde+5, fill="blue")
        trianglearea (xgarde,xf1,xf2,ygarde,yf1,yf2)
        areas (xjoueur,xgarde,xf1,xf2,yjoueur,ygarde,yf1,yf2)
        if int(tarea)==int(totalarea):
            print("Détecté !")
    elif droite==True:
        xgarde=xgarde+10
        xf1= largeurfenetre-100 # faisceau bas
        yf1= a*(largeurfenetre-100)+ygarde-a*xgarde # faisceau bas
        xf2= largeurfenetre-100 # faisceau haut
        yf2= -a*(largeurfenetre-100)+ygarde+a*xgarde #faisceau haut
        field3=drawzone.create_polygon(xf1, yf1, xgarde, ygarde, xf2, yf2, fill="yellow")
        garde=drawzone.create_oval(xgarde-5,ygarde-5,xgarde+5,ygarde+5, fill="blue")
        trianglearea (xgarde,xf1,xf2,ygarde,yf1,yf2)
        areas (xjoueur,xgarde,xf1,xf2,yjoueur,ygarde,yf1,yf2)
        if int(tarea)==int(totalarea):
            print("Détecté !")
    fen.after(100, deplacement)
 
fen.bind("<Key>", deplacementjoueur) #On la lie à l'évènement clavier
 
deplacement()
 
fen.mainloop()

Z/Q/S/D pour se déplacer
W pour siffler (bruit fort)
X pour claquement de doigts (bruit faible)