Comment créer un jeu Pygame avec plusieurs niveaux et un menu principal ?

Niveau/états du menu de Pygame

Pygame est une bibliothèque Python populaire pour créer des jeux 2D. Il fournit une variété de modules pour gérer les graphiques, le son, les entrées, etc.

Dans cet article, nous verrons comment utiliser Pygame pour créer des jeux avec plusieurs niveaux et menus. Nous commencerons par créer un jeu simple avec un seul niveau, puis nous développerons cela pour créer un jeu avec plusieurs niveaux et un menu principal.

Créer un jeu simple avec un seul niveau

Pour créer un jeu simple avec un seul niveau, nous devrons créer une fenêtre Pygame, charger des graphiques et créer une boucle de jeu.

Voici un code extrait qui montre comment procéder :

import pygame

# Initialize the Pygame library
pygame.init()

# Set the window size
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

# Create the Pygame window
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))

# Set the window title
pygame.display.set_caption("My Game")

# Load the background image
background_image = pygame.image.load("background.png").convert()

# Create the player sprite
player = pygame.sprite.Sprite()
player.image = pygame.image.load("player.png").convert()
player.rect = player.image.get_rect()
player.rect.center = (SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2)

# Create the enemy sprite
enemy = pygame.sprite.Sprite()
enemy.image = pygame.image.load("enemy.png").convert()
enemy.rect = enemy.image.get_rect()
enemy.rect.center = (SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 + 100)

# Create a group to hold all the sprites
all_sprites = pygame.sprite.Group()
all_sprites.add(player)
all_sprites.add(enemy)

# Create a clock to control the game loop
clock = pygame.time.Clock()

# Run the game loop
running = True
while running:

    # Process events
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Update the game state
    all_sprites.update()

    # Draw the game画面
    screen.blit(background_image, (0, 0))
    all_sprites.draw(screen)

    # Flip the display
    pygame.display.flip()

    # Cap the frame rate at 60 FPS
    clock.tick(60)

# Quit the game
pygame.quit()

Ce code crée une fenêtre Pygame avec une image de fond et deux sprites : un joueur et un ennemi. La boucle de jeu se déroule jusqu'à ce que le joueur quitte le jeu, et à chaque itération de la boucle, l'état du jeu est mis à jour, l'écran est dessiné et l'affichage est inversé.

Extension du jeu pour inclure plusieurs niveaux et un menu principal

Pour étendre le jeu afin d'inclure plusieurs niveaux et un menu principal, nous devrons créer une nouvelle classe Scene. Une scène représente une partie particulière du jeu, comme un niveau ou un menu.

Voici un extrait de code qui montre comment créer une classe Scene :

class Scene:

    def __init__(self):
        self.next = None

    def update(self):
        pass

    def draw(self, screen):
        pass

    def handle_events(self, events):
        pass

La classe Scene a trois méthodes : update, draw et handle_events. La méthode update est appelée chaque image pour mettre à jour l'état du jeu, la méthode draw est appelée chaque image pour dessiner le jeu, et la méthode handle_events est appelée chaque image pour gérer les entrées de l'utilisateur.

Nous pouvons maintenant créer un nouvelle scène pour chaque niveau et pour le menu principal. Voici un extrait de code qui montre comment procéder :

class Level1(Scene):

    def __init__(self):
        super().__init__()

        # Create the player sprite
        self.player = pygame.sprite.Sprite()
        self.player.image = pygame.image.load("player.png").convert()
        self.player.rect = self.player.image.get_rect()
        self.player.rect.center = (SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2)

        # Create the enemy sprite
        self.enemy = pygame.sprite.Sprite()
        self.enemy.image = pygame.image.load("enemy.png").convert()
        self.enemy.rect = self.enemy.image.get_rect()
        self.enemy.rect.center = (SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 + 100)

        # Create a group to hold all the sprites
        self.all_sprites = pygame.sprite.Group()
        self.all_sprites.add(self.player)
        self.all_sprites.add(self.enemy)

    def update(self):
        # Update the game state
        self.all_sprites.update()

    def draw(self, screen):
        # Draw the game画面
        screen.blit(background_image, (0, 0))
        self.all_sprites.draw(screen)

    def handle_events(self, events):
        # Handle user input
        for event in events:
            if event.type == pygame.QUIT:
                # The user has quit the game
                pygame.quit()
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    # The user has pressed the left arrow key
                    self.player.rect.x -= 10
                elif event.key == pygame.K_RIGHT:
                    # The user has pressed the right arrow key
                    self.player.rect.x += 10
                elif event.key == pygame.K_UP:
                    # The user has pressed the up arrow key
                    self.player.rect.y -= 10
                elif event.key == pygame.K_DOWN:
                    # The user has pressed the down arrow key
                    self.player.rect.y += 10

class MainMenu(Scene):

    def __init__(self):
        super().__init__()

        # Create the title text
        self.title_text = pygame.font.Font(None, 50)
        self.title_text_image = self.title_text.render("My Game", True, (255, 255, 255))
        self.title_text_rect = self.title_text_image.get_rect()
        self.title_text_rect.center = (SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2)

        # Create the start button
        self.start_button = pygame.draw.rect(screen, (0, 255, 0), (SCREEN_WIDTH / 2 - 50, SCREEN_HEIGHT / 2 + 100, 100, 50))

    def update(self):
        pass

    def draw(self, screen):
        # Draw the game画面
        screen.blit(background_image, (0, 0))
        screen.blit(self.title_text_image, self.title_text_rect)
        pygame.draw.rect(screen, (0, 255, 0), self.start_button)

    def handle_events(self, events):
        # Handle user input
        for event in events:
            if event.type == pygame.QUIT:
                # The user has quit the game
                pygame.quit()
                sys.exit()
            elif event.type == pygame.MOUSEBUTTONDOWN:
                # The user has clicked the start button
                if self.start_button.collidepoint(event.pos):
                    # Set the next scene to Level1
                    self.next = Level1()

Nous pouvons maintenant créer une nouvelle classe SceneManager pour gérer les différentes scènes. Le SceneManager garde une trace de la scène en cours et passe à la scène suivante lorsque la scène en cours est terminée.

Voici un extrait de code qui montre comment créer une classe SceneManager :

class SceneManager:

    def __init__(self):
        self.current_scene = MainMenu()

    def run(self):
        # Run the game loop
        running = True
        while running:

            # Process events
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    # The user has quit the game
                    running = False

            # Update the current scene
            self.current_scene.update()

            # Draw the current scene
            self.current_scene.draw(screen)

            # Flip the display
            pygame.display.flip()

            # Check if the current scene is finished
            if self.current_scene.next is not None:

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!