Discussion :

[scheme]

Bonjour à tous

Je suis débutant en python et je suis le guide de Gérard Swinnen, j'en suis actuellement à l'exercice 8.30, de la page 107, où je dois créer un canevas dans lequel plusieurs balles de couleurs bougent en rebondissant sur les côtés et entre elles. Pour l'instant j'ai réussi à ce qu'elles rebondissent sur les côtés:

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
# -*- coding: cp1252 -*-
 
from Tkinter import *
from random import randrange
 
#-------------------------------------------------
 
def start_it():
    global flag
    if flag == 0:
        flag = 1
        avancer()
 
def stop_it():
    global flag
    flag = 0
 
def avancer():
    global x1,y1,x2,y2,x3,y3,x4,y4, dx1,dy1,dx2,dy2,dx3,dy3,dx4,dy4
    x1,y1=x1+dx1,y1+dy1
    x2,y2=x2+dx2,y2+dy2
    x3,y3=x3+dx3,y3+dy3
    x4,y4=x4+dx4,y4+dy4
    move_redball()
    move_magball()
    move_yelball()
    move_brownball()
    can.coords(redball,x1,y1,x1+20,y1+20)
    can.coords(magball,x2,y2,x2+20,y2+20)
    can.coords(yelball,x3,y3,x3+20,y3+20)
    can.coords(brownball,x4,y4,x4+20,y4+20)
    if flag == 1:
        fen.after(50,avancer)
 
def move_redball():
    global x1,y1,dx1,dy1,liste
    if x1>270:
        dx1=-dx1
        dy1=liste[randrange(8)]
    if y1>270:
        dy1=-dy1
        dx1=liste[randrange(8)]
    if x1<10:
        dx1=-dx1
        dy1=liste[randrange(8)]
    if y1<10:
        dy1=-dy1
        dx1=liste[randrange(8)]
    if (x1>270) and (y1 > 270):
        dx1,dy1=-20,-10
    if (x1>270) and (y1 < 10):
        dx1,dy1=-20,10
    if (x1 <10) and (y1 > 270):
        dx1,dy1=20,-10
    if (x1<10) and (y1< 10):
        dx1,dy1=20,10
 
def move_magball():
    global x2,y2,dx2,dy2,liste
    if x2>270:
        dx2=-dx2
        dy2=liste[randrange(8)]
    if y2>270:
        dy2=-dy2
        dx2=liste[randrange(8)]
    if x2<10:
        dx2=-dx2
        dy2=liste[randrange(8)]
    if y2<10:
        dy2=-dy2
        dx2=liste[randrange(8)]
    if (x2>270) and (y2 > 270):
        dx2,dy2=-20,-10
    if (x2>270) and (y2 < 10):
        dx2,dy2=-20,10
    if (x2 <10) and (y2 > 270):
        dx2,dy2=20,-10
    if (x2<10) and (y2< 10):
        dx2,dy2=20,10
 
def move_yelball():
    global x3,y3,dx3,dy3,liste
    if x3>270:
        dx3=-dx3
        dy3=liste[randrange(8)]
    if y3>270:
        dy3=-dy3
        dx3=liste[randrange(8)]
    if x3<10:
        dx3=-dx3
        dy3=liste[randrange(8)]
    if y3<10:
        dy3=-dy3
        dx3=liste[randrange(8)]
    if (x3>270) and (y3 > 270):
        dx3,dy3=-20,-10
    if (x3>270) and (y3 < 10):
        dx3,dy3=-20,10
    if (x3 <10) and (y3 > 270):
        dx3,dy3=20,-10
    if (x3<10) and (y3< 10):
        dx3,dy3=20,10
 
def move_brownball():
    global x4,y4,dx4,dy4,liste
    if x4>270:
        dx4=-dx4
        dy4=liste[randrange(8)]
    if y4>270:
        dy4=-dy4
        dx4=liste[randrange(8)]
    if x4<10:
        dx4=-dx4
        dy4=liste[randrange(8)]
    if y4<10:
        dy4=-dy4
        dx4=liste[randrange(8)]
    if (x4>270) and (y4 > 270):
        dx4,dy4=-20,-10
    if (x4>270) and (y4 < 10):
        dx4,dy4=-20,10
    if (x4 <10) and (y4 > 270):
        dx4,dy4=20,-10
    if (x4<10) and (y4< 10):
        dx4,dy4=20,10
 
