Labyrinthe avec Pygame

Bienvenue dans le monde des labyrinthes avec Pygame ! Aujourd’hui, nous allons créer un labyrinthe simple à l’aide de la bibliothèque Pygame. Tu seras en mesure de voir comment nous pouvons dessiner des formes à l’écran pour créer des jeux amusants.

Partie 1 : Initialisation du projet

Dans cette première partie, nous allons apprendre à dessiner les murs d’un labyrinthe en utilisant Pygame. 

Créer un nouveau projet Pygame dans Replit, puis supprimer le code présent par défaut.

Les murs seront représentés par des rectangles blancs.

Explications :

Nous commençons par importer le module pygame qui nous permettra de créer notre jeu.

import pygame
import sys

Nous initialisons Pygame avec pygame.init() pour pouvoir l’utiliser.

pygame.init()

Nous définissons les couleurs que nous allons utiliser. Par exemple, BLACK représente le noir, WHITE représente le blanc, GREEN représente le vert et RED représente le rouge.

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GREEN = (0, 255, 0)
RED = (255, 0, 0)

Nous définissons les dimensions de la fenêtre du jeu en utilisant les variables WINDOW_WIDTH et WINDOW_HEIGHT. Par exemple, ici la fenêtre fera 400 pixels de large et 400 pixels de haut.

WINDOW_WIDTH = 400
WINDOW_HEIGHT = 400

Nous créons la fenêtre du jeu avec la méthode pygame.display.set_mode() en lui passant les dimensions de la fenêtre.

window = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption(« Labyrinthe »)

Puis tout en bas du code (et il le saura toujours) il y aura : 

# Fermeture de Pygame
pygame.quit()

pygame.QUIT permet de fermer la fenêtre du jeu.

Partie 2 : Configurer les Murs du Labyrinthe

Maintenant, nous allons définir la taille des cellules du labyrinthe. Par exemple, nous définissons que chaque cellule fera 40 pixels de large et de haut.

CELL_SIZE = 40

Nous définissons le nombre de cellules dans chaque direction en utilisant les variables NUM_CELLS_X et NUM_CELLS_Y. Ces valeurs sont calculées en divisant la largeur et la hauteur de la fenêtre par la taille des cellules.

NUM_CELLS_X = WINDOW_WIDTH // CELL_SIZE
NUM_CELLS_Y = WINDOW_HEIGHT // CELL_SIZE

Ensuite, nous créons une liste appelée walls qui contient les coordonnées des murs du labyrinthe. Chaque coordonnée représente une cellule dans le labyrinthe où nous voulons dessiner un mur.

walls = [(2, 1), (2, 2), (2, 3), (3, 3), (4, 3), (5, 3), (8, 4)]

Maintenant, nous entrons dans la boucle principale du jeu avec while running:. Cette boucle s’exécute tant que la variable running est True.

À l’intérieur de la boucle, nous parcourons tous les événements qui se produisent (par exemple, le mouvement de la souris, les clics de souris, les touches du clavier) en utilisant for event in pygame.event.get():.

Si l’événement est de type pygame.QUIT, cela signifie que l’utilisateur souhaite fermer la fenêtre du jeu. Dans ce cas, nous mettons la variable running à `False

Partie 3 : Dessiner les murs

Explications  :

Si l’événement est de type pygame.QUIT, cela signifie que l’utilisateur souhaite fermer la fenêtre du jeu. Dans ce cas, nous mettons la variable running à False et nous quittons le jeu.

if event.type == pygame.QUIT:
    running = False
    sys.exit()

Nous effaçons l’écran en utilisant la couleur noire avec window.fill(BLACK).

    # Effacer l’écran
    window.fill(BLACK)

Maintenant, nous allons dessiner les murs du labyrinthe en parcourant la liste walls. Pour chaque coordonnée dans walls, nous utilisons la fonction pygame.draw.rect() pour dessiner un rectangle blanc à l’emplacement de la cellule correspondante. Les coordonnées de chaque cellule sont multipliées par la taille des cellules pour obtenir les coordonnées en pixels.

# Dessiner les murs

for wall in walls:
    pygame.draw.rect(window, WHITE, (wall[0] * CELL_SIZE, wall[1] * CELL_SIZE, CELL_SIZE, CELL_SIZE))

Enfin, nous mettons à jour la fenêtre avec pygame.display.update() pour afficher les dessins à l’écran.

L’exécution du programme continue dans la boucle principale jusqu’à ce que l’utilisateur ferme la fenêtre du jeu.

Lorsque la boucle se termine, nous fermons Pygame avec pygame.quit().

Code complet :

import pygame
import sys

# Initialisation de Pygame
pygame.init()

# Définition des couleurs
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GREEN = (0, 255, 0)
RED = (255, 0, 0)

# Définition des dimensions de la fenêtre du jeu
WINDOW_WIDTH = 400
WINDOW_HEIGHT = 400

# Dimensions des cellules et nombre de cellules
CELL_SIZE = 40
NUM_CELLS_X = WINDOW_WIDTH // CELL_SIZE
NUM_CELLS_Y = WINDOW_HEIGHT // CELL_SIZE

# Création de la fenêtre du jeu
window = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption(« Labyrinthe »)

# Position des murs
walls = [(2, 1), (2, 2), (2, 3), (3, 3), (4, 3), (5, 3), (8, 4)]

# Boucle principale du jeu
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
            sys.exit()

    # Effacer l’écran
    window.fill(BLACK)

    # Dessiner les murs
    for wall in walls:
        pygame.draw.rect(window, WHITE, (wall[0] * CELL_SIZE, wall[1] * CELL_SIZE, CELL_SIZE, CELL_SIZE))

    # Actualiser la fenêtre
    pygame.display.update()

# Fermeture de Pygame
pygame.quit()

Avec ce code, tu devrais pouvoir voir les murs du labyrinthe s’afficher à l’écran. N’hésite pas à expérimenter en ajoutant ou en modifiant les coordonnées des murs dans la liste walls pour créer ton propre labyrinthe.

Partie 4 : Intégrer le Joueur

Dans cette partie, nous allons ajouter le joueur et le point d’arrivée au jeu.

1. Coordonnées du joueur et du point d’arrivée

Nous ajoutons les variables `player_x` et `player_y` qui représentent les coordonnées du joueur dans le labyrinthe. Ici, nous les initialisons avec les valeurs `CELL_SIZE // 1` pour positionner le joueur au début du labyrinthe.

