Introduction
La création de jeux vidéo est une manière passionnante d'apprendre la programmation, et Python, avec sa bibliothèque Pygame, offre une approche accessible et pratique pour développer des jeux en 2D. Si vous êtes débutant dans le développement de jeux ou dans l'utilisation de Pygame, cet article est pour vous. Nous allons explorer les concepts fondamentaux de Pygame comme la création d'une fenêtre, la gestion des événements et la boucle de jeu, avant de mettre tout cela en pratique en écrivant un petit jeu simple : une balle qui rebondit dans une fenêtre.
1. Introduction à Pygame et à ses concepts clés
Avant de plonger dans le code, il est essentiel de comprendre quelques concepts de base dans Pygame :
Création d'une fenêtre de jeu
La première étape pour tout jeu Pygame est de créer une fenêtre où le jeu sera affiché. Cela se fait avec la fonction pygame.display.set_mode() :
import pygame
# Initialiser Pygame
pygame.init()
# Créer une fenêtre de jeu
screen = pygame.display.set_mode((640, 480))
pygame.display.set_caption("Mon premier jeu avec Pygame")
Dans cet exemple :
pygame.init()initialise tous les modules Pygame nécessaires.pygame.display.set_mode()crée une fenêtre avec les dimensions 640x480 pixels.pygame.display.set_caption()permet de définir un titre pour la fenêtre.
Gestion des événements
Les événements dans Pygame représentent les interactions de l'utilisateur avec le jeu, comme fermer la fenêtre ou appuyer sur une touche. Ces événements sont capturés dans une boucle grâce à la fonction pygame.event.get().
Exemple de code pour détecter la fermeture de la fenêtre :
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
Cela garantit que le jeu reste actif jusqu'à ce que l'utilisateur ferme la fenêtre.
La boucle de jeu
La boucle de jeu est au cœur de chaque jeu. Elle permet de garder le jeu actif, de gérer les événements, de mettre à jour l'affichage, et de contrôler les animations. La structure générale ressemble à ceci :
running = True
while running:
# Gestion des événements
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
# Logique du jeu (mouvements, collisions, etc.)
# Rafraîchir l'écran
pygame.display.flip()
# Attente pour limiter la vitesse du jeu
pygame.time.Clock().tick(60)
pygame.display.flip()met à jour l'écran après chaque cycle de la boucle.pygame.time.Clock().tick(60)limite le nombre de frames par seconde à 60, ce qui permet de garder une vitesse de jeu constante.
2. Écrire un premier jeu simple : une balle qui rebondit
Maintenant que vous comprenez les bases, mettons-les en pratique en codant un petit jeu où une balle rebondit dans la fenêtre. Ce projet mettra en lumière les concepts clés que nous avons vus plus tôt : gestion des événements, mise à jour de l'affichage et logique de mouvement.
Étape 1 : Initialisation du jeu et création de la balle
Commençons par initialiser Pygame et définir les dimensions de la fenêtre ainsi que les propriétés de la balle :
import pygame
# Initialiser Pygame
pygame.init()
# Créer la fenêtre de jeu
screen = pygame.display.set_mode((640, 480))
pygame.display.set_caption("Balle qui rebondit")
# Couleur de l'arrière-plan et de la balle
WHITE = (255, 255, 255)
BLUE = (0, 0, 255)
# Position et vitesse de la balle
ball_x = 320
ball_y = 240
ball_speed_x = 3
ball_speed_y = 3
# Rayon de la balle
ball_radius = 20
WHITEetBLUEdéfinissent les couleurs pour l'arrière-plan et la balle.- La position initiale de la balle est au centre de l'écran (640/2, 480/2).
- Les variables
ball_speed_xetball_speed_ycontrôlent la vitesse et la direction de la balle.
Étape 2 : Dessiner et déplacer la balle
À chaque itération de la boucle de jeu, nous allons mettre à jour la position de la balle en fonction de sa vitesse et vérifier si elle touche les bords de la fenêtre pour la faire rebondir.
running = True
clock = pygame.time.Clock()
while running:
# Gestion des événements
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
# Déplacer la balle
ball_x += ball_speed_x
ball_y += ball_speed_y
# Faire rebondir la balle sur les bords de la fenêtre
if ball_x - ball_radius <= 0 or ball_x + ball_radius >= 640:
ball_speed_x = -ball_speed_x
if ball_y - ball_radius <= 0 or ball_y + ball_radius >= 480:
ball_speed_y = -ball_speed_y
# Effacer l'écran avec du blanc
screen.fill(WHITE)
# Dessiner la balle
pygame.draw.circle(screen, BLUE, (ball_x, ball_y), ball_radius)
# Mettre à jour l'affichage
pygame.display.flip()
# Limiter la boucle à 60 images par seconde
clock.tick(60)
pygame.quit()
Explication du code :
ball_x += ball_speed_x: déplace la balle horizontalement.ball_y += ball_speed_y: déplace la balle verticalement.- La vérification des collisions avec les bords permet de faire rebondir la balle en inversant sa vitesse (
ball_speed_x = -ball_speed_x). pygame.draw.circle()dessine la balle à sa nouvelle position.
Étape 3 : Tester et ajuster le jeu
Vous pouvez maintenant exécuter ce programme pour voir une balle qui rebondit dans la fenêtre. Ce petit projet vous offre un aperçu de la façon dont Pygame gère le mouvement et l'affichage des objets.
Conclusion
En suivant ce guide, vous avez découvert les concepts clés de Pygame et réalisé un petit projet simple, mais instructif : une balle qui rebondit dans une fenêtre. Vous avez appris à :
- Créer une fenêtre de jeu.
- Gérer les événements utilisateurs avec Pygame.
- Utiliser la boucle de jeu pour mettre à jour les éléments graphiques et la logique du jeu.
Ce projet de balle rebondissante peut servir de base pour créer des jeux plus complexes, en ajoutant des interactions supplémentaires, des objets multiples, ou encore un système de score. Vous êtes désormais prêt à explorer d'autres fonctionnalités de Pygame et à développer des jeux plus aboutis !
Liens externes utiles :