Aller au contenu

Animation simple (sans événements)⚓︎

L'objectif ici est de faire apparaître un personnage (une image) et de l'animer. Pour illustrer cela on va utiliser cette image que l'on va faire rebondir sur les bords de la fenêtre.

1. Création de la fenêtre et insertion de l'image⚓︎

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
import pygame
from pygame.locals import *

pygame.init()

width, height = 320, 240
screen = pygame.display.set_mode((width, height))

balle = pygame.image.load("basketball16.png")
position_balle = balle.get_rect()
screen.blit(balle, position_balle)
pygame.display.flip()

pygame.quit()

Explication du code

On importe l'image dans une variable balle qui est un objet pygame de type Surface.

Afin de facilement pouvoir le déplacer, on stocke la position de cet objet dans une variable position_balle, qui sera de type rect. 

>>> position_balle
<rect(0, 0, 16, 16)>

où les deux premiers attributs sont les coordonnées (abscisse, ordonnée) et les deux derniers la largeur et la hauteur de l'image.

On affiche cette image en la superposant aux éléments graphiques déjà affichés (en l'occurence, rien...) avec la méthode blit.

2. Animation de l'image/personnage⚓︎

Déplacement

Pour déplacer l'image/le personnage, il faut modifier ses coordonnées à chaque rafraîchissement de la fenêtre.

On peut accéder directement aux coordonnées d'un objet de type rect. Par exemple:

>>> position_balle.left
0
>>> position_balle.bottom
16
>>> position_balle.topleft
(0, 0)
Pour afficher la balle en position (50, 100) (pour le coin haut-gauche, qui est traditionnellement celui sur lequel on travaille), il suffit donc d'écrire:

position_balle.topleft = (50, 100)

On indique le déplacement (horizontal et vertical) par rapport à la position initiale.

Par exemple, pour décaler la balle de 10 pixels vers la droite et de 20 pixels vers le haut: 

1
position_balle.move(10, -20)

Pour notre animation, on décide donc d'un décalage relatif en abscisse et en ordonnée, qu'on stocke par exemple dans deux variables dx et dy.

Ici, pour déplacer d'un pixel sur chaque coordonnée:

dx, dy = 1, 1
position_balle.move([dx, dy])

Bien entendu, il faut changer ces valeurs lorsqu'on atteint le bord de la fenêtre:

  • si position_balle.right dépasse la largeur width, il faut repartir vers la gauche, c'est-à-dire passer de la valeur dx de 1 à -1.
  • et si position_balle.left devient négatif, il faut repartir vers la droite, c'est-à-dire passer de la valeur dx de -1 à 1.

Le code suivant va donc actualiser ce déplacement et faire rebondir notre balle de droite à gauche:

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


pygame.init()

width, height = 320, 240
screen = pygame.display.set_mode((width, height))

balle = pygame.image.load("basketball16.png")
position_balle = balle.get_rect()
screen.blit(balle, position_balle)
pygame.display.flip()

dx, dy = 1, 0

continuer = True
while continuer:
    for evenement in pygame.event.get():
        if evenement.type == QUIT:
            continuer = False

    if position_balle.left < 0 or position_balle.right > width:
        dx = - dx

    position_balle = position_balle.move([dx, dy]) 

    screen.fill([0, 0, 0])
    screen.blit(balle, position_balle)
    pygame.display.flip()

pygame.quit()

screen.fill

Commenter la ligne 28. En quoi est-elle importante?

À vous de jouer pour terminer le programme...

Pour s'entraîner

Écrire un programme où un personnage se déplace aléatoirement dans la fenêtre.

Vous pourrez utiliser les instructions :

  • pygame.time.delay(1000) afin de ne bouger le personnage que toutes les 1000 millisecondes (ou une autre valeur à votre guise).
  • randint(a,b) du package random, qui renvoie un entier pseudo-aléatoire entre a et b.

Pour le personnage, vous pouvez utiliser un sprite (libre de droits) trouvé sur le Web, mais privilégiez le format PNG qui gère la transparence. Ou bien celui-ci: