Python4Games

Introduction à Pygame et à ses concepts clés : Fenêtre, événements, et boucle de jeu

Posted on by Lucan

Introduction

Pygame est une bibliothèque Python qui simplifie le développement de jeux 2D et d'applications multimédia interactives. Elle repose sur SDL (Simple DirectMedia Layer) et permet de gérer des graphismes, du son, et des interactions utilisateurs avec une relative facilité. Dans cet article, nous allons explorer les concepts fondamentaux de Pygame : la création d'une fenêtre, la gestion des événements, et la boucle de jeu, qui constituent les bases essentielles pour tout projet de jeu.

Si vous êtes débutant en développement de jeux ou en Python, cette introduction vous offrira un point de départ solide pour comprendre comment fonctionne Pygame et comment structurer un jeu simple.

1. Créer une fenêtre de jeu avec Pygame

Le premier élément essentiel pour tout projet avec Pygame est la fenêtre de jeu. Cette fenêtre est l’endroit où tous les éléments visuels de votre jeu seront affichés, qu'il s'agisse de sprites, d'animations ou d'éléments d'interface.

Initialiser Pygame

La première étape dans tout projet Pygame consiste à initialiser la bibliothèque. Cette initialisation prépare les modules nécessaires à la gestion des graphismes, du son, des événements, etc.

import pygame

# Initialiser tous les modules Pygame
pygame.init()

Créer une fenêtre avec pygame.display.set_mode()

Une fois Pygame initialisé, il est temps de créer une fenêtre dans laquelle le jeu se déroulera. Cela se fait en utilisant la fonction pygame.display.set_mode(). Vous pouvez définir la taille de la fenêtre en spécifiant la largeur et la hauteur en pixels.

# Créer une fenêtre de 640x480 pixels
screen = pygame.display.set_mode((640, 480))

# Donner un titre à la fenêtre
pygame.display.set_caption("Mon premier jeu Pygame")

Dans cet exemple, nous créons une fenêtre de 640 x 480 pixels et lui attribuons un titre. L'écran est maintenant prêt à recevoir des éléments visuels.

Remplir l'écran avec une couleur

Pour voir quelque chose à l'écran, vous pouvez le remplir avec une couleur de fond. Utilisons un blanc simple pour commencer :

# Couleur blanche (R, G, B)
WHITE = (255, 255, 255)

# Remplir l'écran avec du blanc
screen.fill(WHITE)

2. Gestion des événements dans Pygame

Dans un jeu vidéo, les événements sont des actions déclenchées par l'utilisateur, comme appuyer sur une touche du clavier ou déplacer la souris. Pygame fournit un moyen simple de gérer ces événements à l’aide de la fonction pygame.event.get().

Boucle d'événements

Les événements sont capturés dans une boucle qui vérifie constamment les actions de l'utilisateur pendant que le jeu tourne. Voici un exemple de boucle d'événements qui détecte la fermeture de la fenêtre lorsque l'utilisateur clique sur le bouton de fermeture.

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
  • pygame.event.get() : Renvoie une liste de tous les événements qui se sont produits (comme la fermeture de la fenêtre ou une touche appuyée).
  • pygame.QUIT : Cet événement est déclenché lorsque l'utilisateur clique sur le bouton de fermeture de la fenêtre.

Cette boucle est essentielle pour tout jeu, car elle permet de capturer les interactions utilisateur et de réagir en conséquence.

Gestion des touches du clavier

En plus de la fermeture de la fenêtre, vous pouvez également gérer d’autres événements comme les appuis sur des touches du clavier. Voici un exemple simple pour détecter quand l'utilisateur appuie sur les touches flèche gauche ou flèche droite :

for event in pygame.event.get():
    if event.type == pygame.KEYDOWN:
        if event.key == pygame.K_LEFT:
            print("Flèche gauche pressée")
        if event.key == pygame.K_RIGHT:
            print("Flèche droite pressée")
  • pygame.KEYDOWN : Détecte si une touche du clavier a été enfoncée.
  • pygame.K_LEFT et pygame.K_RIGHT : Représentent respectivement les touches de la flèche gauche et droite.

3. La boucle de jeu en Pygame (suite)

Comme mentionné précédemment, la boucle de jeu est l'élément central de tout jeu vidéo. Elle continue de tourner tant que le jeu est en cours, gérant les événements, mettant à jour les objets, et rafraîchissant l'affichage à chaque cycle.

Voici un exemple d'une boucle de jeu complète en Pygame, avec gestion des événements et rafraîchissement de l'écran.

Structure complète d'une boucle de jeu

running = True
clock = pygame.time.Clock()  # Crée un objet horloge pour gérer la fréquence des images

while running:
    # 1. Gestion des événements
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # 2. Logique du jeu (mouvement, interactions, etc.)
    # Par exemple, déplacer des objets ou vérifier des collisions

    # 3. Rafraîchir l'affichage
    screen.fill(WHITE)  # On efface l'écran avec une couleur de fond
    # Dessiner ici des objets (sprites, formes, texte, etc.)

    # 4. Mise à jour de l'affichage
    pygame.display.flip()  # Met à jour tout l'écran (rafraîchit l'affichage)

    # 5. Limiter la vitesse de la boucle
    clock.tick(60)  # Limite la boucle à 60 images par seconde (FPS)

Explication détaillée :

  1. Gestion des événements : La première étape de la boucle consiste à vérifier tous les événements qui se produisent (comme la fermeture de la fenêtre, les appuis de touches, etc.) et à réagir en conséquence.
  2. Logique du jeu : C'est là que vous pouvez gérer le mouvement des objets, les interactions entre le joueur et les ennemis, les collisions, ou toute autre mécanique liée au jeu. Par exemple, dans un jeu où un personnage se déplace, c'est ici que la position du personnage serait mise à jour en fonction des entrées du joueur.
  3. Rafraîchir l'affichage : Avant de redessiner les objets, vous devez souvent effacer l'écran en le remplissant avec une couleur de fond ou en redessinant les éléments d'arrière-plan.
  4. Mise à jour de l'affichage : Après avoir effacé l'écran et redessiné les objets (sprites, formes, etc.), la fonction pygame.display.flip() permet d'afficher les modifications à l'écran. Cette opération rafraîchit tout le contenu visible de la fenêtre.
  5. Limiter la vitesse de la boucle : L'utilisation de pygame.time.Clock().tick(60) limite la boucle à 60 itérations par seconde (FPS). Cela permet de contrôler la fluidité du jeu et d'éviter que la boucle ne s'exécute trop rapidement.

4. Exemple de projet : Fenêtre avec un cercle mobile

Pour consolider les concepts, voici un exemple simple où nous ajoutons un cercle qui se déplace à l'écran, avec gestion des événements et boucle de jeu.

Code complet d'un petit projet Pygame

import pygame

# Initialisation de Pygame
pygame.init()

# Configuration de la fenêtre de jeu
screen = pygame.display.set_mode((640, 480))
pygame.display.set_caption("Cercle qui bouge")

# Couleur
WHITE = (255, 255, 255)
RED = (255, 0, 0)

# Position initiale du cercle
circle_x = 320
circle_y = 240
circle_speed_x = 3
circle_speed_y = 3

# Création d'un objet horloge pour contrôler les FPS
clock = pygame.time.Clock()

# Boucle principale du jeu
running = True
while running:
    # 1. Gestion des événements
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # 2. Logique du jeu (déplacer le cercle)
    circle_x += circle_speed_x
    circle_y += circle_speed_y

    # Rebondir sur les bords de l'écran
    if circle_x - 20 <= 0 or circle_x + 20 >= 640:
        circle_speed_x = -circle_speed_x
    if circle_y - 20 <= 0 or circle_y + 20 >= 480:
        circle_speed_y = -circle_speed_y

    # 3. Rafraîchir l'écran (effacer et dessiner)
    screen.fill(WHITE)
    pygame.draw.circle(screen, RED, (circle_x, circle_y), 20)

    # 4. Mise à jour de l'affichage
    pygame.display.flip()

    # 5. Limiter la boucle à 60 FPS
    clock.tick(60)

# Quitter Pygame proprement
pygame.quit()

Explication du code :

  1. Initialisation et création de la fenêtre : Nous avons défini une fenêtre de 640x480 pixels et une couleur de fond blanche.
  2. Logique du jeu : Le cercle rouge se déplace selon les variables circle_speed_x et circle_speed_y. Si le cercle atteint un bord de l'écran, sa direction est inversée, ce qui lui permet de "rebondir" sur les bords.
  3. Rafraîchissement de l'écran : Après chaque déplacement du cercle, nous effaçons l'écran avec la couleur blanche, puis nous dessinons le cercle à sa nouvelle position.
  4. Limitation de la vitesse du jeu : Grâce à clock.tick(60), nous limitons la fréquence de la boucle à 60 images par seconde, assurant une animation fluide.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *