Jeu de labyrinthe - Animation d'une balle.

**FatP0ney** · 09/04/2014, 20h42

Bonjour ,
Après avoir sollicité votre aide il y a quelques jours déjà je me re-manifeste pour la création d'un jeu en python.
Mon projet est de créer un labyrinthe dans lequel se déplace une balle contrôlée à l'aide de boutons.
Pour cela j'ai déjà fait le gros du travail en créant le canvas, les limites du parcours, les fonctions dédiées au déplacement ect.
Néanmoins mon code concernant les fonctions de déplacement et les limites du parcours sont deux fichiers à part.
Mon problème est le suivant :
J'essaie de mettre en relation les deux de manière à ce que les limites du parcours soient en activité sur le labyrinthe et que lorsque le code dédié au déplacement renvoie False , le jeu s’arrête et renvoie la boule aux coordonnées de départ.

Voici le code concernant le mouvement de la boule :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
 
from Tkinter import *
from random import randrange
from partie1_coord_droite_finie import est_dans_polygone
# procédure générale de déplacement :
def move():
    global dep, sx, sy
     if est_dans_polygone = False :
      command=pause
    can1.move(cerc1, sx*dep, sy*dep)
    can1.after(100, move)
# gestionnaires d'évènements:
def dep1_gauche(event):
    global sx, sy
    sx = -1
    sy = 0
 
def dep1_droite(event):
    global sx, sy
    sx = 1
    sy = 0
 
def dep1_haut(event):
    global sy, sx
    sy = -1 
    sx = 0 
 
def dep1_bas(event):
    global sy, sx  
    sy = 1 
    sx = 0
 
def start_it():
    "démarrage de l'animation"
    global flag
    flag = not flag
    move()
 
def pause() :
    #nous servira quand on touchera le mur
     "arret de l'animation"
     global flag    
     flag =0
 
 
# Programme principal
 
# les variables suivantes seront utilisées de manière globale:
dep = 5   # valeur de deplacement
x_cerc, y_cerc = 70, 81 #coordonnées initiales
sx, sy = 1, 0
dim = 10
flag =0   #commutateur
 
# Création du widget principal ("maître"):
fen1 = Tk()
fen1.title("Super Ball")
 
