Création d'une animation de pluie de code avec Pygame

Introduction

Dans ce projet, vous allez apprendre à créer une animation de pluie de code simple à l'aide de la bibliothèque Pygame en Python. Les animations de pluie de code, popularisées par des films comme "The Matrix", affichent des caractères tombant sur un écran, donnant l'impression d'une pluie numérique. Nous utiliserons la bibliothèque Pygame pour créer l'animation et l'afficher dans une fenêtre.

👀 Aperçu

🎯 Tâches

Dans ce projet, vous allez apprendre :

• Comment configurer la fenêtre d'animation dans Pygame
• Comment définir une classe "Goutte de pluie" pour représenter chaque caractère tombant
• Comment générer et afficher de multiples instances de la classe Goutte de pluie
• Comment implémenter la boucle principale pour mettre à jour continuellement l'animation
• Comment fermer correctement la fenêtre d'animation

🏆 Réalisations

Après avoir terminé ce projet, vous serez capable de :

• Utiliser la bibliothèque Pygame pour créer des animations
• Définir et utiliser une classe en Python
• Gérer les événements utilisateur dans Pygame
• Créer une boucle d'animation principale dans Pygame
• Fermer correctement une fenêtre d'animation dans Pygame

Créer les fichiers du projet

Avant de commencer, assurez-vous d'avoir Pygame installé. Si vous n'avez pas Pygame installé, vous pouvez le faire à l'aide de pip :

sudo pip install pygame

Ensuite, créez un fichier nommé code_rain.py dans votre éditeur de code ou IDE préféré. Ce sera le fichier principal où vous écrirez le code pour le jeu de Pong.

cd ~/projet
touch code_rain.py

Configuration de la fenêtre d'animation

Dans le fichier code_rain.py, importez les bibliothèques requises au début du code :

import pygame
import random

Ensuite, initialisez Pygame en appelant pygame.init() :

pygame.init()

Ensuite, configurez la fenêtre d'animation en définissant la largeur, la hauteur et la légende :

largeur, hauteur = 800, 600
ecran = pygame.display.set_mode((largeur, hauteur))
pygame.display.set_caption("Pluie de code")

Définissez les couleurs utilisées dans l'animation :

couleur_fond = (0, 0, 0)
couleur_texte = (0, 255, 0)

Paramètres de police :

police = pygame.font.Font(None, 36)

Définition de la classe Goutte de pluie

Ensuite, nous définissons la classe Goutte de pluie, qui représente chaque caractère tombant dans l'animation de pluie de code. La classe Goutte de pluie contient des attributs tels que la position initiale, le texte et la vitesse de chute de chaque goutte de pluie.

class GoutteDePluie:
    def __init__(self):
        self.x = random.randint(0, largeur)
        self.y = random.randint(0, hauteur)
        self.text = chr(random.randint(33, 126))
        self.vitesse = random.randint(1, 5)

    def tomber(self):
        self.y += self.vitesse
        if self.y > hauteur:
            self.y = 0
            self.x = random.randint(0, largeur)

    def afficher(self):
        surface_texte = police.render(self.text, True, couleur_texte)
        ecran.blit(surface_texte, (self.x, self.y))

La méthode __init__ est appelée lorsqu'une instance de la classe est créée pour initialiser les propriétés de la goutte de pluie, y compris la position initiale aléatoire (x, y), les caractères de texte aléatoires (ASCII entre 33 et 126) et la vitesse de chute aléatoire (entre 1 et 5).

La méthode tomber est utilisée pour déplacer les gouttes de pluie vers le bas. Elle augmente la valeur de self.y selon la vitesse de la goutte de pluie. Si la goutte de pluie sort de l'écran (lorsque self.y est supérieure à la hauteur de l'écran), la remettre au sommet de l'écran et sélectionner aléatoirement une nouvelle position x sur l'écran.

La méthode afficher est utilisée pour afficher les gouttes de pluie. Elle utilise la fonction police.render de la bibliothèque pygame pour créer une surface de texte et la rendre à la position de la goutte de pluie (self.x, self.y) sur l'écran.

Génération et affichage des gouttes de pluie

Maintenant, nous allons créer et afficher de multiples instances de la classe Goutte de pluie pour simuler les caractères tombant. Le code ci-dessous génère un nombre spécifié de gouttes de pluie et met à jour leurs positions sur l'écran.

nombre_gouttes = 100
gouttes = [GoutteDePluie() for _ in range(nombre_gouttes)]

Gérer la boucle principale

Dans cette étape, nous implémentons la boucle principale qui gère l'animation en mettant à jour continuellement l'écran. Elle écoute également l'événement de fermeture pour fermer correctement la fenêtre.

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

    ecran.fill(couleur_fond)

    for goutte in gouttes:
        goutte.tomber()
        goutte.afficher()

    pygame.display.flip()

pygame.quit()

Le corps principal de la boucle d'animation est une boucle while, où la variable en_execution contrôle la boucle. La boucle ne continuera à s'exécuter que si en_execution est True.

Dans la boucle d'animation, utilisez pygame.event.get() pour obtenir une liste d'événements pygame et examiner chaque événement en itérant sur la liste d'événements. Dans ce cas, le principal test est s'il y a un événement de sortie pygame.QUIT, qui est généré lorsque l'utilisateur ferme la fenêtre d'animation. Si un événement de sortie est détecté, définissez en_execution sur False pour sortir de la boucle d'animation.

ecran.fill(couleur_fond) remplit la couleur d'arrière-plan de la fenêtre d'animation ecran pour couvrir le contenu de la trame précédente en préparation pour dessiner une nouvelle trame.

Itérez à travers la liste gouttes, en appelant la méthode tomber() sur chaque objet goutte de pluie pour la faire tomber, et en appelant la méthode afficher() pour afficher la goutte de pluie sur la fenêtre de jeu.

pygame.display.flip() est utilisé pour rafraîchir toutes les opérations de dessin ci-dessus sur l'écran pour l'animation.

Après la fin de la boucle d'animation, appelez pygame.quit() pour nettoyer la bibliothèque pygame et sortir de l'animation.

Exécutez le projet

Enfin, basculez sur le bureau et exécutez le projet en utilisant la commande suivante :

python code_rain.py

Récapitulatif

Dans ce projet, vous avez appris à créer une simple animation de pluie de code à l'aide de la bibliothèque Pygame en Python. Vous avez initialisé le module Pygame, défini la classe Goutte de pluie, généré et affiché de multiples gouttes de pluie, et implémenté la boucle principale pour gérer l'animation. Ce projet fournit une compréhension de base de la manière de créer des animations simples à l'aide de Pygame.