Vous cherchez à affiner la gestion du danger de votre jeu? Transformez des vies en santé et ajoutez une dimension supplémentaire à votre jeu.

L'ajout d'un système de santé à votre jeu d'arcade peut améliorer l'expérience du joueur et peut ajouter une couche supplémentaire de défi et d'engagement. Vous pouvez créer une expérience de jeu plus immersive avec un affichage de la santé du joueur et des mécanismes de dégâts et de soins.

Heureusement, la mise en œuvre d'un système de santé en Python à l'aide de la bibliothèque Arcade est simple et ne nécessite que quelques étapes.

Créer un jeu simple

D'abord, installer pip sur votre appareil et utilisez la commande ci-dessous pour installer la bibliothèque d'arcade :

pip installer arcade

Après cela, commencez par créer un jeu simple en utilisant la bibliothèque Arcade. Ce jeu mettra en vedette un personnage joueur qui peut se déplacer à gauche, à droite, en haut et en bas et un objet ennemi qui constitue une menace pour le joueur.

Le code utilisé dans cet article est disponible dans ce

instagram viewer
Référentiel GitHub et est libre d'utilisation sous la licence MIT.

Créer un nouveau fichier nommé jeu-simple.py et ajoutez le code ci-dessous :

importer arcade
# Définir les dimensions de la fenêtre
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


# Définir la vitesse de déplacement du joueur
PLAYER_MOVEMENT_SPEED = 5
blanc = arcade.couleur. BLANC
bleu = arcade.color. BLEU
rouge = arcade.color. ROUGE


classeFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
 super().__init__(largeur, hauteur)
 arcade.set_background_color (blanc)


# Créer des objets joueurs et ennemis
 self.player = arcade. SpriteCercle(30, bleu)
 self.enemy = arcade. SpriteCercle(30, rouge)
 self.player.center_x = 100
 self.player.center_y = 100
 self.enemy.center_x = 400
 self.enemy.center_y = 300


définitivementon_draw(soi):
 arcade.start_render()
 self.player.draw()
 self.enemy.draw()


définitivementmise à jour(soi, delta_time):
passer


définitivementon_key_press(soi, clé, modificateurs):
si clé == arcade.clé. GAUCHE:
 self.player.center_x -= PLAYER_MOVEMENT_SPEED
elif clé == arcade.clé. DROITE:
 self.player.center_x += PLAYER_MOVEMENT_SPEED
elif clé == arcade.clé. EN HAUT:
 self.player.center_y += PLAYER_MOVEMENT_SPEED
elif clé == arcade.clé. BAS:
 self.player.center_y -= PLAYER_MOVEMENT_SPEED


définitivementprincipal():
 jeu = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
si __nom__ == "__principal__":
 principal()

Vous devriez voir une fenêtre contenant deux caractères, représentés par des cercles bleus et rouges :

Pour mettre en œuvre le système de santé, définir des variables et des constantes liées à la santé. Vous les utiliserez pour garder une trace de la santé actuelle du joueur et déterminer les règles de dégâts et de soins. Ajoutez le code suivant dans le Fenêtre de jeu classe:

classeFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
# ...
# Variables et constantes liées à la santé
 self.player_health = 100
# Points de santé guéris par seconde
 self.heal_rate = 1


# Minuterie pour la guérison
 self.heal_timer = 0


définitivementmise à jour(soi, delta_time):
# ...
# Mettre à jour la minuterie de guérison
 self.heal_timer += delta_time


# Soignez la santé du joueur toutes les 2 secondes
si self.heal_timer >= 2:
 self.player_health += self.heal_rate
 self.heal_timer = 0
# Assurez-vous que la santé ne dépasse pas la valeur maximale
si self.player_health > 100:
 self.player_health = 100

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

Pour mettre en œuvre les mécanismes de dégâts et de guérison, détecter les collisions entre le joueur et l'ennemi. Réduit la santé du joueur lorsqu'il entre en collision avec l'ennemi et soigne la santé du joueur toutes les 2 secondes lorsqu'il n'entre pas en collision. Modifier le mise à jour() méthode et ajoutez le code suivant :

classeFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
# ...
définitivementmise à jour(soi, delta_time):
# Détecter les collisions entre le joueur et l'ennemi
si arcade.check_for_collision (self.player, self.enemy):
 self.player_health -= 5
# ...

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

Pour gérer les scénarios de mort de joueur et de fin de partie, vérifiez si la santé du joueur atteint zéro ou moins. Si la santé tombe à zéro, considérez le joueur comme mort et terminez la partie. Modifier le mise à jour() méthode avec le code suivant :

classeFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
# ...
définitivementmise à jour(soi, delta_time):
# ...


# Vérifiez si la santé du joueur est nulle ou inférieure
si self.player_health <= 0:
# Terminer le jeu
 arcade.close_window()
# ...

Visualiser la barre de santé

Une représentation visuelle de la santé du joueur peut grandement améliorer l'expérience de jeu. Créez une barre de santé à l'aide de rectangles pour afficher le niveau de santé actuel. Créer un nouveau fichier nommé santé-bar.py et ajoutez le code avec les mises à jour ci-dessous :

classeFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
# ...
définitivementon_draw(soi):
 arcade.start_render()
 self.player.draw()
 self.enemy.draw()
 gris = arcade.color. GRIS CLAIR
 vert = arcade.color. VERT


# Dessiner la barre de santé
 arcade.draw_rectangle_filled (SCREEN_WIDTH // 2, 20, 
 SCREEN_WIDTH, 20, gris)


 health_width = self.player_health / 100 * SCREEN_WIDTH
 arcade.draw_rectangle_filled (health_width // 2, 20, 
 santé_largeur, 20, vert)

Ci-dessous la sortie :

Inclure des fonctionnalités supplémentaires

Vous pouvez encore améliorer le système de santé avec plus de fonctionnalités, comme celles ci-dessous.

Affichage numérique de la santé

En plus de la barre de santé, vous pouvez afficher la santé restante sous forme de valeur numérique à l'écran. Cela fournit une indication précise de l'état de santé du joueur. Ajoutez le code suivant dans le on_draw() méthode:

# Dans la méthode on_draw()
noir = arcade.couleur. NOIR
texte = f"Santé: {self.player_health}"
arcade.draw_text (texte, 10, 10, noir, 14)

Bonus de santé

Pour introduire des bonus de santé, vous pouvez créer des objets spéciaux qui améliorent la santé du joueur lorsqu'ils entrent en collision avec eux. Voici un exemple d'implémentation de cette fonctionnalité :

# Dans la méthode update()
si arcade.check_for_collision (self.player, self.power_up):
 self.player_health += 20
# Supprimer le power-up du jeu
 self.power_up.kill()

Types d'ennemis variés

Pour ajouter de la profondeur à votre jeu, vous pouvez introduire différents types d'ennemis qui infligent différents niveaux de dégâts au joueur. Cela ajoute un élément stratégique et permet des expériences de jeu plus diversifiées. Voici une implémentation de cette fonctionnalité :

# Dans la méthode update()
si arcade.check_for_collision (self.player, self.enemy):
si self.enemy.type == "faible":
 self.player_health -= 5
elif self.enemy.type == "fort":
 self.player_health -= 20

En intégrant ces fonctionnalités supplémentaires dans la mise en œuvre de votre système de santé, vous pouvez créer des expériences de jeu plus dynamiques et stimulantes pour vos joueurs.

Meilleures pratiques pour le système de santé

Lors de la mise en œuvre d'un système de santé dans votre jeu d'arcade, il est important de suivre les meilleures pratiques pour s'assurer que le système est robuste et efficace. Voici quelques-unes des meilleures pratiques à garder à l'esprit :

Rendez-le modulaire

Conservez la fonctionnalité du système de santé dans une classe ou un module distinct pour qu'elle reste modulaire et facilement réutilisable dans différents projets de jeu. Cela favorise l'organisation du code et la séparation des préoccupations.

Validation des entrées et sauvegardes

Implémentez la validation des entrées pour empêcher votre code d'attribuer des valeurs d'intégrité non valides. Les mêmes garanties devraient protéger contre les valeurs de santé invalides en cas de dommages ou de guérison.

Mécanisme de sauvegarde et de chargement

Implémentez un mécanisme de sauvegarde et de chargement qui inclut l'état de santé du joueur. Cela permet aux joueurs de reprendre le jeu avec leur progression intacte, y compris leur santé, même après avoir quitté le jeu.

Test et gestion des erreurs

Testez minutieusement la mise en œuvre du système de santé pour vérifier son exactitude et sa fiabilité. Utilisez des techniques de gestion des erreurs appropriées pour gérer efficacement les exceptions et les cas extrêmes.

Rétroaction cohérente sur la santé

Fournissez au joueur des informations cohérentes et claires sur son état de santé. Vous pouvez ajouter des effets audio, des repères visuels ou même des retours haptiques, garantissant que les joueurs connaissent leur état de santé dans le jeu et peuvent prendre des décisions éclairées pendant le jeu.

En suivant ces meilleures pratiques, vous pouvez créer un système de santé robuste et efficace qui améliore l'expérience de jeu de votre jeu d'arcade tout en maintenant la qualité et la lisibilité du code.

Rendez les jeux plus amusants avec le système de santé

L'ajout d'un système de santé à votre jeu peut considérablement améliorer l'expérience globale du joueur. Il introduit un élément de risque et de défi, rendant le gameplay plus engageant et gratifiant.

Une représentation visuelle de la santé permet aux joueurs d'évaluer facilement leur état actuel, augmentant l'immersion et la prise de décision stratégique.