# création des widgets "esclaves":
can1 = Canvas (fen1, bg='white', height=500, width=500)
cerc1 = can1.create_oval(x_cerc, y_cerc, x_cerc + dim, y_cerc + dim,fill = 'grey')
can1.pack(side=LEFT)
can1.create_rectangle(50,50,100,100) #dessine un rectangle
can1.create_rectangle(120,280,170,335)
polygone1 = [100,65,420,65], [100,85,400,85]
can1.create_line(tuple(polygone1[0]),fill='red',width=4)#ligne 1
can1.create_line(tuple(polygone1[1]),fill='red',width=4)#ligne 2
can1.create_line(400,84,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 5
Button(fen1, text='Démarrer', command=start_it).pack(side=BOTTOM)
Button(fen1, text='Quitter', command=fen1.destroy).pack(side=BOTTOM)
Button(fen1, text='Gauche',command=dep1_gauche).pack()
Button(fen1, text='Droite', command=dep1_droite).pack()
Button(fen1, text='Haut', command=dep1_haut).pack()
Button(fen1, text='Bas', command=dep1_bas).pack()
Button(fen1, text='Accélère!', command=start_it).pack(side=BOTTOM)
can1.bind("<z>", dep1_haut)
can1.bind("<s>", dep1_bas)
can1.bind("<d>", dep1_droite)
can1.bind("<q>", dep1_gauche)
 
 
# démarrage du réceptionnaire d'évènements (boucle principale):
fen1.mainloop()

Mon souci se situe notemment dans les premières lignes du code ou je ne vois pas quoi changer :

Code :

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

1
2
3
4
5
6
 
 
def move():
    global dep, sx, sy
     if est_dans_polygone = False :
      command=pause

Merci de votre aide!J'espère avoir été relativement clair

Un débutant.

**VinsS** · 10/04/2014, 07h11

Salut,

Tu ne nous dis pas ce que est "est_dans_polygone" mais on peut supposer qu'il s'agit d'une fonction.

Donc il faut l'appeler, non ?

Elle n'a pas besoin d'arguments cette fonction ?

**FatP0ney** · 10/04/2014, 09h10

Effectivement est_dans_polygone est bien une fonction qui permet de savoir si la balle est bien dans les limites.
Voila son 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
 
 
def est_dans_polygone(XY,r, Droite1, Droite2):
 
    Droite3 = [Droite1[0], Droite1[1], Droite2[0], Droite2[1]]
 
    Droite4 = [Droite1[2], Droite1[3], Droite2[2], Droite2[3]]
 
    est_dans_poly1 = est_en_dessous([XY[0], XY[1] - r], Droite2) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite1) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite3) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite4)
 
 
    est_dans_poly2 = est_en_dessous([XY[0], XY[1] - r], Droite1) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite2) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite4) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite3)
 
 
    est_dans_poly3 = est_en_dessous([XY[0], XY[1] - r], Droite3) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite4) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite2) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite1)
 
 
    est_dans_poly4 = est_en_dessous([XY[0], XY[1] - r], Droite3) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite4) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite1) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite2)  
 
 
    est_dans_poly5 = est_en_dessous([XY[0], XY[1] - r], Droite4) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite3) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite2) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite1)
 
 
    est_dans_poly6 = est_en_dessous([XY[0], XY[1] - r], Droite4) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite3) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite1) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite2)
 
 
 
    return est_dans_poly1 or est_dans_poly2 or est_dans_poly3 or est_dans_poly4 or est_dans_poly5 or est_dans_poly6

Désolé mais en grand débutant je ne sais pas trop ce qu'est un argument :S

Merci de votre aide

**VinsS** · 10/04/2014, 09h27

Les arguments sont les données passées à la fonction, ici (XY,r, Droite1, Droite2).

Donc tu dois appeler ta fonction en lui passant ce qu'elle attend:

Code :

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

1
2
     if est_dans_polygone(ici les quatre valeurs) = False :

Question: xy sont les coordonnées de la balle et r est son rayon ?

**VinsS** · 10/04/2014, 09h56

Comprend pas trop ton histoire de polygones, si je suis bien, Droite1 et Droite2 sont deux droites parallèles et tu construis Droite3 et Droite4 avec les coordonnées de départ de l'une et d'arrivée de l'autre.

Testons un exemple:

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
          Droite2
        -----------
        |          |
        |          |
Droite3 |          | Droite4
        |          |
        |          |
        -----------
          Droite1

Dans cette fonction, la balle peut être sous Droite2, sur Droite1, à droite de droite3 et à gauche de Droite 4 
    est_dans_poly1 = est_en_dessous([XY[0], XY[1] - r], Droite2) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite1) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite3) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite4)

Dans celle-ci il est impossibe que la balle soit sous Droite1 et sur Droite2 et impossible qu'elle soit
à gauche de Droite3 et à droite de Droite4
    est_dans_poly2 = est_en_dessous([XY[0], XY[1] - r], Droite1) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite2) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite4) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite3)

Devrait pouvoir être simplifié tout ça ...

**FatP0ney** · 10/04/2014, 19h25

En fait ce que j'essaie de faire est de limiter mon parcours en utilisant tous les cas possibles de polygones que je rencontrerais.
Nous avons essayé ( moi et les personnes avec qui je travaille) de faire quelques chose de général qui pourrais s’adapter à tous les cas de figures au cas ou nous pourrions par la suite générer des parcours aléatoirement ce qui explique pourquoi le code est un peu complexe...

