Möchten Sie den Umgang Ihres Spiels mit Gefahren verfeinern? Verwandeln Sie Leben in Gesundheit und verleihen Sie Ihrem Gameplay eine zusätzliche Dimension.

Das Hinzufügen eines Gesundheitssystems zu Ihrem Arcade-Spiel kann das Spielerlebnis verbessern und eine zusätzliche Ebene der Herausforderung und des Engagements hinzufügen. Sie können ein noch intensiveres Spielerlebnis schaffen, indem Sie die Gesundheit des Spielers sowie die Mechanismen für Schaden und Heilung anzeigen.

Glücklicherweise ist die Implementierung eines Gesundheitssystems in Python mithilfe der Arcade-Bibliothek unkompliziert und erfordert nur wenige Schritte.

Erstellen Sie ein einfaches Spiel

Erste, Installieren Sie Pip auf Ihrem Gerät und verwenden Sie den folgenden Befehl, um die Arcade-Bibliothek zu installieren:

Pip Arcade installieren

Beginnen Sie anschließend mit der Erstellung eines einfachen Spiels mithilfe der Arcade-Bibliothek. In diesem Spiel gibt es einen Spielercharakter, der sich nach links, rechts, oben und unten bewegen kann, sowie ein feindliches Objekt, das eine Bedrohung für den Spieler darstellt.

instagram viewer

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

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

importieren Arkade
# Fensterabmessungen festlegen
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


# Bewegungsgeschwindigkeit des Spielers festlegen
PLAYER_MOVEMENT_SPEED = 5
weiß = arcade.color. WEISS
blau = arcade.color. BLAU
rot = arcade.color. ROT


KlasseGameWindow(Arkade. Fenster):
def__drin__(Selbst, Breite, Höhe):
 super().__init__(Breite, Höhe)
 arcade.set_background_color (weiß)


# Erstelle Spieler- und Feindobjekte
 self.player = Arcade. SpriteCircle(30, Blau)
 self.enemy = Arcade. SpriteCircle(30, Rot)
 self.player.center_x = 100
 self.player.center_y = 100
 self.enemy.center_x = 400
 self.enemy.center_y = 300


defon_draw(selbst):
 arcade.start_render()
 self.player.draw()
 self.enemy.draw()


defaktualisieren(self, delta_time):
passieren


defon_key_press(selbst, Schlüssel, Modifikatoren):
Wenn Schlüssel == arcade.key. LINKS:
 self.player.center_x -= PLAYER_MOVEMENT_SPEED
elif Schlüssel == arcade.key. RECHTS:
 self.player.center_x += PLAYER_MOVEMENT_SPEED
elif Schlüssel == arcade.key. HOCH:
 self.player.center_y += PLAYER_MOVEMENT_SPEED
elif Schlüssel == arcade.key. RUNTER:
 self.player.center_y -= PLAYER_MOVEMENT_SPEED


defhauptsächlich():
 game = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
Wenn __name__ == "__hauptsächlich__":
 hauptsächlich()

Sie sollten ein Fenster mit zwei Zeichen sehen, dargestellt durch blaue und rote Kreise:

Um das Gesundheitssystem zu implementieren, definieren Sie Variablen und Konstanten im Zusammenhang mit der Gesundheit. Sie verwenden sie, um die aktuelle Gesundheit des Spielers im Auge zu behalten und die Regeln für Schaden und Heilung festzulegen. Fügen Sie den folgenden Code hinzu GameWindow Klasse:

KlasseGameWindow(Arkade. Fenster):
def__drin__(Selbst, Breite, Höhe):
# ...
# Gesundheitsbezogene Variablen und Konstanten
 self.player_health = 100
# Pro Sekunde geheilte Gesundheitspunkte
 self.heal_rate = 1


# Timer für die Heilung
 self.heal_timer = 0


defaktualisieren(self, delta_time):
# ...
# Heilungstimer aktualisieren
 self.heal_timer += delta_time


