Ajouter une caméra déroulante à vos jeux PyGame

Une caractéristique commune à de nombreux jeux est une caméra défilante qui vous suit lorsque vous vous déplacez dans l’univers du jeu. Cet effet peut ajouter de la profondeur et du réalisme à votre jeu et améliorer l’expérience de jeu globale.

Il existe de nombreuses façons d’implémenter une caméra déroulante dans PyGame, alors assurez-vous de comprendre leurs différences.

Création d’un jeu simple

Avant de commencer, installez pip sur votre appareil et utilisez la commande ci-dessous pour installer le module PyGame :

 pip install pygame 

Maintenant, vous pouvez créer un jeu simple avec un rectangle de joueur et deux plateformes statiques. Le joueur peut se déplacer à gauche et à droite en utilisant les touches fléchées.

Commencez par importer le module pygame. Ensuite, initialisez-le, et créez la fenêtre de jeu en utilisant la fonction pygame.display.set_mode() fonction. Ensuite, définissez la légende de la fenêtre et créez l’objet clock pour gérer la fréquence d’images.

 import pygame

pygame.init()

WINDOW_WIDTH = 800
WINDOW_HEIGHT = 600

screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))

pygame.display.set_caption("My Simple Game")

clock = pygame.time.Clock()

BACKGROUND_COLOR = (255, 255, 255) 

Ensuite, configurez le lecteur et les plates-formes statiques. Définissez la taille du lecteur et sa position initiale.

 PLAYER_WIDTH = 50
PLAYER_HEIGHT = 50

player_x = WINDOW_WIDTH // 2 - PLAYER_WIDTH // 2
player_y = WINDOW_HEIGHT - PLAYER_HEIGHT - 20

PLAYER_SPEED = 10

RECTANGLE_COLOR_1 = (255, 0, 0)
RECTANGLE_COLOR_2 = (0, 0, 255)

rectangle_1 = pygame.Rect(200, 200, 100, 100)
rectangle_2 = pygame.Rect(500, 300, 150, 50) 

Créez ensuite une boucle de jeu qui gère les événements et met à jour l’écran. Dans la boucle, vérifiez les événements tels que l’abandon du jeu ou le déplacement du joueur à l’aide des touches fléchées.

 while True:
    # Handle events
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            quit()

    # Draw the background
    screen.fill(BACKGROUND_COLOR)

    # Draw the static rectangles
    pygame.draw.rect(screen, RECTANGLE_COLOR_1, rectangle_1)
    pygame.draw.rect(screen, RECTANGLE_COLOR_2, rectangle_2)

    # Draw the player
    player_rect = pygame.Rect(player_x, player_y, PLAYER_WIDTH,
        PLAYER_HEIGHT)

    pygame.draw.rect(screen, (0, 0, 0), player_rect)

    # Update the display
    pygame.display.update()

    # Limit the frame rate
    clock.tick(30) 

Configuration de la caméra

Maintenant que vous avez un jeu simple avec un rectangle de joueur et deux plateformes statiques, vous pouvez commencer à travailler sur la caméra. Dans PyGame, la caméra est essentiellement un décalage qui agit sur tous les objets que vous dessinez à l’écran. Cela signifie que si vous déplacez la caméra vers la gauche, tout ce qui se trouve à l’écran semblera se déplacer vers la droite.

Pour configurer la caméra, vous devez d’abord définir une variable qui contiendra le décalage X de la caméra. Appelez cette variable camera_offset_x et l’initialiser à 0.

 # Set the camera offset
camera_offset_x = 0 

Ensuite, mettez à jour les positions de tous les objets que vous dessinez à l’écran, afin de prendre en compte le décalage de la caméra. Vous pouvez le faire en ajoutant le paramètre camera_offset_x à la position X de chaque objet. Par exemple, vous pouvez mettre à jour la position du joueur comme suit :

 # Draw the player
player_rect = pygame.Rect(player_x + camera_offset_x, player_y, PLAYER_WIDTH,
    PLAYER_HEIGHT)

pygame.draw.rect(screen, (0, 0, 0), player_rect) 

De même, vous pouvez mettre à jour les positions des plates-formes statiques comme suit :

 # Draw the static rectangles
rectangle_1_draw_pos = rectangle_1.move(camera_offset_x, 0)
pygame.draw.rect(screen, RECTANGLE_COLOR_1, rectangle_1_draw_pos)
    
rectangle_2_draw_pos = rectangle_2.move(camera_offset_x, 0)
pygame.draw.rect(screen, RECTANGLE_COLOR_2, rectangle_2_draw_pos) 

Déplacement de la caméra à l’aide du clavier

Maintenant que la caméra est installée, vous pouvez commencer à la déplacer. L’une des façons d’y parvenir est de déplacer la caméra en fonction des entrées clavier. Par exemple, vous pouvez déplacer la caméra vers la gauche lorsque le joueur appuie sur la touche fléchée gauche.

Pour ce faire, ajoutez le code suivant dans la boucle d’événements qui gère les entrées clavier :

 if event.type == pygame.KEYDOWN:
    if event.key == pygame.K_LEFT:
        camera_offset_x -= PLAYER_SPEED
    elif event.key == pygame.K_RIGHT:
        camera_offset_x += PLAYER_SPEED 

Une autre méthode consiste à modifier la coordonnée x du joueur lors de l’appui sur le clavier, puis à mettre à jour le décalage de la caméra. Vous pouvez implémenter ceci de la manière suivante :

 # Handle events
for event in pygame.event.get():
    if event.type == pygame.QUIT:
        pygame.quit()
        quit()

    if event.type == pygame.KEYDOWN:
         if event.key == pygame.K_LEFT:
             player_x -= PLAYER_SPEED
         elif event.key == pygame.K_RIGHT:
             player_x += PLAYER_SPEED 

Ensuite, vous pouvez mettre à jour le décalage de la caméra par rapport à la coordonnée x du joueur comme suit :

 camera_offset_x = WINDOW_WIDTH // 2 - player_x - PLAYER_WIDTH // 2 

Déplacement de la caméra à l’aide de la souris

Une autre façon de déplacer la caméra est d’utiliser la souris. Vous pouvez permettre au joueur de déplacer l’écran en cliquant et en faisant glisser la souris.

Pour ce faire, suivez la position de la souris lorsque le joueur appuie sur le bouton gauche de la souris. Lorsqu’il déplace la souris, mettez à jour la coordonnée x du joueur. Elle doit être modifiée par la différence entre la position actuelle de la souris et la position initiale que vous avez suivie, mouse_start_pos.

 # Handle events
for event in pygame.event.get():
    if event.type == pygame.QUIT:
        pygame.quit()
        quit()

    if event.type == pygame.MOUSEBUTTONDOWN:
        if event.button == 1:
            mouse_start_pos = pygame.mouse.get_pos()

    if event.type == pygame.MOUSEMOTION:
        if pygame.mouse.get_pressed()[0]:
            mouse_current_pos = pygame.mouse.get_pos()
            mouse_offset_x = mouse_current_pos[0] - mouse_start_pos[0]
            player_x -= mouse_offset_x
            mouse_start_pos = mouse_current_pos 

Ajouter d’autres fonctions à l’appareil photo

Outre l’effet de caméra défilante, vous pouvez ajouter plusieurs autres fonctions liées à la caméra pour améliorer l’expérience de jeu. L’une d’entre elles est un effet de zoom qui permet au joueur d’agrandir ou de réduire l’univers du jeu. Vous pouvez obtenir cet effet en modifiant la taille de la fenêtre de jeu et en mettant à l’échelle les objets dessinés à l’écran.

Pour ce faire, définissez une variable zoom qui stockera le niveau de zoom actuel du jeu. Fixez sa valeur initiale à 1.0, ce qui correspond à un niveau de zoom nul. Ensuite, définissez une fonction qui calculera la taille d’un objet en fonction du niveau de zoom actuel.

 zoom = 1.0

def get_scaled_size(size):
    return int(size * zoom) 

Ensuite, mettez à jour les positions et les tailles des objets dessinés à l’écran à l’aide de la fonction get_scaled_size . Par exemple, vous pouvez mettre à jour la position et la taille du lecteur comme suit :

 player_rect = pygame.Rect(
    get_scaled_size(player_x + camera_offset_x),
    get_scaled_size(player_y),
    get_scaled_size(PLAYER_WIDTH),
    get_scaled_size(PLAYER_HEIGHT)
) 

De même, mettez à jour les positions et les tailles des plates-formes statiques comme suit :

 rectangle_1_draw_pos = pygame.Rect(
    get_scaled_size(rectangle_1.x + camera_offset_x),
    get_scaled_size(rectangle_1.y),
    get_scaled_size(rectangle_1.width),
    get_scaled_size(rectangle_1.height)
)

pygame.draw.rect(screen, RECTANGLE_COLOR_1, rectangle_1_draw_pos)

rectangle_2_draw_pos = pygame.Rect(
    get_scaled_size(rectangle_2.x + camera_offset_x),
    get_scaled_size(rectangle_2.y),
    get_scaled_size(rectangle_2.width),
    get_scaled_size(rectangle_2.height)
)

pygame.draw.rect(screen, RECTANGLE_COLOR_2, rectangle_2_draw_pos) 

Augmenter ou diminuer le niveau de zoom de 0,1 lorsque le joueur appuie sur la touche = ou – respectivement. Définissez la nouvelle taille de la fenêtre de jeu en fonction du niveau de zoom actuel. Pour ce faire, ajoutez le code suivant dans la boucle d’événements qui gère les entrées clavier :

 if event.type == pygame.KEYDOWN:
    if event.key == pygame.K_EQUALS:
        zoom += 0.1

        screen = pygame.display.set_mode((
            int(WINDOW_WIDTH * zoom),
            int(WINDOW_HEIGHT * zoom)
        ))
    elif event.key == pygame.K_MINUS:
        zoom -= 0.1

        if zoom < 0.1:
            zoom = 0.1

        screen = pygame.display.set_mode((
            int(WINDOW_WIDTH * zoom),
            int(WINDOW_HEIGHT * zoom)
        )) 

Avec le code ci-dessus, vous avez ajouté avec succès un effet de caméra zoomante à notre jeu PyGame. En combinant cette fonctionnalité avec l’effet de caméra défilante, vous pouvez créer une expérience de jeu dynamique et attrayante.

Améliorer le gameplay avec les mouvements de caméra

L’ajout d’une caméra déroulante à un jeu PyGame améliore non seulement l’expérience visuelle, mais aussi le gameplay. Elle permet au joueur de voir une plus grande partie de l’univers du jeu, ce qui lui donne une meilleure compréhension de son environnement et facilite la navigation.

Vous pouvez également utiliser le mouvement de la caméra pour créer des effets spéciaux tels que des zooms avant et arrière ou des secousses de l’écran pour simuler des explosions ou des tremblements de terre.