Je n'ai pas trop traité cette partie du code mais je crois bien que tu as raison en disant que Droite1 et Droite2 sont deux droites parallèles et que l'on construit Droite3 et Droite4 avec les coordonnées de départ de l'une et d'arrivée de l'autre.

A propos des arguments (ce qui relève plus du travail dont je dois m'occuper) je ne comprends pas trop ce qui cloche... même si je les rajoutes j'obtiens toujours la même erreur : "unexpected ident" (située au niveau du if est_dans_polygone...) et je ne comprends pas à quelle élément de la ligne elle fait référence...

Code :

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

1
2
3
4
5
 
def move():
    global dep, sx, sy
     if est_dans_polygone(XY,r, Droite1, Droite2) = False :
      command=pause

Merci de ton aide

Ps : j'avais laissé mes amis aidés de mon professeur traiter la partie du code sur les limites des polygones et je ne comprends pas très bien à quoi correspondent les chiffres entre crochets :/ pourrais tu m'éclairer sur ce point?

exemple :

Code :

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

1
2
 
est_en_dessous([XY[0], XY[1] - r], Droite2)

**VinsS** · 10/04/2014, 21h20

Si ton code est exactement comme reproduit, c'est normal.

Il faut impérativement respecter les indentations.

Si tu as choisis une indentation de quatre espaces, alors tu devrais avoir ceci:

Code :

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

1
2
3
4
5
 
def move():
    global dep, sx, sy      # 4 espaces, OK
    if est_dans_polygone(XY,r, Droite1, Droite2) = False:   # 4 espaces et pas 5 !
        command=pause       # 8 espaces et pas 6 !

Pour les arguments entre crochets, non je ne sais pas vraiment, l'exemple dans mon post précédent je l'ai sucé de mon pouce, mais je dirai que XY représente les coordonnées du centre de la balle et r est le rayon,
donc X - r = le coté gauche de la balle, Y - r son coté supérieur et ainsi de suite.

**FatP0ney** · 10/04/2014, 21h42

J'ai modifié mon code de manière à ce qu'il respecte les identations et qu'il reprenne les arguments voulus.
J'ai également changé les données dans la suite du code de manière à ce qu'elles soient les mêmes dans les deux fichiers ce qui posait peut etre problème...
Je conserve néanmoins une erreur (même si elle a changé) toujours au niveau de cette même ligne.

Je poste les codes entiers des deux parties ca sera peut être plus facile pour comprendre

Limites du polygone :

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
 
 
r = 10          # Dimension du cercle
 
 
def est_au_dessus(XY,Droite):
 
    x, y = tuple(XY)
 
    xA, yA, xB, yB = tuple(Droite)
    # Le point ne peut être au dessus d'une droite verticale
    if xB == xA:
        return False
    a= (yB-yA)/(xB-xA)
 
    b= yA-a*xA
 
    valeur_a_retourner = y<a*x+b
 
    return valeur_a_retourner
 
 
 
def est_en_dessous(XY,Droite):
 
    x, y = tuple(XY)
 
    xC, yC, xD, yD = tuple(Droite)
    if xC == xD:
        return False
         # Le point ne peut être au dessous d'une droite verticale
    a= (yD-yC)/(xD-xC)
 
    b= yC-a*xC
 
    valeur_a_retourner = y>a*x+b
 
    return valeur_a_retourner
 
 
 
 
 
def est_a_gauche(XY,Droite):
 
    x, y = tuple(XY)
 
    xA, yA, xC, yC = tuple(Droite)
    if yA == yC:
        return False
        # Le point ne peut être à gauche d'une droite horizontale
 
    a= (xC-xA)/(yC-yA)
 
    b= xA-a*yA
 
    valeur_a_retourner=x<a*y+b
 
    return valeur_a_retourner
 
 
 
def est_a_droite(XY,Droite):
 
    x, y = tuple(XY)
 
    xB, yB, xD, yD = tuple(Droite)
    if yB == yD:
        return False
       #Le point ne peut être à droite d'une droite horizontale
    a= (xD-xB)/(yD-yB)
 
    b= xB-a*yB
 
    valeur_a_retourner=x>a*y+b
 
    return valeur_a_retourner    
 
 
 
def est_dans_polygone(XY,r, Droite1, Droite2):
 
    Droite3 = [Droite1[0], Droite1[1], Droite2[0], Droite2[1]]
 
    Droite4 = [Droite1[2], Droite1[3], Droite2[2], Droite2[3]]
 
    est_dans_poly1 = est_en_dessous([XY[0], XY[1] - r], Droite2) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite1) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite3) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite4)
 
 
    est_dans_poly2 = est_en_dessous([XY[0], XY[1] - r], Droite1) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite2) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite4) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite3)
 
 
    est_dans_poly3 = est_en_dessous([XY[0], XY[1] - r], Droite3) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite4) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite2) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite1)
 
 
    est_dans_poly4 = est_en_dessous([XY[0], XY[1] - r], Droite3) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite4) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite1) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite2)  
 
 
    est_dans_poly5 = est_en_dessous([XY[0], XY[1] - r], Droite4) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite3) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite2) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite1)
 
 
    est_dans_poly6 = est_en_dessous([XY[0], XY[1] - r], Droite4) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite3) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite1) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite2)
 
 
 
    return est_dans_poly1 or est_dans_poly2 or est_dans_poly3 or est_dans_poly4 or est_dans_poly5 or est_dans_poly6
 
 
 
 
