Première - TP - Introduction à Pygame

Pygame : un module de dessin 2D

Pygame est un module Python permettant de créer des fenêtes et de dessiner à l'intérieur. Avec un peu d'imagination, on peut même créer des petits jeux vidéos 2D, la seule limite étant l'habileté du programmeur.

Premier code, première fenêtre

import pygame

# Paramétrage de base
pygame.init()
screen = pygame.display.set_mode((800, 600))
clock = pygame.time.Clock()

COULEUR_FOND = (0,0,0)

# Boucle principale
running = True

while running:
    
    # Gestion des événements
    for event in pygame.event.get():
        if event.type == pygame.QUIT: # Lorsqu'on clique sur le X de la fenêtre
            running = False

    # Remplissage de l'écran
    screen.fill(COULEUR_FOND)

    ##################
    # Votre code ici !
    ##################

    # flip() met à jour l'affichage
    pygame.display.flip()

    # Limitation à 60 im/s
    clock.tick(60)

pygame.quit()

Quelques explications...

Initialisation de la fenêtre de jeu

Sans surprise, on commence par importer le module pygame avec le classique :

import pygame

On initialise ensuite la fenêtre avec la fonction init(), puis on crée la variable screen représentant notre fenêtre de jeu, en précisant ses dimensions (800x600 pixels ici).

pygame.init()
screen = pygame.display.set_mode((800, 600))

Boucle principale

Le coeur de notre programme est... une boucle infinie ! Cette boucle n'a d'infini que le nom : sa fin est déterminée par l'état de la variable running, qui, dans ce premier programme, prend la valeur False lorsque l'utilisateur clique sur le bouton de fermeture de la fenêtre (la fameuse croix), grâce aux instructions suivantes :

for event in pygame.event.get():
    if event.type == pygame.QUIT:
        running = False

Nous reviendrons plus en détails sur cette série de commandes lorsque nous parlerons de la gestion des événements.

On trouve également dans la boucle principale deux instructions permettant d'afficher un magnifique fond noir :

screen.fill(COULEUR_FOND)

pygame.display.flip()

La première de ces instructions, screen.fill(COULEUR_FOND), remplit notre fenêtre (représentée par la variable screen) de la couleur précisée, ici du noir. Dans Pygame, une couleur est définie comme un triplet de valeurs (R,V,B).Chaque valeur est un nombre entier de 0 à 255 ; il y a 3 valeurs, une pour chaque couleur primaire, permettant ainsi d'afficher jusqu'à 16 777 216 de couleurs !
C'est le système le plus classique pour représenter des couleurs en informatique, chaque couleur étant alors codée sur 3 octets (1 octet par couleur primaire).

La seconde instruction, pygame.display.flip(), permet de mettre à jour l'affichage de la fenêtre.

Définir un framerate pour calmer le processeur...

On fixe le nombre maximal d'images par seconde à 60 avec l'instruction clock.tick(60). Cette instruction crée une courte pose à la fin de notre boucle de jeu afin de ne pas faire plus de 60 tours de boucle par seconde : votre processeur vous dit merci !

Fin du programme

Lorsque la boucle de jeu se termine, il faut remercier pygame avec la commande :

pygame.quit()

À vous de jouer !

Voici quelques exercices simples. Il suffit de modifier un peu le programme ci-dessus pour les réussir.

Commençons par manipuler un peu la couleur de fond...

1. Modifier le programme afin d'afficher 3 images par seconde.
2. À l'aide de la commande screen.fill(color), faire que la couleur de fond alterne entre noir et blanc.
3. Modifier le programme pour alterner successivement entre les couleurs rouge, vert et orange.
4. Faire clignoter l'écran, en choisissant à chaque tour de boucle une couleur générée aléatoirement (attention les yeux !).

Maintenant que l'on sait afficher des couleurs, il va falloir les enchaîner de façon fluide en réalisant un fondu.

Un fondu entre deux couleurs n'est rien de plus qu'un enchaînement de toutes les couleurs intermédiaires entre ces deux couleurs.

1. Régler le framerate sur 60im/s.
2. Adapter le programme pour afficher un fondu du noir au blanc, en affichant toutes les couleurs intermédiaires : (0,0,0), (1,1,1), (2,2,2), ... jusqu'à (255,255,255).
3. Modifier le programme pour afficher un boucle un fondu noir/blanc/noir.
4. Réaliser un enchaînement ininterrompu de fondus entre couleurs générées aléatoirement.

---

---