L’implémentation d’un système de santé dans un jeu peut grandement améliorer l’expérience de jeu et ajouter une couche supplémentaire de défi et de stratégie. PyGame fournit un ensemble robuste d’outils et de fonctions pour incorporer le système de santé, facilitant ainsi la création d’expériences interactives.
Créer un jeu simple
Avant de commencer, assurez-vous que pip est installé sur votre système. Utilisez cette commande pour installer le programme pygame bibliothèque :
pip install pygame
Ensuite, créez un fichier nommé simple-game.py et commençons par créer un jeu simple où le joueur peut se déplacer de gauche à droite.
Le code utilisé dans cet article est disponible dans ce dépôt GitHub et est libre d’utilisation sous la licence MIT.
Dans cette boucle de jeu basique, l’objectif du joueur sera d’éviter d’entrer en collision avec l’ennemi.
import pygame
import random
# Initialize PyGame
pygame.init()
# Set up the game window
window_width, window_height = 800, 600
window = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption("Health System Demo")
# Player attributes
player_width, player_height = 50, 50
player_x, player_y = window_width // 2, window_height - player_height - 10
player_speed = 1
# Enemy attributes
enemy_width, enemy_height = 50, 50
enemy_x, enemy_y = random.randint(0, window_width - enemy_width), 0
enemy_speed = 0.3
# Game loop
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
# Move the player left or right
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT] and player_x > 0:
player_x -= player_speed
if keys[pygame.K_RIGHT] and player_x < window_width - player_width:
player_x += player_speed
# Move the enemy downwards
enemy_y += enemy_speed
# Draw game objects
window.fill((0, 0, 0)) # Clear the screen
pygame.draw.rect(window, (255, 0, 0),
(player_x, player_y,
player_width, player_height))
pygame.draw.rect(window, (0, 255, 0),
(enemy_x, enemy_y,
enemy_width, enemy_height)) # Draw enemy
pygame.display.update()
pygame.quit()
Exécutez le code et vous verrez une fenêtre avec un joueur que vous pouvez contrôler à l’aide des touches fléchées gauche et droite.
Définition des variables et constantes relatives à la santé
Maintenant que vous disposez d’une configuration de jeu de base, définissez les variables et les constantes liées à la santé du joueur. Vous pouvez utiliser un système de santé simple qui représente la santé d’un joueur par une valeur numérique. Vous pouvez également définir des constantes pour la santé maximale du joueur et la quantité de dégâts infligés par l’ennemi.
Fixez la santé initiale du joueur à 100, définissez la santé maximale à 100 et fixez les dégâts infligés par l’ennemi à 20. Ces valeurs peuvent être ajustées en fonction des besoins spécifiques de votre jeu.
# Player health
player_health = 100
max_health = 100
enemy_damage = 20
Mise en place des mécanismes de dégâts et de soins
Pour introduire des mécanismes de dégâts et de soins, vous devez détecter les collisions entre le joueur et l’ennemi et gérer les changements de santé correspondants. Vous pouvez également mettre en place un mécanisme pour soigner le joueur lorsqu’il se déplace hors de l’écran.
Vérifier s’il y a une collision entre le joueur et l’ennemi en comparant leurs rectangles de délimitation. Si une collision est détectée, soustrayez la valeur des dégâts de l’ennemi à la santé du joueur.
De plus, si le joueur quitte le haut de l’écran (player_y < ; 0), ajoutez 10 à sa santé et assurez-vous qu’elle ne dépasse pas la santé maximale. Cela crée une mécanique de guérison et réinitialise la position du joueur en bas de l’écran.
Créer un nouveau fichier nommé dommages-et-guérison.py et ajoutez le code avec les mises à jour ci-dessous :
# Inside the game loop, after updating the enemy position
# Detect collision between player and enemy
if player_x < enemy_x + enemy_width and \
player_x + player_width > enemy_x and \
player_y < enemy_y + enemy_height \
and player_y + player_height > enemy_y:
player_health -= enemy_damage
print(player_health)
# Heal the player when they move off the screen
if player_y < 0:
player_health += 10
print(player_health)
if player_health > max_health:
player_health = max_health
player_y = window_height - player_height - 10
Voici le résultat :
Gestion des scénarios de mort du joueur et de fin de partie
Pour gérer les scénarios de mort du joueur et de fin de partie, vous devez vérifier si la santé du joueur atteint zéro. Si c’est le cas, affichez un Fin de partie et redémarrer le jeu.
Ajout d’une vérification pour voir si la santé du joueur est inférieure ou égale à zéro. Si cette condition est vraie, on imprime Fin de partie et réinitialise la santé et la position du joueur.
Créer un nouveau fichier nommé manage-player-death.py et modifiez le code avec les mises à jour ci-dessous :
# After updating the player's position
# Check if player's health reaches zero
if player_health <= 0:
print("Game Over")
player_health = max_health
player_x = window_width // 2
player_y = window_height - player_height - 10
Ajout de fonctionnalités supplémentaires
Pour améliorer encore le système de santé, vous pouvez y intégrer des fonctionnalités supplémentaires. En voici un exemple :
Les bonus
Définissez les attributs du power-up, tels que ses dimensions et sa position. Définissez également une valeur de santé que le joueur gagnera lorsqu’il entrera en collision avec le power-up.
Dans la boucle du jeu, détecter les collisions entre le joueur et le power-up. Si une collision se produit, augmentez la santé du joueur de la valeur de santé du power-up, en veillant à ce qu’elle ne dépasse pas la santé maximale. Ensuite, repositionnez le power-up de manière aléatoire sur l’écran. Enfin, dessinez l’objet power-up sur l’écran à l’aide d’un rectangle bleu.
Créez un nouveau fichier nommé power-up.py et ajoutez le code avec les mises à jour ci-dessous :
# Define power-up attributes
power_up_width, power_up_height = 30, 30
power_up_x, power_up_y = 200,200
power_up_health_value = 50
# Inside the game loop, after updating the player's position
# Detect collision between player and power-up
if player_x < power_up_x + power_up_width and\
player_x + player_width > power_up_x \
and player_y < power_up_y + power_up_height\
and player_y + player_height > power_up_y:
player_health += power_up_health_value
if player_health > max_health:
player_health = max_health
power_up_x, power_up_y = 200,200
# Draw power-up object
pygame.draw.rect(window, (0, 0, 255),
(power_up_x, power_up_y,
power_up_width,
power_up_height))
Voici le résultat :
Pour chaque fonctionnalité supplémentaire, vous pouvez définir les variables et les constantes nécessaires et implémenter les mécanismes correspondants dans la boucle du jeu.
Meilleures pratiques pour les systèmes de santé
Lors de l’implémentation d’un système de santé dans PyGame, gardez à l’esprit les meilleures pratiques suivantes :
Mettre en œuvre des systèmes pilotés par les événements
Au lieu de vérifier continuellement les collisions ou les changements de santé dans la boucle du jeu, envisagez d’utiliser des systèmes pilotés par les événements. PyGame fournit des capacités de gestion d’événements, vous permettant de déclencher des actions liées à la santé en fonction d’événements spécifiques, tels que des événements de collision ou des événements de prise de pouvoir.
Équilibrer les valeurs de santé
Ajustez les valeurs de santé, les valeurs de dégâts et les taux de guérison de votre jeu pour garantir une expérience de jeu équilibrée. Les tests de jeu et les commentaires des joueurs peuvent vous aider à affiner ces valeurs pour une expérience de jeu optimale.
Donner son avis
Veillez à ce que le joueur reçoive des informations claires et significatives sur son état de santé. Affichez la barre de santé bien en évidence sur l’écran, utilisez des indices visuels tels que des changements de couleur ou des animations pour indiquer les dégâts ou les soins, et fournissez des indices sonores ou visuels lorsque la santé du joueur atteint des niveaux critiques.
En suivant ces bonnes pratiques, vous pouvez créer un système de santé robuste et attrayant qui contribue à une expérience de jeu immersive.
Rendre les jeux plus attrayants grâce à la barre de santé
La mise en place d’un système de santé n’ajoute pas seulement une couche de défi, mais rend également les jeux plus attrayants pour les joueurs. En incorporant des représentations visuelles de la santé, telles que des barres de santé, les joueurs peuvent facilement évaluer leur état actuel et prendre des décisions stratégiques. De plus, l’ajout de niveaux à votre jeu peut encore améliorer l’expérience de jeu.