# Code:
 
#######
 
print(est_dans_polygone([3,0], 0.2, [2,5,3,3], [1,-1,5,-1]))

Code du déplacement :

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
 
from Tkinter import *
from random import randrange
from partie1_coord_droite_finie import est_dans_polygone
# procédure générale de déplacement :
def move():
    global dep, sx, sy
    if est_dans_polygone(XY,r, Droite1, Droite2) = False :
       command=pause
    can1.move(cerc1, sx*dep, sy*dep)
    can1.after(100, move)
# gestionnaires d'évènements:
def dep1_gauche(event):
    global sx, sy
    sx = -1
    sy = 0
 
def dep1_droite(event):
    global sx, sy
    sx = 1
    sy = 0
 
def dep1_haut(event):
    global sy, sx
    sy = -1 
    sx = 0 
 
def dep1_bas(event):
    global sy, sx  
    sy = 1 
    sx = 0
 
def start_it():
    "démarrage de l'animation"
    global flag
    flag = not flag
    move()
 
def pause() :
    #nous servira quand on touchera le mur
     "arret de l'animation"
     global flag    
     flag =0
 
 
# Programme principal
 
# les variables suivantes seront utilisées de manière globale:
dep = 5   # valeur de deplacement
X, Y = 70, 81 #coordonnées initiales
sx, sy = 1, 0
r = 10
flag =0   #commutateur
 
# Création du widget principal ("maître"):
fen1 = Tk()
fen1.title("Super Ball")
 
