Bonjour à tous,
Pour la petite histoire, je développe en Python depuis maintenant 2 ans au taff (je suis DBA avec beaucoup d'administration de bases en Python !). Je suis aussi un très gros joueur de jeux vidéo (6 à 8h par jours en semaine). Du coup je me suis dis, mais pourquoi ne pas joindre deux choses qui me passionnent, le développement (en python pour le coup) et le jeu vidéo. Alors je suis tombé sur Pygame et je tente de faire quelques animations toutes bêtes avant de tenter quoi que ce soit, classique en somme.

J'essaye de faire une animation avec des "balles" qui rebondissent non-stop dans la fenêtre (exemple pris sur un wiki et que je complique au fur et à mesure). Elles rebondissent sur les bords, et entre elles (sans me casser la tête avec les angles de collision etc ...). En gros si une balle touche un bord ou une autre balle alors elle repart d'où elle vient.
J'ai de temps en temps une balle qui va se mettre à "bugguer" sur un bord ou bien pendant qu'elle en croise une autre : la balle "tremble" et fini par repartir. De temps en temps, les balles se traversent aussi. J'ai beau chercher, je ne trouve pas la faille dans mon code qui est pourtant simple.
Auriez vous un oeil avisé afin de me donner une piste de l'endroit où ca pourrait foirer ?

Voici le code complet :

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
 
import sys, pygame, random, time
 
#Initialisation de la fenetre
pygame.init()
nb_ball=5
size = width, height = 800, 600
black = 0, 0, 0
screen = pygame.display.set_mode(size)
 
class Ball():
        def __init__(self):
                self.image = pygame.image.load('ball.png')
                self.rect = self.newRandomPosition()
                self.moveSpeed = self.newRandomSpeed()
                return
 
        def newRandomPosition(self):
                # Generation d'une position de depart aleatoire
                rect = self.image.get_rect()
                xpos = random.randint(rect.width, width - rect.width)
                ypos = random.randint(rect.height, height - rect.height)
                rect = rect.move([xpos, ypos])
                return rect
 
        def newRandomSpeed(self):
                # Generation d'une vitesse aleatoire
                random_speed=[random.randint(-10,10), random.randint(-10,10)]
                while 0 in random_speed:
                        random_speed=[random.randint(-10,10), random.randint(-10,10)]
                return random_speed
 
        def move(self):
                self.rect = self.rect.move(self.moveSpeed)
                # On rebondit sur les bords de la fenetre
                if self.rect.left < 0 or self.rect.right > width:
                        self.reverseHorizontal()
                if self.rect.top < 0 or self.rect.bottom > height:
                        self.reverseVertical()
                return
 
        def reverseHorizontal(self):
                self.moveSpeed[0] = -self.moveSpeed[0]
                return
 
        def reverseVertical(self):
                self.moveSpeed[1] = -self.moveSpeed[1]
                return
 
        def displayBall(self):
                screen.blit(self.image, self.rect)
                return
 
        def detectCollisions(self, ballList, exceptions=[]):
                allRect=[]
                for j in range(len(ballList)):
                        if ballList[j] != self and j not in exceptions:
                                allRect.append(ballList[j].rect)
                        listCollisions=self.rect.collidelistall(allRect)
                return listCollisions
 
 
 
ball_list=[]
for i in range(nb_ball):
        ball_list.append(Ball())
 
while 1:
        # Timer pour avoir un déplacement pas trop lent/rapide pour mes yeux :)
        time.sleep(0.01)
 
        # Capture d'event pour quitter
        for event in pygame.event.get():
                if event.type == pygame.QUIT:
                        pygame.display.quit()
                        sys.exit()
 
        # Nettoyage de la fenetre
        screen.fill(black)
 
        # Deplacement basique des balles
        for ball in ball_list:
                ball.move()
                ball.displayBall()
 
        # On detecte les collisions entre balles
        already_moved=[]
        for i in range(len(ball_list)):
                listCollisions=ball_list[i].detectCollisions(ball_list)
                if listCollisions != []:
                        already_moved.append(i)
                        ball_list[i].reverseHorizontal()
                        ball_list[i].reverseVertical()
                        for collision in listCollisions:
                                ball_list[collision].reverseHorizontal()
                                ball_list[collision].reverseVertical
                ball_list[i].displayBall()
        pygame.display.flip()