So implementieren Sie ein Gesundheitssystem in PyGame

Die Implementierung eines Gesundheitssystems in ein Spiel kann das Spielerlebnis erheblich verbessern und eine zusätzliche Herausforderungs- und Strategieebene hinzufügen. PyGame bietet eine Reihe robuster Tools und Funktionen zur Einbindung des Gesundheitssystems und erleichtert die Erstellung interaktiver Erlebnisse.

Erstellen Sie ein einfaches Spiel

Bevor Sie beginnen, stellen Sie sicher, dass Sie dies getan haben pip auf Ihrem System installiert. Verwenden Sie diesen Befehl, um die zu installieren Pygame Bibliothek:

Pip Pygame installieren

Erstellen Sie anschließend eine Datei mit dem Namen simple-game.py und beginnen Sie mit der Erstellung eines einfachen Spiels, bei dem sich der Spieler nach links und rechts bewegen kann.

Der in diesem Artikel verwendete Code ist hier verfügbar GitHub-Repository Die Nutzung steht Ihnen unter der MIT-Lizenz kostenlos zur Verfügung.

In dieser grundlegenden Spielschleife besteht das Ziel des Spielers darin, eine Kollision mit dem Feind zu vermeiden.

importieren Pygame
importieren willkürlich
# PyGame initialisieren
pygame.init()
# Richten Sie das Spielfenster ein
window_width, window_height = 800, 600
window = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption(„Demo zum Gesundheitssystem“)
# Spielerattribute
Spielerbreite, Spielerhöhe = 50, 50
player_x, player_y = window_width // 2, window_height - player_height - 10
player_speed = 1
# Feindattribute
feind_breite, feind_höhe = 50, 50
feind_x, feind_y = random.randint(0, Fensterbreite - Feindbreite), 0
feind_geschwindigkeit = 0.3
# Spielschleife
laufen = WAHR
während Betrieb:
für Fall In pygame.event.get():
Wenn event.type == pygame. AUFHÖREN:
 laufen = FALSCH
# Bewegen Sie den Player nach links oder rechts
 Schlüssel = pygame.key.get_pressed()
Wenn Schlüssel[pygame. K_LEFT] Und Spieler_x > 0:
 Spieler_x -= Spielergeschwindigkeit
Wenn Schlüssel[pygame. K_RIGHT] Und player_x < window_width - player_width:
 Spieler_x += Spielergeschwindigkeit
# Bewege den Feind nach unten
 feind_y += feind_geschwindigkeit
# Spielobjekte zeichnen
 window.fill((0, 0, 0)) # Löschen Sie den Bildschirm
 pygame.draw.rect (Fenster, (255, 0, 0), 
 (Spieler_x, Spieler_y, 
 player_width, player_height)) 
 pygame.draw.rect (Fenster, (0, 255, 0), 
 (Feind_x, Feind_y, 
 feind_breite, feind_höhe)) # Feind zeichnen
 pygame.display.update()
pygame.quit()

Führen Sie den Code aus und Sie sehen ein Fenster mit einem Spielercharakter, den Sie mit der linken und rechten Pfeiltaste steuern können.

Nachdem Sie nun über ein grundlegendes Spiel-Setup verfügen, definieren Sie die Variablen und Konstanten, die sich auf die Gesundheit des Spielers beziehen. Sie können ein einfaches Gesundheitssystem verwenden, bei dem Sie die Gesundheit eines Spielers durch einen numerischen Wert darstellen können. Sie können auch Konstanten für die maximale Gesundheit des Spielers und die Höhe des vom Feind verursachten Schadens definieren.

Stellen Sie die anfängliche Gesundheit des Spielers auf 100 ein, definieren Sie die maximale Gesundheit auf 100 und legen Sie den Schaden des Feindes auf 20 fest. Diese Werte können entsprechend den spezifischen Anforderungen Ihres Spiels angepasst werden.

# Spielergesundheit
player_health = 100
max_health = 100
feind_schaden = 20

Implementierung von Schadens- und Heilungsmechanismen

Um Schadens- und Heilungsmechanismen einzuführen, müssen Sie Kollisionen zwischen dem Spieler und dem Feind erkennen und die entsprechenden Gesundheitsänderungen bewältigen. Sie können auch einen Mechanismus implementieren, um den Spieler zu heilen, wenn er sich vom Bildschirm entfernt.

Überprüfen Sie, ob es eine gibt Kollision zwischen dem Spieler und dem Feind durch den Vergleich ihrer begrenzenden Rechtecke. Wenn eine Kollision erkannt wird, subtrahieren Sie den Schadenswert des Feindes von der Gesundheit des Spielers.

Wenn sich der Spieler außerdem über den oberen Bildschirmrand bewegt (Spieler_y < 0), addiere 10 zu ihrer Gesundheit und stelle sicher, dass sie die maximale Gesundheit nicht überschreitet. Dadurch wird ein Heilungsmechanismus erstellt und die Position des Spielers an den unteren Bildschirmrand zurückgesetzt.

Erstellen Sie eine neue Datei mit dem Namen Damage-and-Healing.py und fügen Sie den Code mit den folgenden Updates hinzu:

# Innerhalb der Spielschleife, nach Aktualisierung der Gegnerposition
# Kollision zwischen Spieler und Feind erkennen
Wenn Spieler_x < Feind_x + Feind_breite Und \
 Spieler_x + Spielerbreite > Feind_x Und \
 Spieler_y < Feind_y + Feind_Höhe \
Und Spieler_y + Spielerhöhe > Feind_y:
 Spielergesundheit -= Feind_Schaden
 drucken (player_health)
# Heile den Spieler, wenn er den Bildschirm verlässt
Wenn Spieler_y < 0:
 player_health += 10
 drucken (player_health)
Wenn Spielergesundheit > max_gesundheit:
 player_health = max_health
 player_y = window_height - player_height - 10

Unten ist die Ausgabe:

Verwalten von Spielertod- und Game-Over-Szenarien

Um die Todes- und Game-Over-Szenarien des Spielers zu bewältigen, müssen Sie prüfen, ob die Gesundheit des Spielers Null erreicht. Wenn dies der Fall ist, zeigen Sie a an Spiel ist aus Nachricht und starten Sie das Spiel neu.

Fügen Sie eine Prüfung hinzu, um zu sehen, ob die Gesundheit des Spielers unter oder gleich Null fällt. Wenn diese Bedingung erfüllt ist, drucken Sie Spiel ist aus und die Gesundheit und Position des Spielers zurücksetzen.

Erstellen Sie eine neue Datei mit dem Namen manage-player-death.py und ändern Sie den Code mit den folgenden Updates:

# Nach dem Aktualisieren der Position des Spielers
# Überprüfen Sie, ob die Gesundheit des Spielers Null erreicht
Wenn player_health <= 0:
 drucken("Spiel ist aus")
 player_health = max_health
 player_x = window_width // 2
 player_y = window_height - player_height - 10

Inklusive zusätzlicher Funktionen

Um das Gesundheitssystem weiter zu verbessern, können Sie zusätzliche Funktionen integrieren. Nachfolgend finden Sie ein Beispiel:

Einschalten

Definieren Sie die Attribute des Power-Ups, z. B. seine Abmessungen und Position. Legen Sie außerdem einen Gesundheitswert fest, den der Spieler erhält, wenn er mit dem Power-Up kollidiert.

Erkennen Sie innerhalb der Spielschleife Kollisionen zwischen dem Spieler und dem Power-Up. Wenn es zu einer Kollision kommt, erhöhen Sie die Gesundheit des Spielers um den Gesundheitswert des Power-Ups und achten Sie darauf, dass die maximale Gesundheit nicht überschritten wird. Positionieren Sie dann das Power-Up zufällig auf dem Bildschirm neu. Zeichnen Sie abschließend das Power-Up-Objekt mit einem blauen Rechteck auf den Bildschirm.

Erstellen Sie eine neue Datei mit dem Namen power-up.py und fügen Sie den Code mit den folgenden Updates hinzu:

# Definieren Sie Einschaltattribute
power_up_width, power_up_height = 30, 30
power_up_x, power_up_y = 200,200
power_up_health_value = 50
# Innerhalb der Spielschleife, nachdem die Position des Spielers aktualisiert wurde
# Kollision zwischen Spieler und Power-Up erkennen
Wenn player_x < power_up_x + power_up_width Und\
 player_x + player_width > power_up_x \
Und player_y < power_up_y + power_up_height\
Und player_y + player_height > power_up_y:
 player_health += power_up_health_value
Wenn Spielergesundheit > max_gesundheit:
 player_health = max_health
 power_up_x, power_up_y = 200,200
# Einschaltobjekt zeichnen
pygame.draw.rect (Fenster, (0, 0, 255), 
 (power_up_x, power_up_y, 
 power_up_width, 
 power_up_height))

Unten ist die Ausgabe:

Für jedes zusätzliche Feature können Sie die notwendigen Variablen und Konstanten definieren und die entsprechende Mechanik innerhalb der Spielschleife implementieren.

Best Practices für das Gesundheitssystem

Beachten Sie bei der Implementierung eines Gesundheitssystems in PyGame die folgenden Best Practices:

Implementieren Sie ereignisgesteuerte Systeme

Anstatt ständig nach Kollisionen oder Gesundheitsänderungen innerhalb der Spielschleife zu suchen, sollten Sie den Einsatz ereignisgesteuerter Systeme in Betracht ziehen. PyGame bietet Funktionen zur Ereignisbehandlung, mit denen Sie gesundheitsbezogene Aktionen basierend auf bestimmten Ereignissen auslösen können, z. B. Kollisionsereignisse oder Einschaltereignisse.

Gesundheitswerte in Einklang bringen

Passen Sie die Gesundheitswerte, Schadenswerte und Heilungsraten in Ihrem Spiel an, um ein ausgewogenes Spielerlebnis zu gewährleisten. Durch Spieltests und das Sammeln von Feedback von Spielern können Sie diese Werte für ein optimales Gameplay optimieren.

Rückmeldung geben

Stellen Sie sicher, dass der Spieler ein klares und aussagekräftiges Feedback zu seinem Gesundheitszustand erhält. Zeigen Sie die Gesundheitsleiste deutlich auf dem Bildschirm an, verwenden Sie visuelle Hinweise wie Farbänderungen oder Animationen, um Schaden oder Heilung anzuzeigen, und Geben Sie akustische oder visuelle Hinweise wenn die Gesundheit des Spielers ein kritisches Niveau erreicht.

Indem Sie diese Best Practices befolgen, können Sie ein robustes und ansprechendes Gesundheitssystem schaffen, das zu einem immersiven Spielerlebnis beiträgt.

Machen Sie Spiele mit Health Bar spannender

Die Implementierung eines Gesundheitssystems stellt nicht nur eine zusätzliche Herausforderung dar, sondern macht Spiele für die Spieler auch spannender. Durch die Einbindung visueller Gesundheitsdarstellungen, wie z. B. Gesundheitsbalken, können Spieler ihren aktuellen Status leicht beurteilen und strategische Entscheidungen treffen. Darüber hinaus kann das Hinzufügen von Leveln zu Ihrem Spiel das Spielerlebnis weiter verbessern.