# création des widgets "esclaves":
can1 = Canvas (fen1, bg='white', height=500, width=500)
cerc1 = can1.create_oval(X, Y, X + r, Y + r,fill = 'grey')
can1.pack(side=LEFT)
can1.create_rectangle(50,50,100,100) #dessine un rectangle
can1.create_rectangle(120,280,170,335)
polygone1 = [100,65,420,65], [100,85,400,85]
can1.create_line(tuple(polygone1[0]),fill='red',width=4)#ligne 1
can1.create_line(tuple(polygone1[1]),fill='red',width=4)#ligne 2
can1.create_line(400,84,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 5
Button(fen1, text='Démarrer', command=start_it).pack(side=BOTTOM)
Button(fen1, text='Quitter', command=fen1.destroy).pack(side=BOTTOM)
Button(fen1, text='Gauche',command=dep1_gauche).pack()
Button(fen1, text='Droite', command=dep1_droite).pack()
Button(fen1, text='Haut', command=dep1_haut).pack()
Button(fen1, text='Bas', command=dep1_bas).pack()
Button(fen1, text='Accélère!', command=start_it).pack(side=BOTTOM)
can1.bind("<z>", dep1_haut)
can1.bind("<s>", dep1_bas)
can1.bind("<d>", dep1_droite)
can1.bind("<q>", dep1_gauche)
 
 
# démarrage du réceptionnaire d'évènements (boucle principale):
fen1.mainloop()

**VinsS** · 11/04/2014, 07h35

Quelle erreur, quelle ligne ?

Copie-colle le traceback d'erreur complet, qu'on puisse voir ça.

**FatP0ney** · 11/04/2014, 19h31

L'erreur se situe sur cette ligne la :

"if est_dans_polygone(XY,r, Droite1, Droite2) = False :"

elle est symbolisée par un attention entouré de rouge avec : "invalid syntax"

**wiztricks** · 11/04/2014, 20h10

Salut,
il ne faut pas se laisser impressionner:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
>>> def f(): pass
...
>>> if f() = True:
  File "<stdin>", line 1
    if f() = True:
           ^
SyntaxError: invalid syntax
>>> if f() == True:
...    pass
...
>>>

'=' : assignation
'==' : comparaison

Et çà pète car après 'if', çà attend une expression
- W

**FatP0ney** · 11/04/2014, 20h36

Salut excuses moi mais en très grand débutant je n'ai pas trop compris ce que tu as fait dans ton code?
Merci

Ps : est_dans_polygone n'est elle pas censée en être une ?

**wiztricks** · 11/04/2014, 20h54

Envoyé par FatP0ney

Salut excuses moi mais en très grand débutant je n'ai pas trop compris ce que tu as fait dans ton code?

Ne pas discerner la différence entre '==' et '=', c'est un problème de vue.
Et çà je n'y peux rien.
- W

**FatP0ney** · 11/04/2014, 20h59

Dac non je que je voulais dire c'est que je n'avais pas compris que tu avais testé l'importance du "=" et du "=="
Merci

Invité · 15/04/2014, 08h46

Envoyé par FatP0ney

J'ai modifié mon code de manière à ce qu'il respecte les identations et qu'il reprenne les arguments voulus.
J'ai également changé les données dans la suite du code de manière à ce qu'elles soient les mêmes dans les deux fichiers ce qui posait peut etre problème...
Je conserve néanmoins une erreur (même si elle a changé) toujours au niveau de cette même ligne.

Je poste les codes entiers des deux parties ca sera peut être plus facile pour comprendre

Limites du polygone :

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
 
 
r = 10          # Dimension du cercle
 
 
def est_au_dessus(XY,Droite):
 
    x, y = tuple(XY)
 
    xA, yA, xB, yB = tuple(Droite)
    # Le point ne peut être au dessus d'une droite verticale
    if xB == xA:
        return False
    a= (yB-yA)/(xB-xA)
 
    b= yA-a*xA
 
    valeur_a_retourner = y<a*x+b
 
    return valeur_a_retourner
 
 
 
def est_en_dessous(XY,Droite):
 
    x, y = tuple(XY)
 
    xC, yC, xD, yD = tuple(Droite)
    if xC == xD:
        return False
         # Le point ne peut être au dessous d'une droite verticale
    a= (yD-yC)/(xD-xC)
 
    b= yC-a*xC
 
    valeur_a_retourner = y>a*x+b
 
    return valeur_a_retourner
 
 
 
 
 
def est_a_gauche(XY,Droite):
 
    x, y = tuple(XY)
 
    xA, yA, xC, yC = tuple(Droite)
    if yA == yC:
        return False
        # Le point ne peut être à gauche d'une droite horizontale
 
    a= (xC-xA)/(yC-yA)
 
    b= xA-a*yA
 
    valeur_a_retourner=x<a*y+b
 
    return valeur_a_retourner
 
 
 
def est_a_droite(XY,Droite):
 
    x, y = tuple(XY)
 
    xB, yB, xD, yD = tuple(Droite)
    if yB == yD:
        return False
       #Le point ne peut être à droite d'une droite horizontale
    a= (xD-xB)/(yD-yB)
 
    b= xB-a*yB
 
    valeur_a_retourner=x>a*y+b
 
    return valeur_a_retourner    
 
 
 
def est_dans_polygone(XY,r, Droite1, Droite2):
 
    Droite3 = [Droite1[0], Droite1[1], Droite2[0], Droite2[1]]
 
    Droite4 = [Droite1[2], Droite1[3], Droite2[2], Droite2[3]]
 
    est_dans_poly1 = est_en_dessous([XY[0], XY[1] - r], Droite2) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite1) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite3) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite4)
 
 
    est_dans_poly2 = est_en_dessous([XY[0], XY[1] - r], Droite1) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite2) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite4) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite3)
 
 
    est_dans_poly3 = est_en_dessous([XY[0], XY[1] - r], Droite3) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite4) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite2) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite1)
 
 
    est_dans_poly4 = est_en_dessous([XY[0], XY[1] - r], Droite3) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite4) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite1) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite2)  
 
 
    est_dans_poly5 = est_en_dessous([XY[0], XY[1] - r], Droite4) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite3) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite2) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite1)
 
 
    est_dans_poly6 = est_en_dessous([XY[0], XY[1] - r], Droite4) and \
                     est_au_dessus([XY[0],XY[1] + r], Droite3) and \
                     est_a_droite([XY[0] - r,XY[1]], Droite1) and \
                     est_a_gauche([XY[0] + r,XY[1]], Droite2)
 
 
 
    return est_dans_poly1 or est_dans_poly2 or est_dans_poly3 or est_dans_poly4 or est_dans_poly5 or est_dans_poly6
 
 
 
 
