Discussion :

[FatP0ney]

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]

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]

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]

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]

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]

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)