Créer un jeu de course avec Pygame : Guide pour les débutants

Introduction

Dans ce projet, vous allez apprendre à créer un simple jeu de course à l'aide de la bibliothèque Pygame. Le jeu implique une voiture du joueur et plusieurs voitures ennemies. La voiture du joueur peut être déplacée vers la gauche et la droite en utilisant les flèches directionnelles, tandis que les voitures ennemies descendent sur l'écran. Le but est d'éviter les collisions avec les voitures ennemies aussi longtemps que possible. Le jeu affichera un écran de fin de partie lorsqu'une collision se produira et permettra au joueur de redémarrer le jeu en appuyant sur la touche "R".

👀 Aperçu

Aperçu du jeu de course

🎯 Tâches

Dans ce projet, vous allez apprendre :

Comment configurer la fenêtre de jeu et importer les bibliothèques nécessaires
Comment définir les couleurs et charger les images de voitures
Comment définir la voiture du joueur
Comment définir les voitures ennemies
Comment définir les variables de fin de partie et la police de caractères
Comment implémenter la logique du jeu
Comment afficher l'écran de fin de partie
Comment quitter le jeu

🏆 Réalisations

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

Utiliser la bibliothèque Pygame pour créer une fenêtre de jeu
Charger et afficher des images dans un jeu
Gérer les collisions entre les objets du jeu
Implémenter une boucle de jeu pour un gameplay continu
Gérer l'entrée utilisateur pour contrôler les objets du jeu
Afficher du texte sur l'écran à l'aide du module de police de caractères de Pygame

Créer les fichiers du projet

Créez un nouveau fichier nommé racing_game.py.

cd ~/projet
touch racing_game.py

Configurer la fenêtre du jeu et importer les bibliothèques nécessaires

import pygame
import random

## Initialisez Pygame
pygame.init()

## Configurez la fenêtre de jeu
window_width = 800
window_height = 600
window = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption("Jeu de course")

Dans cette étape, nous importons la bibliothèque pygame et l'initialisons. Ensuite, nous configurons la fenêtre de jeu avec une largeur de 800 pixels et une hauteur de 600 pixels. Nous définissons également le titre de la fenêtre sur "Jeu de course".

Installez la bibliothèque pygame en exécutant la commande suivante dans le terminal :

sudo pip install pygame

Définir les couleurs et charger les images de voitures

## Définissez les couleurs
background_color = (30, 30, 30)
player_car_color = (255, 255, 255)
enemy_car_color = (255, 0, 0)
text_color = (255, 255, 255)

## Chargez les images de voitures
player_car_img = pygame.image.load("player_car.png").convert_alpha()
enemy_car_img = pygame.image.load("enemy_car.png").convert_alpha()

Dans cette étape, nous définissons quelques couleurs utilisées dans le jeu : background_color, player_car_color, enemy_car_color et text_color. Nous chargeons également les images de la voiture du joueur et de la voiture ennemie à l'aide de la fonction pygame.image.load().

Les images player_car.png et enemy_car.png sont incluses dans le répertoire ~/projet.

Définir la voiture du joueur

## Définissez la voiture du joueur
player_car_width = player_car_img.get_width()
player_car_height = player_car_img.get_height()
player_car_x = window_width // 2 - player_car_width // 2
player_car_y = window_height - player_car_height - 10
player_car_speed = 5

Dans cette étape, nous définissons les propriétés de la voiture du joueur : player_car_width et player_car_height sont définis sur les dimensions de l'image de la voiture du joueur. player_car_x et player_car_y représentent la position initiale de la voiture du joueur sur l'écran. player_car_speed détermine la vitesse à laquelle la voiture du joueur peut se déplacer.

Définir les voitures ennemies

## Définissez les voitures ennemies
enemy_cars = []
num_enemy_cars = 3
enemy_car_width = 80
enemy_car_height = 160
for _ in range(num_enemy_cars):
    enemy_car_x = random.randint(0, window_width - enemy_car_width)
    enemy_car_y = random.randint(-window_height, -enemy_car_height)
    enemy_car_speed = random.randint(2, 5)
    enemy_cars.append({"x": enemy_car_x, "y": enemy_car_y, "speed": enemy_car_speed})

Dans cette étape, nous définissons les propriétés des voitures ennemies : enemy_cars est une liste qui stockera les objets de voitures ennemies. num_enemy_cars détermine le nombre de voitures ennemies dans le jeu. enemy_car_width et enemy_car_height représentent les dimensions de l'image de la voiture ennemie. Nous utilisons une boucle pour générer des positions et des vitesses aléatoires pour chaque voiture ennemie et les ajouter à la liste enemy_cars.

Définir les variables de fin de partie et la police

## Définissez les variables de fin de partie
game_over = False
font = pygame.font.Font(None, 50)
game_over_text = font.render("Game Over", True, text_color)
restart_text = font.render("Press R to Restart", True, text_color)