# Code:
 
#######
 
print(est_dans_polygone([3,0], 0.2, [2,5,3,3], [1,-1,5,-1]))

Code du déplacement :

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
 
from Tkinter import *
from random import randrange
from partie1_coord_droite_finie import est_dans_polygone
# procédure générale de déplacement :
def move():
    global dep, sx, sy
    if est_dans_polygone(XY,r, Droite1, Droite2) = False :
       command=pause
    can1.move(cerc1, sx*dep, sy*dep)
    can1.after(100, move)
# gestionnaires d'évènements:
def dep1_gauche(event):
    global sx, sy
    sx = -1
    sy = 0
 
def dep1_droite(event):
    global sx, sy
    sx = 1
    sy = 0
 
def dep1_haut(event):
    global sy, sx
    sy = -1 
    sx = 0 
 
def dep1_bas(event):
    global sy, sx  
    sy = 1 
    sx = 0
 
def start_it():
    "démarrage de l'animation"
    global flag
    flag = not flag
    move()
 
def pause() :
    #nous servira quand on touchera le mur
     "arret de l'animation"
     global flag    
     flag =0
 
 
# Programme principal
 
# les variables suivantes seront utilisées de manière globale:
dep = 5   # valeur de deplacement
X, Y = 70, 81 #coordonnées initiales
sx, sy = 1, 0
r = 10
flag =0   #commutateur
 
# Création du widget principal ("maître"):
fen1 = Tk()
fen1.title("Super Ball")
 