Nous ajoutons également les variables `goal_x` et `goal_y` qui représentent les coordonnées du point d’arrivée. Ici, nous les initialisons avec les valeurs `WINDOW_WIDTH – CELL_SIZE // 2` et `WINDOW_HEIGHT – CELL_SIZE // 2` pour les positionner à la fin du labyrinthe.

# Coordonnées du joueur
player_x = CELL_SIZE // 1
player_y = CELL_SIZE // 1

# Coordonnées du point d’arrivée
goal_x = WINDOW_WIDTH – CELL_SIZE // 2
goal_y = WINDOW_HEIGHT – CELL_SIZE // 2

 

2. Gestion des événements de déplacement du joueur

Nous ajoutons une condition pour gérer les événements de déplacement du joueur lorsqu’une touche du clavier est enfoncée. Si la touche de flèche gauche est enfoncée et que la position du joueur est supérieure à la moitié de la taille d’une cellule, nous décrémentons `player_x` d’une cellule pour déplacer le joueur vers la gauche. Nous faisons de même pour les autres touches de déplacement en vérifiant les limites de la fenêtre.

# Déplacement du joueur
if event.type == pygame.KEYDOWN:
    if event.key == pygame.K_LEFT:
        if player_x > CELL_SIZE // 2:
            player_x -= CELL_SIZE
    elif event.key == pygame.K_RIGHT:
        if player_x < WINDOW_WIDTH – CELL_SIZE // 2:
            player_x += CELL_SIZE
    elif event.key == pygame.K_UP:
        if player_y > CELL_SIZE // 2:
            player_y -= CELL_SIZE
    elif event.key == pygame.K_DOWN:
        if player_y < WINDOW_HEIGHT – CELL_SIZE // 2:
            player_y += CELL_SIZE

Partie 5 : Les collisions

1. Vérification des collisions avec les murs

Nous ajoutons une vérification des collisions entre le joueur et les murs. Si les coordonnées du joueur se trouvent dans la liste `walls`, cela signifie qu’il a touché un mur. Nous affichons alors un message « GAME OVER » à l’écran et mettons fin au jeu.

# Vérification des collisions avec les murs
if (player_x // CELL_SIZE, player_y // CELL_SIZE) in walls:
    print(« Vous avez touché un mur. Le jeu s’arrête. »)
    game_over_text = font.render(« GAME OVER », True, RED)
    window.blit(game_over_text, (WINDOW_WIDTH // 2 – game_over_text.get_width() // 2, WINDOW_HEIGHT // 2))
    pygame.display.update()
    pygame.time.wait(2000)
    running = False

 

2. Vérification de l’arrivée

Nous ajoutons une vérification pour détecter si le joueur a atteint le point d’arrivée. Si les coordonnées du joueur sont proches des coordonnées du point d’arrivée, nous affichons un message « VICTORY » à l’écran et mettons fin au jeu.

# Vérification de l’arrivée
if player_x – goal_x > -40 and player_y – goal_y > -40:
    print(« Félicitations ! Vous avez atteint le point d’arrivée. »)
    victory_text = font.render(« VICTORY », True, GREEN)
    window.blit(victory_text, (WINDOW_WIDTH // 2 – victory_text.get_width() // 2, WINDOW_HEIGHT // 2))
    pygame.display.update()
    pygame.time.wait(2000)
    running = False

 

3. Dessiner le joueur et le point d’arrivée

Nous utilisons `pygame.draw.rect()` pour dessiner un rectangle vert pour représenter le joueur à la position `(player_x, player_y)`. De même, nous dessinons un rectangle rouge pour représenter le point d’arrivée à la position `(goal_x – CELL_SIZE // 2, goal_y – CELL_SIZE // 2)`.

# Dessiner le joueur
pygame.draw.rect(window, GREEN, (player_x, player_y, CELL_SIZE, CELL_SIZE))

# Dessiner le point d’arrivée
pygame.draw.rect(window, RED,
                 (goal_x – CELL_SIZE // 2, goal_y – CELL_SIZE // 2,
                  CELL_SIZE, CELL_SIZE))

Avec ces ajouts, le joueur pourra se déplacer à l’intérieur du labyrinthe et atteindre le point d’arrivée.

N’oublie pas d’inclure l’import `import sys` au début du code pour utiliser `sys.exit()` lorsque tu souhaites quitter le jeu.

Retour en haut