Introduisez des éléments tels que les dégâts des joueurs, les mécanismes de guérison, etc. en incorporant un système de santé dans vos jeux.

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 intégrer le système de santé, ce qui facilite la création d'expériences interactives.

Créer un jeu simple

Avant de commencer, assurez-vous d'avoir pip installé sur votre système. Utilisez cette commande pour installer le pygame bibliothèque:

pip installer pygame

Après cela, créez un fichier nommé jeu-simple.py et commencez par créer un jeu simple où le joueur peut se déplacer à gauche et à droite.

Le code utilisé dans cet article est disponible dans ce Référentiel GitHub et est libre d'utilisation sous la licence MIT.

Dans cette boucle de jeu de base, l'objectif du joueur sera d'éviter d'entrer en collision avec l'ennemi.

importer pygame

importer aléatoire
# Initialiser PyGame
pygame.init()


# Configurer la fenêtre de jeu
largeur_fenêtre, hauteur_fenêtre = 800, 600
fenêtre = pygame.display.set_mode((largeur_fenêtre, hauteur_fenêtre))
pygame.display.set_caption(« Démo du système de santé »)


# Attributs du joueur
largeur_joueur, hauteur_joueur = 50, 50
player_x, player_y = window_width // 2, hauteur_fenêtre - hauteur_joueur - 10
player_speed = 1


# Attributs ennemis
largeur_ennemie, hauteur_ennemie = 50, 50
ennemi_x, ennemi_y = random.randint(0, largeur_fenêtre - largeur_ennemi), 0
vitesse_ennemie = 0.3


# Boucle de jeu
courir = Vrai
alors que en cours d'exécution:
pour événement dans pygame.event.get() :
si événement.type == pygame. ARRÊTER:
 courir = FAUX


# Déplacer le joueur vers la gauche ou vers la droite
 clés = pygame.key.get_pressed()
si clés[pygame. K_LEFT] et joueur_x > 0:
 joueur_x -= vitesse_joueur
si clés[pygame. K_RIGHT] et player_x < window_width - player_width :
 player_x += player_speed


# Déplacez l'ennemi vers le bas
 ennemi_y += vitesse_ennemie


# Dessiner des objets de jeu
 fenêtre.fill((0, 0, 0)) # Effacer l'écran
 pygame.draw.rect (fenêtre, (255, 0, 0), 
 (joueur_x, joueur_y, 
 player_width, player_height)) 
 pygame.draw.rect (fenêtre, (0, 255, 0), 
 (ennemi_x, ennemi_y, 
 ennemi_largeur, ennemi_hauteur)) # Dessiner l'ennemi
 pygame.display.update()
pygame.quit()

Exécutez le code et vous verrez une fenêtre avec un personnage de joueur que vous pouvez contrôler à l'aide des touches fléchées gauche et droite.

Maintenant que vous avez 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 où vous pouvez représenter 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.

Réglez la santé initiale du joueur sur 100, définissez la santé maximale sur 100 et définissez les dégâts de l'ennemi sur 20. Ces valeurs peuvent être ajustées en fonction des besoins spécifiques de votre jeu.

# Santé du joueur
player_health = 100
santé_max = 100
dégâts_ennemis = 20

Mise en œuvre des mécanismes de dégâts et de guérison

Pour introduire des mécanismes de dégâts et de guérison, vous devez détecter les collisions entre le joueur et l'ennemi et gérer les changements de santé correspondants. Vous pouvez également implémenter un mécanisme pour soigner le joueur lorsqu'il quitte l'écran.

Vérifiez s'il y a un collision entre le joueur et l'ennemi en comparant leurs rectangles englobants. Si une collision est détectée, soustrayez la valeur des dégâts de l'ennemi de la santé du joueur.

De plus, si le joueur quitte le haut de l'écran (joueur_y < 0), ajoutez 10 à leur santé et assurez-vous qu'elle ne dépasse pas la santé maximale. Cela crée un mécanisme de guérison et réinitialise la position du joueur au bas de l'écran.

Créer un nouveau fichier nommé dommage-et-guérison.py et ajoutez le code avec les mises à jour ci-dessous :

# À l'intérieur de la boucle de jeu, après avoir mis à jour la position de l'ennemi
# Détecter la collision entre le joueur et l'ennemi
si joueur_x < ennemi_x + ennemi_largeur et \
 player_x + player_width > ennemi_x et \
 joueur_y < ennemi_y + ennemi_height \