# création des widgets "esclaves":
can1 = Canvas (fen1, bg='white', height=500, width=500)
cerc1 = can1.create_oval(X, Y, X + r, Y + r,fill = 'grey')
can1.pack(side=LEFT)
can1.create_rectangle(50,50,100,100) #dessine un rectangle
can1.create_rectangle(120,280,170,335)
polygone1 = [100,65,420,65], [100,85,400,85]
can1.create_line(tuple(polygone1[0]),fill='red',width=4)#ligne 1
can1.create_line(tuple(polygone1[1]),fill='red',width=4)#ligne 2
can1.create_line(400,84,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 5
Button(fen1, text='Démarrer', command=start_it).pack(side=BOTTOM)
Button(fen1, text='Quitter', command=fen1.destroy).pack(side=BOTTOM)
Button(fen1, text='Gauche',command=dep1_gauche).pack()
Button(fen1, text='Droite', command=dep1_droite).pack()
Button(fen1, text='Haut', command=dep1_haut).pack()
Button(fen1, text='Bas', command=dep1_bas).pack()
Button(fen1, text='Accélère!', command=start_it).pack(side=BOTTOM)
can1.bind("<z>", dep1_haut)
can1.bind("<s>", dep1_bas)
can1.bind("<d>", dep1_droite)
can1.bind("<q>", dep1_gauche)
 
 
# démarrage du réceptionnaire d'évènements (boucle principale):
fen1.mainloop()

Bonjour,

Moi, j'ai une question qui me taraude : comment allez-vous déterminer le "polygone" ? à partir de quoi ? une méthode de canvas ? un tableau de vecteurs ? quoi ?

@+

**FatP0ney** · 17/04/2014, 13h20

Salut j'ai fait un petit dessin sur paint pour essayer de représenter les polygones:

Nom : polygones.png
Affichages : 1444
Taille : 7,5 Ko

Malgrès vos explications je suis encore un peu perdu je ne comprends pas comment utiliser mon code des polygones dans le code du mouvement :/ serait il possible d'avoir quelques explications suplémentaires?
Merci d'avance

Invité · 17/04/2014, 17h24

Envoyé par FatP0ney

Salut j'ai fait un petit dessin sur paint pour essayer de représenter les polygones:

Nom : polygones.png
Affichages : 1444
Taille : 7,5 Ko

Malgrès vos explications je suis encore un peu perdu je ne comprends pas comment utiliser mon code des polygones dans le code du mouvement :/ serait il possible d'avoir quelques explications suplémentaires?
Merci d'avance

Bonjour,

Non mais ça je l'avais compris

Ce que je voulais vous pousser à me dire, c'était : le but du jeu est de maintenir la balle sur les rails, il faudra donc détecter les rails autour de la balle quel que soit le contexte.

Je reformule donc ma question : comment allez-vous détecter les rails autour de la balle et quand devriez-vous faire cette détection ?

Comprenez bien que je connais la réponse mais que je vous pousse à "penser" le déroulement de votre programme.

**FatP0ney** · 17/04/2014, 18h25

Si j'ai bien compris ce que mes amis avaient fait il faudrait faire une sorte de test à chaque fois que la balle avance du "pas" voulu.
Il faudrait donc utiliser le test qui est fait à la fin du fichier partie-1-coord-droite-finie (que j'ai posté si je ne me trompe pas) afin que si il revoit Faux (c'est à dire qu'on est en dehors des limites d'un polygone) que la boule revienne à sa place initiale.
Est ce bien cela?

Je vais essayer de chercher dans ce sens en attendant votre réponse
Merci de votre aide!

Invité · 17/04/2014, 18h29

Envoyé par FatP0ney

Si j'ai bien compris ce que mes amis avaient fait il faudrait faire une sorte de test à chaque fois que la balle avance du "pas" voulu.
Il faudrait donc utiliser le test qui est fait à la fin du fichier partie-1-coord-droite-finie (que j'ai posté si je ne me trompes pas) afin que si il revoit Faux (c'est à dire qu'on est en dehors des limites d'un polygone) que la boule revienne à sa place initiale.
Est ce bien cela?

Je vais essayer de chercher dans ce sens en attendant votre réponse
Merci de votre aide!

Vous voulez dire qu'il faudrait faire le test dans la fonction move() directement ?