Dans cette étape, nous définissons les variables liées à l'écran de fin de partie : game_over est une variable booléenne qui indique si la partie est terminée ou non. font est un objet de police Pygame d'une taille de 50. Nous affichons le texte "Game Over" et le texte "Press R to Restart" à l'aide de la police et les stockons dans les variables game_over_text et restart_text.

Boucle de jeu

## Boucle de jeu
running = True
clock = pygame.time.Clock()

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_r and game_over:
                game_over = False
                player_car_x = window_width // 2 - player_car_width // 2
                player_car_y = window_height - player_car_height - 10
                for enemy_car in enemy_cars:
                    enemy_car["x"] = random.randint(0, window_width - enemy_car_width)
                    enemy_car["y"] = random.randint(-window_height, -enemy_car_height)

    if not game_over:
        ## Code de logique du jeu ici...

        ## Rafraîchissez la fenêtre
        window.fill(background_color)
        window.blit(player_car_img, (player_car_x, player_car_y))
        for enemy_car in enemy_cars:
            window.blit(enemy_car_img, (enemy_car["x"], enemy_car["y"]))
    else:
        ## Code de l'écran de fin de partie ici...

    pygame.display.update()
    clock.tick(60)

Dans cette étape, nous configurons la boucle de jeu à l'aide d'une boucle while. La boucle s'exécute tant que la variable running est True. Nous gérons les événements tels que la fermeture du jeu et le redémarrage du jeu en vérifiant les types d'événements et les touches. Lorsque le jeu n'est pas terminé, le code à l'intérieur du bloc if not game_over est exécuté, qui inclut la logique du jeu et le tracé de la voiture du joueur et des voitures ennemies sur l'écran. Lorsque le jeu est terminé, le code à l'intérieur du bloc else est exécuté, qui affiche l'écran de fin de partie. Enfin, nous mettons à jour l'affichage et définissons le taux de trame à 60 images par seconde.

Code de logique du jeu

if not game_over:
    ## Déplacez la voiture du joueur
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT] and player_car_x > player_car_speed:
        player_car_x -= player_car_speed
    if (
        keys[pygame.K_RIGHT]
        and player_car_x < window_width - player_car_width - player_car_speed
    ):
        player_car_x += player_car_speed

    ## Déplacez les voitures ennemies
    for enemy_car in enemy_cars:
        enemy_car["y"] += enemy_car["speed"]
        if enemy_car["y"] > window_height:
            enemy_car["x"] = random.randint(0, window_width - enemy_car_width)
            enemy_car["y"] = random.randint(-window_height, -enemy_car_height)
            enemy_car["speed"] = random.randint(2, 5)

        ## Vérifiez les collisions
        if player_car_y < enemy_car["y"] + enemy_car_height:
            if (
                player_car_x < enemy_car["x"] + enemy_car_width
                and player_car_x + player_car_width > enemy_car["x"]
            ):
                game_over = True

Dans cette étape, nous implémentons le code de logique du jeu à l'intérieur de la boucle de jeu. Nous vérifions les entrées de l'utilisateur pour déplacer la voiture du joueur vers la gauche et la droite. Nous mettons à jour les positions des voitures ennemies et vérifions s'il y a eu une collision entre la voiture du joueur et les voitures ennemies. Si une collision se produit, nous définissons la variable game_over sur True.

Code de l'écran de fin de partie

else:
    ## Écran de fin de partie
    window.fill(background_color)
    game_over_rect = game_over_text.get_rect(
        center=(window_width // 2, window_height // 2 - 50)
    )
    restart_rect = restart_text.get_rect(
        center=(window_width // 2, window_height // 2 + 50)
    )
    window.blit(game_over_text, game_over_rect)
    window.blit(restart_text, restart_rect)

Dans cette étape, nous implémentons le code de l'écran de fin de partie à l'intérieur de la boucle de jeu. Nous affichons le texte de fin de partie et le texte de redémarrage sur l'écran à l'aide de la fonction window.blit(). Le texte est centré sur l'écran à l'aide des propriétés get_rect() et center.

Quitter le jeu

## Quitter le jeu
pygame.quit()

Dans cette dernière étape, nous quittons le jeu et fermons la fenêtre Pygame lorsque la boucle de jeu se termine.

Maintenant, vous pouvez exécuter le jeu en utilisant la commande suivante :

python racing_game.py

Capture d'écran de fermeture de la fenêtre du jeu

Résumé

Félicitations ! Vous avez réussi à créer un jeu de course simple à l'aide de la bibliothèque Pygame. Le jeu comprend une voiture de joueur qui peut être déplacée vers la gauche et la droite, ainsi que plusieurs voitures ennemies. L'objectif est d'éviter les collisions avec les voitures ennemies aussi longtemps que possible. Le jeu propose également un écran de fin de partie et la possibilité de redémarrer le jeu en appuyant sur la touche "R". Continuez à pratiquer et à expérimenter pour améliorer vos compétences en développement de jeux.

Jeu de course avec Pygame