# Heilt alle 2 Sekunden die Gesundheit des Spielers
Wenn self.heal_timer >= 2:
 self.player_health += self.heal_rate
 self.heal_timer = 0
# Stellen Sie sicher, dass die Gesundheit den Maximalwert nicht überschreitet
Wenn self.player_health > 100:
 self.player_health = 100

Implementierung von Schadens- und Heilungsmechanismen

Um die Schadens- und Heilungsmechanismen zu implementieren, Erkennen Sie Kollisionen zwischen dem Spieler und dem Feind. Reduzieren Sie die Gesundheit des Spielers, wenn er mit dem Feind kollidiert, und heilen Sie die Gesundheit des Spielers alle 2 Sekunden, wenn er nicht kollidiert. Modifiziere den aktualisieren() -Methode und fügen Sie den folgenden Code hinzu:

KlasseGameWindow(Arkade. Fenster):
def__drin__(Selbst, Breite, Höhe):
# ...
defaktualisieren(self, delta_time):
# Kollisionen zwischen Spieler und Feind erkennen
Wenn arcade.check_for_collision (self.player, self.enemy):
 self.player_health -= 5
# ...

Verwalten von Spielertod- und Game-Over-Szenarien

Um Spielertod- und Game-Over-Szenarien zu verwalten, überprüfen Sie, ob die Gesundheit des Spielers Null oder weniger erreicht. Wenn die Gesundheit auf Null sinkt, betrachten Sie den Spieler als tot und beenden Sie das Spiel. Modifiziere den aktualisieren() Methode mit folgendem Code:

KlasseGameWindow(Arkade. Fenster):
def__drin__(Selbst, Breite, Höhe):
# ...
defaktualisieren(self, delta_time):
# ...


# Überprüfen Sie, ob die Gesundheit des Spielers Null oder darunter liegt
Wenn self.player_health <= 0:
# Beende das Spiel
 arcade.close_window()
# ...

Visualisierung der Gesundheitsleiste

Eine visuelle Darstellung der Gesundheit des Spielers kann das Spielerlebnis erheblich verbessern. Erstellen Sie eine Gesundheitsleiste mit Rechtecken, um den aktuellen Gesundheitszustand anzuzeigen. Erstellen Sie eine neue Datei mit dem Namen gesundheit-bar.py und fügen Sie den Code mit den folgenden Updates hinzu:

KlasseGameWindow(Arkade. Fenster):
def__drin__(Selbst, Breite, Höhe):
# ...
defon_draw(selbst):
 arcade.start_render()
 self.player.draw()
 self.enemy.draw()
 grau = arcade.color. HELLGRAU
 grün = arcade.color. GRÜN


# Gesundheitsbalken zeichnen
 arcade.draw_rectangle_filled (SCREEN_WIDTH // 2, 20, 
 BILDSCHIRMBREITE, 20, grau)


 health_width = self.player_health / 100 * BILDSCHIRMBREITE
 arcade.draw_rectangle_filled (health_width // 2, 20, 
 gesundheitsbreite, 20, Grün)

Unten ist die Ausgabe:

Inklusive zusätzlicher Funktionen

Sie können das Gesundheitssystem mit weiteren Funktionen wie den folgenden weiter verbessern.

Numerische Gesundheitsanzeige

Zusätzlich zur Gesundheitsleiste können Sie die verbleibende Gesundheit als numerischen Wert auf dem Bildschirm anzeigen. Dies gibt einen genauen Hinweis auf den Gesundheitszustand des Spielers. Fügen Sie den folgenden Code hinzu on_draw() Methode:

# Innerhalb der on_draw()-Methode
schwarz = arcade.color. SCHWARZ
Text = f"Gesundheit: {self.player_health}"
arcade.draw_text (Text, 10, 10, Schwarz, 14)

Gesundheits-Power-Ups

Um Gesundheits-Power-Ups einzuführen, können Sie spezielle Objekte erstellen, die die Gesundheit des Spielers steigern, wenn er mit ihnen kollidiert. Hier ist ein Beispiel dafür, wie Sie diese Funktion implementieren können:

