Aller au contenu

TP : balles rebondissantes⚓︎

image

1. Prise en main de Pygame⚓︎

 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
import pygame, sys
import time
from pygame.locals import *

LARGEUR = 640
HAUTEUR = 480
RAYON = 20

pygame.display.init()
fenetre = pygame.display.set_mode((LARGEUR, HAUTEUR))
fenetre.fill([0,0,0])

x = 300
y = 200
dx = 4
dy = -3
couleur = (45, 170, 250)

while True:
    fenetre.fill([0, 0, 0])
    pygame.draw.circle(fenetre, couleur, (x, y), RAYON)

    x += dx
    y += dy

    pygame.display.update()

    # routine pour pouvoir fermer «proprement» la fenêtre Pygame
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.display.quit()
            sys.exit()

    time.sleep(0.1)

1.1 Rajout d'un rebond sur les parois⚓︎

Modifiez le code précédent afin que la balle rebondisse sur chaque paroi (il suffit de modifier intelligemment les variables de vitesse dx et dy).

Correction 
 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
import pygame, sys
import time
from pygame.locals import *

LARGEUR = 640
HAUTEUR = 480
RAYON = 20

pygame.display.init()
fenetre = pygame.display.set_mode((LARGEUR, HAUTEUR))
fenetre.fill([0, 0, 0])

x = 300
y = 200
dx = 4
dy = -3
couleur = (45, 170, 250)

while True:
    fenetre.fill([0, 0, 0])
    pygame.draw.circle(fenetre, couleur, (x, y), RAYON)

    x += dx
    y += dy

    if (y <= RAYON) or (y >= HAUTEUR - RAYON):
        dy = -dy
    if (x <= RAYON) or (x >= LARGEUR - RAYON):
        dx = -dx

    pygame.display.update()

    # routine pour pouvoir fermer «proprement» la fenêtre Pygame
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.display.quit()
            sys.exit()

    time.sleep(0.02)

1.2 Rajout d'une deuxième balle⚓︎

Attention au nommage des variables...

Correction 
 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
import pygame, sys
import time
from pygame.locals import *

LARGEUR = 640
HAUTEUR = 480
RAYON = 20

pygame.display.init()
fenetre = pygame.display.set_mode((LARGEUR, HAUTEUR))
fenetre.fill([0, 0, 0])


dxA = 7
dyA = 4
dxB = -5
dyB = 3


xA = LARGEUR // 3
yA = HAUTEUR // 2
xB = LARGEUR // 2
yB = HAUTEUR // 2


couleurA = (45, 170, 250)
couleurB = (155, 17, 250)

while True:
    fenetre.fill([0, 0, 0])
    pygame.draw.circle(fenetre, couleurA, (xA, yA), RAYON)
    pygame.draw.circle(fenetre, couleurB, (xB, yB), RAYON)

    xA += dxA
    yA += dyA

    xB += dxB
    yB += dyB

    # rebond en haut ou en bas
    if (yA < RAYON) or (yA > HAUTEUR - RAYON):
        dyA = -dyA

    # rebond à gauche ou à droite
    if (xA < RAYON) or (xA > LARGEUR - RAYON):
        dxA = -dxA

    # rebond en haut ou en bas
    if (yB < RAYON) or (yB > HAUTEUR - RAYON):
        dyB = -dyB

    # rebond à gauche ou à droite
    if (xB < RAYON) or (xB > LARGEUR - RAYON):
        dxB = -dxB

    pygame.display.update()

    # routine pour pouvoir fermer «proprement» la fenêtre Pygame
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.display.quit()
            sys.exit()

    time.sleep(0.03)

1.3 Gestion de la collision entre les deux balles⚓︎

Q1. À l'aide d'un schéma (papier-crayon !), mettez en évidence le test devant être réalisé pour détecter une collision.

indice

image

Q2. Implémentez ce test (en créant pour cela une fonction distance ) et affichez "collision" en console lorsque les deux balles se touchent.

Q3. Pour donner l'illusion physique du rebond, échangez les valeurs respectives de dx et dy pour les deux balles.

1.4 Rajout d'une troisième balle et gestion du rebond avec les deux autres.⚓︎

... vraiment ? Peut-on continuer comme précédemment ?

image

2. La POO à la rescousse : création d'une classe Balle⚓︎

2.1 la classe Balle⚓︎

L'objectif est que la méthode constructeur dote chaque nouvelle balle de valeurs aléatoires : abscisse, ordonnée, vitesse, couleur...

  • Pour l'aléatoire, on pourra utiliser randint(a, b) qui renvoie un nombre pseudo-aléatoire entre a et b. Il faut pour cela importer la fonction, par from random import randint

  • Vous pouvez aussi doter votre classe Balle d'une méthode dessine (qui affiche la balle), ainsi qu'une méthode bouge qui la fait bouger.

Créez cette classe et instanciez une balle.

2.2 Plusieurs balles⚓︎

L'idée est de stocker dans une liste sac_a_balles un nombre déterminé de balles...

2.3 Collision de toutes les balles⚓︎

Il «suffit» , dans la méthode constructeur, de tester la collision de la balle self avec chacune des balles de notre sac_a_balles.

3. Extensions⚓︎

  • Vous pouvez créer des balles de couleurs identiques, sauf une. Cette balle diffusera sa couleur à toutes les balles avec qui elle rentrera en collision.
  • En la supprimant de la liste sac_a_balles, vous pouvez faire disparaitre une balle.
  • Vous pouvez créer une balle que vous déplacerez au clavier (voir ici pour la gestion des déplacements)
  • ...
  • Ce que je ne veux pas voir :