Ajoutez une caméra à défilement à vos jeux PyGame

Une caractéristique commune que vous trouverez dans de nombreux jeux est une caméra à défilement qui vous suit lorsque vous vous déplacez dans le monde 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éfilement dans PyGame, alors assurez-vous de bien comprendre leurs différences.

Créer un jeu simple

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

pip installer pygame

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

Vous pouvez trouver le code complet du projet dans ce Dépôt GitHub.

Commencez par importer le module pygame. Ensuite, initialisez-le et créez la fenêtre de jeu à l'aide de la commande

pygame.display.set_mode() fonction. Ensuite, définissez la légende de la fenêtre et créez le objet horloge pour gérer la fréquence d'images.

importer pygame
pygame.init()
WINDOW_WIDTH = 800
FENÊTRE_HAUTEUR = 600
écran = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption("Mon petit jeu")
horloge = pygame.heure. Horloge()
COULEUR_FOND = (255, 255, 255)

Ensuite, configurez le lecteur et les plates-formes statiques. Définissez la taille du joueur 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_COULEUR_1 = (255, 0, 0)
RECTANGLE_COULEUR_2 = (0, 0, 255)
rectangle_1 = pygame. Rect(200, 200, 100, 100)
rectangle_2 = pygame. Rect(500, 300, 150, 50)

Ensuite, créez une boucle de jeu qui gère les événements et met à jour l'écran. Dans la boucle, recherchez des événements tels que quitter le jeu ou déplacer le joueur à l'aide des touches fléchées.

alors queVrai:
# Gérer les événements
pour événement dans pygame.event.get() :
si événement.type == pygame. ARRÊTER:
 pygame.quit()
 arrêter()
# Dessiner le fond
 screen.fill (BACKGROUND_COLOR)
# Dessinez les rectangles statiques
 pygame.draw.rect (écran, RECTANGLE_COLOR_1, rectangle_1)
 pygame.draw.rect (écran, RECTANGLE_COLOR_2, rectangle_2)
# Dessinez le joueur
 player_rect = pygame. Rect (joueur_x, joueur_y, PLAYER_WIDTH,
 PLAYER_HEIGHT)
 pygame.draw.rect (écran, (0, 0, 0), player_rect)
# Mettre à jour l'affichage
 pygame.display.update()
# Limiter la fréquence d'images
 horloge.tick(30)

Configuration de la caméra

Maintenant que vous avez un jeu simple avec un rectangle de joueur et deux plates-formes statiques, vous pouvez commencer à travailler sur la caméra. Dans PyGame, la caméra n'est essentiellement qu'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 sur l'écran semblera se déplacer vers la droite.

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

# Réglez le décalage de la caméra
camera_offset_x = 0

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

# Dessinez le joueur
player_rect = pygame. Rect (player_x + camera_offset_x, player_y, PLAYER_WIDTH,
 PLAYER_HEIGHT)
pygame.draw.rect (écran, (0, 0, 0), player_rect)

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

# Dessinez les rectangles statiques
rectangle_1_draw_pos = rectangle_1.move (camera_offset_x, 0)
pygame.draw.rect (écran, RECTANGLE_COLOR_1, rectangle_1_draw_pos)

rectangle_2_draw_pos = rectangle_2.move (camera_offset_x, 0)
pygame.draw.rect (écran, RECTANGLE_COLOR_2, rectangle_2_draw_pos)

Déplacement de la caméra avec des entrées au clavier

Maintenant que la caméra est configurée, vous pouvez commencer à la déplacer. Une façon de procéder consiste à déplacer la caméra en réponse aux entrées du 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 au clavier :

si événement.type == pygame. TOUCHE BAS:
si event.key == pygame. K_GAUCHE :
 camera_offset_x -= PLAYER_SPEED
elif event.key == pygame. K_DROITE :
 camera_offset_x += PLAYER_SPEED

Une autre façon consiste à modifier la coordonnée x du joueur sur le clavier, puis à mettre à jour le décalage de la caméra. Vous pouvez implémenter ceci comme ceci:

# Gérer les événements
pour événement dans pygame.event.get() :
si événement.type == pygame. ARRÊTER:
 pygame.quit()
 arrêter()
si événement.type == pygame. TOUCHE BAS:
si event.key == pygame. K_GAUCHE :
 player_x -= PLAYER_SPEED
elif event.key == pygame. K_DROITE :
 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 avec les entrées de la souris

Une autre façon de déplacer la caméra consiste à utiliser la souris. Vous pouvez autoriser le joueur à faire glisser 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. Il devrait changer par la différence entre la position actuelle de la souris et la position initiale que vous avez suivie, mouse_start_pos.

# Gérer les événements
pour événement dans pygame.event.get() :
si événement.type == pygame. ARRÊTER:
 pygame.quit()
 arrêter()
si événement.type == pygame. BOUTON DE SOURIS BAS :
si événement.bouton == 1:
 mouse_start_pos = pygame.mouse.get_pos()
si événement.type == pygame. MOUVEMENT DE SOURIS :
si 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 plus de fonctionnalités de caméra

Outre l'effet de défilement de la caméra, vous pouvez ajouter plusieurs autres fonctionnalités liées à la caméra pour améliorer l'expérience de jeu. L'une de ces fonctionnalités est un effet de caméra de zoom qui permet au joueur d'effectuer un zoom avant ou arrière sur le monde du jeu. Vous pouvez obtenir cet effet en modifiant la taille de la fenêtre de jeu et en redimensionnant les objets dessinés à l'écran.

Pour ce faire, définissez une variable de zoom qui stockera le niveau de zoom actuel du jeu. Définissez sa valeur initiale sur 1,0, ce qui représente aucun zoom. Ensuite, définissez une fonction qui calculera la taille mise à l'échelle d'un objet en fonction du niveau de zoom actuel.

zoom = 1.0
définitivementget_scaled_size(taille):
retour entier (taille * zoom)

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

player_rect = pygame. Rect(
 get_scaled_size (player_x + camera_offset_x),
 get_scaled_size (joueur_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 (écran, 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 (écran, RECTANGLE_COLOR_2, rectangle_2_draw_pos)

Augmentez ou diminuez le niveau de zoom de 0,1 lorsque le joueur appuie sur la = ou - clé, 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 au clavier :

si événement.type == pygame. TOUCHE BAS:
si event.key == pygame. K_EQUALS :
 zoomer += 0.1
 écran = pygame.display.set_mode((
 entier (WINDOW_WIDTH * zoom),
 entier (WINDOW_HEIGHT * zoom)
 ))
elif event.key == pygame. K_MOINS :
 agrandir -= 0.1
si agrandir < 0.1:
 zoom = 0.1
 écran = pygame.display.set_mode((
 entier (WINDOW_WIDTH * zoom),
 entier (WINDOW_HEIGHT * zoom)
 ))

Avec le code ci-dessus, vous avez ajouté avec succès un effet de caméra de zoom à notre jeu PyGame. En combinant cette fonctionnalité avec l'effet de caméra à défilement, 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éfilement à un jeu PyGame améliore non seulement l'expérience visuelle, mais améliore également le gameplay. Il permet au joueur de voir plus du monde du jeu, lui offrant une meilleure compréhension de son environnement et facilitant la navigation.

Vous pouvez également utiliser le mouvement de la caméra pour créer des effets spéciaux tels que zoomer et dézoomer ou secouer l'écran pour simuler des explosions ou des tremblements de terre.