# Innerhalb der update()-Methode
Wenn arcade.check_for_collision (self.player, self.power_up):
 self.player_health += 20
# Entferne das Power-Up aus dem Spiel
 self.power_up.kill()

Verschiedene Feindtypen

Um Ihrem Spiel Tiefe zu verleihen, können Sie verschiedene Gegnertypen einführen, die dem Spieler unterschiedlich hohen Schaden zufügen. Dies fügt ein strategisches Element hinzu und ermöglicht vielfältigere Spielerlebnisse. Hier ist eine Implementierung dieser Funktion:

# Innerhalb der update()-Methode
Wenn arcade.check_for_collision (self.player, self.enemy):
Wenn self.enemy.type == "schwach":
 self.player_health -= 5
elif self.enemy.type == "stark":
 self.player_health -= 20

Durch die Integration dieser zusätzlichen Funktionen in die Implementierung Ihres Gesundheitssystems können Sie dynamischere und herausforderndere Spielerlebnisse für Ihre Spieler schaffen.

Best Practices für das Gesundheitssystem

Bei der Implementierung eines Gesundheitssystems in Ihr Arcade-Spiel ist es wichtig, Best Practices zu befolgen, um sicherzustellen, dass das System robust und effizient ist. Hier sind einige der Best Practices, die Sie beachten sollten:

Machen Sie es modular

Behalten Sie die Funktionalität des Gesundheitssystems in einer separaten Klasse oder einem separaten Modul, um es modular und für verschiedene Spielprojekte einfach wiederverwendbar zu halten. Dies fördert die Codeorganisation und die Trennung von Belangen.

Eingabevalidierung und Schutzmaßnahmen

Implementieren Sie eine Eingabevalidierung, um zu verhindern, dass Ihr Code ungültige Integritätswerte zuweist. Dieselben Schutzmaßnahmen sollen vor ungültigen Gesundheitswerten schützen, wenn Schäden oder Heilung auftreten.

Speicher- und Lademechanismus

Implementieren Sie einen Speicher- und Lademechanismus, der den Gesundheitszustand des Spielers berücksichtigt. Dies ermöglicht es den Spielern, das Spiel mit intaktem Fortschritt, einschließlich ihrer Gesundheit, fortzusetzen, selbst nachdem sie das Spiel verlassen haben.

Testen und Fehlerbehandlung

Testen Sie die Implementierung des Gesundheitssystems gründlich, um ihre Richtigkeit und Zuverlässigkeit zu überprüfen. Verwenden Sie geeignete Fehlerbehandlungstechniken, um Ausnahmen und Randfälle effektiv zu behandeln.

Konsistentes Gesundheitsfeedback

Geben Sie dem Spieler konsistentes und klares Feedback zu seinem Gesundheitszustand. Sie können Audioeffekte hinzufügen, visuelle Hinweise oder sogar haptisches Feedback, um sicherzustellen, dass die Spieler ihren Gesundheitszustand im Spiel kennen und während des Spiels fundierte Entscheidungen treffen können.

Indem Sie diese Best Practices befolgen, können Sie ein robustes und effektives Gesundheitssystem erstellen, das das Spielerlebnis Ihres Arcade-Spiels verbessert und gleichzeitig die Qualität und Lesbarkeit des Codes beibehält.

Mit dem Gesundheitssystem machen Spiele mehr Spaß

Das Hinzufügen eines Gesundheitssystems zu Ihrem Spiel kann das Spielerlebnis insgesamt erheblich verbessern. Es bringt ein Risiko- und Herausforderungselement mit sich, wodurch das Gameplay spannender und lohnender wird.

Eine visuelle Darstellung des Gesundheitszustands ermöglicht es den Spielern, ihren aktuellen Status einfach einzuschätzen, wodurch die Immersion und die strategische Entscheidungsfindung verbessert werden.