Bonjour à tous,

Je suis tout neuf dans la programmation de python et dans la programmation tout court. Depuis quel temps, je m'y suis mis mais là je bloque. Mon apprentissage je le réalise avec le livre de Gérard Swinnen(apprendre à programmer avec python).

Je cherche à réaliser l'exercice 8.30., dans cet exercice des boules doivent se déplacer et si une collision survient entre les différentes boules ou contre les parois de la fenêtre, elles doivent rebondir en sens inverse.

je cherche depuis un moment mais là je bloque donc j'ai mis mon code ci-dessous.

je ne cherche pas une correction du code mais plus de nouvelles pistes me permettant de réfléchir différemment.(mon but étant de réaliser l'exercice).

N'hésitez pas à me dire si je suis mal parti avec mon code, je précise que je n'ai pas sauté de chapitres donc je ne connais pas certaines notions comme les classes.

En vous remerciant à bientôt.

Patchoman

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
 
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
 
from Tkinter import *
from random import randrange
 
def addBall():
    """Boucle permettant de créer 5 balles dont les caractérisques sont crées 
        par des variables globales"""
    i=0
    global ball, x, y, r, coul
    while i<len(ball):
        ball[i] = can.create_oval(x[i]-r, y[i]-r, x[i]+r, y[i]+r, fill=color[i])
        i += 1
 
def controlCollision():
    global x, y, dx, dy, r, color
    a=0
    b=1
    while a < 5 :
        b=a+1
        while b < 5:
            print a, b, x[a], x[b], y[a], y[b], dx[a], dx[b], dy[a], dy[b], color[a], color[b]
            if x[a]+r >= x[b]-r and x[a]-r <= x[b]+r:
                # si les coordonnées x de la première balle sont comprises entre
                # celles de la deuxième balle
                if y[a]+r < y[b]-r:
                    dy[a],dy[b]=-dy[a],-dy[b]
                    print"ok 1"
                if y[a]-r > y[b]+r:
                    dy[a],dy[b]=-dy[a],-dy[b]
                    print"ok 2"
 
            elif y[a]+r >= y[b]-r and y[a]-r <= y[b]+r:
                if x[a]+r < x[b]-r:
                    dx[a],dx[b]=-dx[a],-dx[b]
                    print"ok 3"
                if x[a]-r > x[b]+r:
                    dx[a],dx[b]=-dx[a],-dx[b]
                    print"ok 4"
            b += 1
        a += 1
 
 
def moveBall():
    global x, y, dx, dy, flag, r, ball
    j=0
    while j<len(ball):
 
    # déplacement horizontal :
        if x[j] > (400-r) :
            x[j]=(400-r)
            dx[j] = -dx[j]             # on inverse le déplacement
        if x[j] < r:
            x[j]=r
            dx[j] = -dx[j]             # on inverse le déplacement
        controlCollision()
        x[j] = x[j] + dx[j]
 
    # déplacement vertical (proportionnel à la vitesse)
        if y[j] > (250-r):
            y[j]=(250-r)
            dy[j] = -dy[j]             # on inverse le déplacement
        if y[j] < r:
            y[j]=r
            dy[j] = -dy[j]             # on inverse le déplacement
        controlCollision()
        y[j] = y[j] + dy[j]
 
    # on repositionne les balles une par une :
        can.coords(ball[j], x[j]-r, y[j]-r, x[j]+r, y[j]+r)
        j +=1
#        print x
#        print y
        print dx, color
    # ... et on remet ça jusqu'à plus soif :
    if flag > 0:
        fen.after(50,moveBall)
 
def start():
    global flag
    flag = flag +1
    if flag == 1:
        addBall()
        moveBall()
 
def stop():
    global flag
    flag =0
 
# fenêtre graphique
    # liste de 5 coordonnées x et y + un diamètre pour création des balles 
x= [30,370,200,30,370]
y= [30,30,125,220,220]
r= 10
    # pas des déplacements en x et y au hasard choisis de 5 à 10 pour chaque balle
dx= [randrange(5,10),randrange(5,10),randrange(5,10),randrange(5,10),randrange(5,10)]
dy= [randrange(5,10),randrange(5,10),randrange(5,10),randrange(5,10),randrange(5,10)]
flag = 0 
ball=[0]*5 # liste des balles (vides au départ)
color=['red','blue','green','yellow','purple']
compteur = 0
 
fen = Tk()
fen.title(' Balles et rebonds')
can = Canvas(fen, width =400, height=250, bg="white")
can.pack()
 
Button(fen, text='Start', command =start).pack(side =LEFT, padx =10)
Button(fen, text='Stop', command =stop).pack(side =LEFT)
Button(fen, text='Quitter', command =fen.quit).pack(side =RIGHT, padx =10)
score =Label(fen,text="Le score est de " + str(compteur))
score.pack()
 
fen.mainloop()