#------------------------------------------------    
 
fen= Tk()
 
x1,y1,x2,y2,x3,y3,x4,y4=20,20,260,20,260,260,20,260
dx1,dy1=20,20
dx2,dy2=-20,20
dx3,dy3=-20,-20
dx4,dy4=20,-20
flag = 0
liste=[-5,-10,-15,-20,5,10,15,20]
can=Canvas(fen,height=300,width=300,bg='white')
can.grid(row=0,column=0,columnspan=2)
redball=can.create_oval(20,20,40,40,width=2,fill='red')
magball=can.create_oval(260,20,280,40,width=2,fill='magenta')
brownball=can.create_oval(20,260,40,280,width=2,fill='maroon')
yelball=can.create_oval(260,260,280,280,width=2,fill='yellow')
Button(fen,text='Start',fg= 'blue',command=start_it).grid(row=1,column=0,sticky=E,padx=2)
Button(fen,text='Stop',fg = 'red', command=stop_it).grid(row=1,column=1,sticky=W,padx=2)
 
fen.mainloop()

Mais pour qu'elles rebondissent entre elles, je n'arrive pas à transcrire mon idée en syntaxe python
En gros, si un point d'une balle 1 de coordonnées en abscisses qui va de x1 à x1+20 et en ordonnées de y1 à y1+20 coupe une balle 2 de coordonnées en abscisses de x2 à x2+20 et en ordonnées de y2 à 2y+20.Je ne sais pas vraiment ce qu'il faut faire, mais c'est la seule idée que j'aie pour l'instant

Avez-vous une idée ?

Dernière chose, vous l'avez certainement remarqué, la longueur de mon code pourrait être réduite de beaucoup si j' arrivais à mettre en argument des fonctions les variables x1, y1 et ainsi de suite mais apparemment ce n'est pas possible Avez-vous une solution pour ça aussi ?

Merci d'avance

[BebeFoetus]

Salut scheme

Mais pour qu'elles rebondissent entre elles, je n'arrive pas à transcrire mon idée en syntaxe python

Pour faire rebondir les balles, j'ai fait en sorte que si la somme des rayons des deux balles était plus grande que la distance séparant leurs centres, alors les balles entre en collision. Et donc s'il y a collision, j'intervertis les dx et dy des deux balles concernées. Ça donne une simulation à peu près potable, et largement suffisante pour l'exercice.

Dernière chose, vous l'avez certainement remarqué, la longueur de mon code pourrait être réduite de beaucoup si j' arrivais à mettre en argument des fonctions les variables x1, y1 et ainsi de suite mais apparemment ce n'est pas possible

Pour ma part, j'ai utilisé des dictionnaires pour enregistrer les attributs des balles (coordonnées, rayon, couleur, ...), et je les aie mis dans des tuples pour pouvoir utiliser des boucles for. Je ne sais pas si c'est "bien", mais en tout cas ça fonctionne.

Mon code si ça peut t'aider :

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
#!/usr/bin/python
# coding: utf-8
 
######
# Écrivez un programme dans lequel évoluent plusieurs balles de couleurs
# différentes, qui rebondissent les unes sur les autres ainsi que sur les parois.
######
 
######
# Importations des bibliothèques
from Tkinter import *
from random import randrange as rr
 
######
# Définitions de fonctions
 
def action() :
    "Animation"
    collide()
    move()
    fen.after(20, action)
 
def move() :
    "Déplacement des balles"
    for i in range(len(bs)) :
        bs[i]['x'] += bs[i]['dx']
        bs[i]['y'] += bs[i]['dy']
        can.coords(balls[i],
                   bs[i]['x'] - bs[i]['ray'],
                   bs[i]['y'] - bs[i]['ray'],
                   bs[i]['x'] + bs[i]['ray'],
                   bs[i]['y'] + bs[i]['ray'])
 