et joueur_y + joueur_hauteur > ennemi_y :
 santé_joueur -= dégâts_ennemis
 imprimer (player_health)
# Soignez le joueur lorsqu'il quitte l'écran
si joueur_y < 0:
 player_health += 10
 imprimer (player_health)
si player_health > max_health :
 joueur_santé = max_santé
 player_y = window_height - player_height - 10

Ci-dessous la sortie :

Gestion des scénarios de décès et de fin de partie

Pour gérer les scénarios de mort et de fin de partie du joueur, vous devez vérifier si la santé du joueur atteint zéro. Si c'est le cas, affichez un Jeu terminé message et redémarrez le jeu.

Ajoutez une vérification pour voir si la santé du joueur est inférieure ou égale à zéro. Si cette condition est vraie, imprimez Jeu terminé et réinitialiser la santé et la position du joueur.

Créer un nouveau fichier nommé gérer-joueur-death.py et modifiez le code avec les mises à jour ci-dessous :

# Après avoir mis à jour la position du joueur
# Vérifiez si la santé du joueur atteint zéro
si player_health <= 0:
 imprimer("Jeu terminé")
 joueur_santé = max_santé
 player_x = window_width // 2
 player_y = window_height - player_height - 10

Inclure des fonctionnalités supplémentaires

Pour améliorer encore le système de santé, vous pouvez intégrer des fonctionnalités supplémentaires. Ci-dessous un exemple :

Mises sous tension

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 en entrant en collision avec le power-up.

Dans la boucle du jeu, détectez 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 vous assurant qu'elle ne dépasse pas la santé maximale. Repositionnez ensuite le power-up au hasard sur l'écran. Enfin, dessinez l'objet power-up sur l'écran à l'aide d'un rectangle bleu.

Créer un nouveau fichier nommé power-up.py et ajoutez le code avec les mises à jour ci-dessous :

# Définir les attributs de mise sous tension
power_up_width, power_up_height = 30, 30
power_up_x, power_up_y = 200,200
power_up_health_value = 50
# À l'intérieur de la boucle de jeu, après avoir mis à jour la position du joueur
# Détecter la collision entre le joueur et la mise sous tension
si player_x < power_up_x + power_up_width et\
 player_x + player_width > power_up_x \
et player_y < power_up_y + power_up_height\
et player_y + player_height > power_up_y :
 player_health += power_up_health_value
si player_health > max_health :
 joueur_santé = max_santé
 power_up_x, power_up_y = 200,200
# Dessiner un objet de mise sous tension
pygame.draw.rect (fenêtre, (0, 0, 255), 
 (power_up_x, power_up_y, 
 power_up_width, 
 power_up_height))

Ci-dessous la sortie :

Pour chaque fonctionnalité supplémentaire, vous pouvez définir les variables et constantes nécessaires, et implémenter les mécanismes correspondants dans la boucle de jeu.

Meilleures pratiques pour le système de santé

Lors de la mise en œuvre d'un système de santé dans PyGame, gardez à l'esprit les bonnes pratiques suivantes :

Mettre en œuvre des systèmes pilotés par les événements

Au lieu de vérifier en permanence les collisions ou les changements de santé dans la boucle de jeu, envisagez d'utiliser des systèmes pilotés par les événements. PyGame fournit des fonctionnalités de gestion des é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 mise sous tension.

Équilibrer les valeurs de santé

Ajustez les valeurs de santé, les valeurs de dégâts et les taux de guérison dans votre jeu pour garantir une expérience de jeu équilibrée. Les tests de jeu et la collecte des commentaires des joueurs peuvent vous aider à affiner ces valeurs pour un gameplay optimal.

Fournir une réponse

Assurez-vous que le joueur reçoit des commentaires clairs et significatifs concernant son état de santé. Affichez la barre de santé bien en évidence sur l'écran, utilisez des repères visuels tels que des changements de couleur ou des animations pour indiquer les dommages ou la guérison, et fournir des repères audio ou visuels lorsque la santé du joueur atteint des niveaux critiques.

En suivant ces meilleures pratiques, vous pouvez créer un système de santé robuste et engageant qui contribue à une expérience de jeu immersive.

Rendez les jeux plus engageants avec la barre de santé

La mise en œuvre d'un système de santé ajoute non 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.