def collide() :
    "Test de collision des balles"
    # Collision avec les parois
    for i in bs :
        if (i['x'] - i['ray']) <= 0 or (i['x'] + i['ray']) >= int(can['width']) :
            i['dx'] = -i['dx']
        if (i['y'] - i['ray']) <= 0 or (i['y'] + i['ray']) >= int(can['height']) :
            i['dy'] = -i['dy']
    # Collision entre les balles
    # ordre = 1/2, 1/3, 1/4, 2/3, 2/4, 3/4
    for i in range(len(bs)) :
        j = i + 1
        while j < len(bs) :
            # Test si (ray1+ray2)² > dist(x1-x2)² + dist(y1-y2)²
            # et interverti les dx et dy
            if (bs[i]['ray'] + bs[j]['ray'])**2 > \
                     ((bs[i]['x'] - bs[j]['x'])**2 + \
                     (bs[i]['y'] - bs[j]['y'])**2) :
                bs[i]['dx'], bs[j]['dx'] = bs[j]['dx'], bs[i]['dx']
                bs[i]['dy'], bs[j]['dy'] = bs[j]['dy'], bs[i]['dy']
            j += 1
 
#######################
# Programme principal #
#######################
 
######
# Widget principal
fen = Tk()
fen.title("Ping pong à 4")
 
######
# Variables
canW, canH = 640, 480
ray = 15
 
######
# Widget enfants
can = Canvas(fen, width=canW, height=canH, bg='white')
can.pack(side=TOP, padx=5, pady=5)
 
b1 = {'x': rr(canW - 2*ray) + ray,
      'y': rr(canH - 2*ray) + ray,
      'ray': ray,
      'dx': rr(-5,5),
      'dy': rr(-5,5)}
 
b2 = {'x': rr(canW - 2*ray) + ray,
      'y': rr(canH - 2*ray) + ray,
      'ray': ray,
      'dx': rr(-5,5),
      'dy': rr(-5,5)}
 
b3 = {'x': rr(canW - 2*ray) + ray,
      'y': rr(canH - 2*ray) + ray,
      'ray': ray,
      'dx': rr(-5,5),
      'dy': rr(-5,5)}
 
b4 = {'x': rr(canW - 2*ray) + ray,
      'y': rr(canH - 2*ray) + ray,
      'ray': ray,
      'dx': rr(-5,5),
      'dy': rr(-5,5)}
 
bs = (b1, b2, b3, b4)
 
 
ball1 = can.create_oval(b1['x'] - b1['ray'],
                        b1['y'] - b1['ray'],
                        b1['x'] + b1['ray'],
                        b1['y'] + b1['ray'],
                        fill='red')
 
ball2 = can.create_oval(b2['x'] - b2['ray'],
                        b2['y'] - b2['ray'],
                        b2['x'] + b2['ray'],
                        b2['y'] + b2['ray'],
                        fill='green')
 
ball3 = can.create_oval(b3['x'] - b3['ray'],
                        b3['y'] - b3['ray'],
                        b3['x'] + b3['ray'],
                        b3['y'] + b3['ray'],
                        fill='blue')
 
ball4 = can.create_oval(b4['x'] - b4['ray'],
                        b4['y'] - b4['ray'],
                        b4['x'] + b4['ray'],
                        b4['y'] + b4['ray'],
                        fill='yellow')
 
balls = (ball1, ball2, ball3, ball4)
 
 
Button(fen, text="Quitter", command=fen.quit).pack()
 
######
# Démarrage du gestionnaire d'évènements
action()
fen.mainloop()

[scheme]

Merci beaucoup

Je ne connais pas encore la notion de tuple ni de for, donc je ne comprend tout à ton code, mais tu m'as quand même bien aidé avec ça :"la somme des rayons des deux balles était plus grande que la distance séparant leurs centres, alors les balles entre en collision", j'aurais du y penser plus tôt^^
Maintenant je vais pouvoir y arriver, merci encore