So implementieren Sie Spielebenen in Pythons Arcade

Spieleentwicklung ist ein spannender und kreativer Prozess, der es Ihnen ermöglicht, Ihre fantasievollen Ideen zum Leben zu erwecken. Beim Entwerfen eines Spiels ist die Implementierung von Spielebenen eines der Schlüsselelemente, die das Spielerlebnis erheblich verbessern können.

Level bieten Struktur, Fortschritt und Herausforderungen und geben den Spielern beim Navigieren durch die verschiedenen Phasen des Spiels ein Gefühl von Erfolg und Engagement.

Erstellen Sie ein einfaches Spiel

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

Pip Arcade installieren

Erstellen Sie ein Grundspiel, 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.

Nutzen Sie die Funktionen der Arcade-Bibliothek, um Benutzereingaben zu verarbeiten und den Spielstatus entsprechend zu aktualisieren. Erstellen Sie eine neue Datei mit dem Namen simple-game.py und fügen Sie den folgenden Code hinzu:

importieren Arkade
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
KlasseMein Spiel(Arkade. Fenster):
def__drin__(selbst):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mein Spiel")
 arcade.set_background_color (arcade.color. WEISS)
 self.player_x = SCREEN_WIDTH // 2
defon_draw(selbst):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arcade.color. BLAU)
defon_key_press(selbst, Schlüssel, Modifikatoren):
Wenn Schlüssel == arcade.key. LINKS:
 self.player_x -= 10
elif Schlüssel == arcade.key. RECHTS:
 self.player_x += 10
defon_key_release(selbst, Schlüssel, Modifikatoren):
Wenn Schlüssel == arcade.key. LINKS oder Schlüssel == arcade.key. RECHTS:
passieren
defhauptsächlich():
 game = MyGame()
 arcade.run()
Wenn __name__ == "__hauptsächlich__":
 hauptsächlich()

Unten ist die Ausgabe:

Erstellen Sie mehrere Ebenen

Erweitern Sie nun das Spiel, indem Sie mehrere Level hinzufügen. Jedes Level hat seine eigenen einzigartigen Eigenschaften und stellt den Spieler vor unterschiedliche Herausforderungen. Sie können den vorherigen Code ändern, um zusätzliche Ebenen einzuschließen. Hier ist ein Beispiel:

KlasseLevel eins:
def__drin__(selbst):
 self.player_x = SCREEN_WIDTH // 2
defaktualisieren(selbst):
passieren
defziehen(selbst):
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arcade.color. BLAU)
KlasseLevelTwo:
def__drin__(selbst):
 self.player_x = SCREEN_WIDTH // 2
defaktualisieren(selbst):
passieren
defziehen(selbst):
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arcade.color. ROT)
KlasseMein Spiel(Arkade. Fenster):
def__drin__(selbst):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mein Spiel")
 arcade.set_background_color (arcade.color. WEISS)
 self.levels = [LevelOne(), LevelTwo()]
 self.current_level = 0
defon_draw(selbst):
 arcade.start_render()
 self.levels[self.current_level].draw()
defon_key_press(selbst, Schlüssel, Modifikatoren):
Wenn Schlüssel == arcade.key. LINKS:
 self.levels[self.current_level].player_x -= 10
elif Schlüssel == arcade.key. RECHTS:
 self.levels[self.current_level].player_x += 10
defon_key_release(selbst, Schlüssel, Modifikatoren):
Wenn Schlüssel == arcade.key. LINKS oder Schlüssel == arcade.key. RECHTS:
passieren
defaktualisieren(self, delta_time):
 self.levels[self.current_level].update()
defhauptsächlich():
 game = MyGame()
 arcade.run()
Wenn __name__ == "__hauptsächlich__":
 hauptsächlich()

Übergang zwischen Ebenen

Um einen reibungslosen Übergang zwischen den Levels zu schaffen, erkennen Sie, wann der Spieler eine bestimmte Grenze überschreitet. Du kannst Verfolgen Sie die Bewegung des Spielers, und sobald der Spieler die Grenze überschreitet, können Sie zum nächsten Level wechseln. Erstellen Sie eine neue Datei mit dem Namen Transition-between-levels.py und fügen Sie den Code mit den folgenden Updates hinzu:

KlasseMein Spiel(Arkade. Fenster):
# ...
defaktualisieren(self, delta_time):
 self.levels[self.current_level].update()
# Überprüfen Sie, ob der Spieler die Grenze überschritten hat
Wenn self.levels[self.current_level].player_x < 0:
 self.current_level += 1
 self.current_level %= len (self.levels)
 self.levels[self.current_level].player_x = SCREEN_WIDTH
elif self.levels[self.current_level].player_x > SCREEN_WIDTH:
 self.current_level += 1
 self.current_level %= len (self.levels)
 self.levels[self.current_level].player_x = 0
# ...

Unten ist die Ausgabe:

Inklusive zusätzlicher Funktionen

Um Ihre Spiellevel spannender zu gestalten, können Sie zusätzliche Funktionen wie Power-Ups und Ziele integrieren.

Ziele

Ziele stellen bestimmte Ziele dar, die der Spieler innerhalb eines Levels erreichen muss. Sie vermitteln ein Gefühl von Zielstrebigkeit und Fortschritt. Hier ist ein Beispiel für die Implementierung einer Zielfunktion:

KlasseZielsetzung:
def__drin__(selbst, x, y):
 self.x = x
 self.y = y
 self.radius = 20
defziehen(selbst):
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. GRÜN)
KlasseLevel eins:
def__drin__(selbst):
 self.objective = Objective(600, 400)
# ...
defaktualisieren(selbst):
# Überprüfen Sie, ob der Spieler das Ziel erreicht
Wenn arcade.check_for_collision (self.player, self.objective):
 self.complete_objective()
defziehen(selbst):
 self.objective.draw()
# ...
defComplete_Objective(selbst):
# Code zur Abwicklung der Zielvervollständigung
passieren

Sammlerstücke

Sammlerstücke sind Gegenstände oder Boni, die der Spieler im Laufe der Level sammeln kann. Hier ist ein Beispiel für die Implementierung einer Sammelfunktion:

KlasseSammlerstück:
def__drin__(selbst, x, y):
 self.x = x
 self.y = y
 self.radius = 10
 self.is_collected = FALSCH
defziehen(selbst):
Wennnicht self.is_collected:
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. ORANGE)
defsammeln(selbst):
 self.is_collected = WAHR
# Code zur Handhabung der Wirkung des Sammlerstücks auf den Spieler
KlasseLevel eins:
def__drin__(selbst):
 self.collectible = Sammlerstück(300, 300)
# ...
defaktualisieren(selbst):
# Überprüfen Sie, ob der Spieler den Gegenstand einsammelt
Wenn arcade.check_for_collision (self.player, self.collectible):
 self.collectible.collect()
defziehen(selbst):
 self.collectible.draw()
# ...

Hindernis

Hindernisse können statische Objekte oder bewegliche Einheiten sein, die den Weg des Spielers behindern. Sie verlangen vom Spieler, Strategien zu entwickeln und Wege zu finden, sie zu überwinden. Hier ist ein Beispiel für die Implementierung der Hindernisfunktion:

KlasseHindernis:
def__drin__(selbst, x, y, Breite, Höhe):
 self.x = x
 self.y = y
 self.width = Breite
 self.height = Höhe
defziehen(selbst):
 arcade.draw_rectangle_filled (self.x, self.y, self.width, self.height, arcade.color. GRAU)
KlasseLevel eins:
def__drin__(selbst):
 self.obstacles = [Hindernis(400, 200, 100, 50), Hindernis(600, 500, 80, 120)]
# ...

Einschalten

Power-Ups können die Fähigkeiten des Spielers verbessern oder vorübergehende Vorteile verschaffen. Hier ist ein Beispiel für die Implementierung einer Power-Up-Funktion:

KlasseEinschalten:
def__drin__(selbst, x, y):
 self.x = x
 self.y = y
 self.radius = 10
 self.is_active = WAHR
defziehen(selbst):
Wenn self.is_active:
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. GELB)
defactivate_power_up(selbst):
 self.is_active = WAHR
defdeaktivieren_power_up(selbst):
 self.is_active = FALSCH
KlasseLevel eins:
def__drin__(selbst):
 self.power_up = PowerUp(200, 200)
# ...
defaktualisieren(selbst):
# Überprüfen Sie, ob der Player mit dem Power-Up kollidiert
Wenn arcade.check_for_collision (self.player, self.power_up):
 self.player.activate_power_up()
 self.power_up.deactivate_power_up()
defziehen(selbst):
 self.power_up.draw()
# ...

Best Practices für das Leveldesign

Das Leveldesign spielt eine entscheidende Rolle bei der Schaffung ansprechender und unterhaltsamer Spielerlebnisse. Hier sind einige Best Practices, die Sie beim Entwerfen von Levels für Ihr Spiel berücksichtigen sollten:

Klare Ziele

Jedes Level sollte ein klares Ziel haben, das der Spieler erreichen muss. Ob es darum geht, einen bestimmten Ort zu erreichen, Feinde zu besiegen oder Rätsel zu lösen, das Ziel sollte klar definiert und dem Spieler kommuniziert werden.

Graduelle Schwierigkeitskurve

Entwerfen Sie Levels mit einem allmählichen Anstieg des Schwierigkeitsgrads, um den Spielern eine reibungslose Lernkurve zu bieten. Beginnen Sie mit einfacheren Herausforderungen und führen Sie im Laufe des Spielers nach und nach neue Mechaniken oder Hindernisse ein. Plötzliche Schwierigkeitsspitzen können Spieler frustrieren, daher ist es wichtig, einen ausgewogenen Fortschritt beizubehalten.

Visuelle Klarheit

Stellen Sie sicher, dass das Leveldesign und die visuellen Elemente dem Spieler wichtige Informationen klar vermitteln. Einbindung von Musik und Soundeffekten kann dem Spieler auch entscheidende Hinweise vermitteln und wichtige Informationen liefern.

Spieltests und Iteration

Regelmäßige Spieltests sind für die Verfeinerung und Verbesserung des Leveldesigns unerlässlich. Sammeln Sie Feedback von Spielern und beobachten Sie ihre Erfahrungen, um Bereiche zu identifizieren, die möglicherweise Anpassungen erfordern. Überarbeiten Sie Ihr Leveldesign basierend auf diesem Feedback, um ein unterhaltsameres und ausgewogeneres Gameplay zu schaffen.

Balance zwischen Belohnung und Herausforderung

Belohnen Sie Spieler für das Meistern von Herausforderungen in Ihren Levels. Dies kann durch Power-Ups, Sammlerstücke, das Freischalten neuer Gebiete oder den Fortschritt der Erzählung erreicht werden. Das Ausbalancieren der Schwierigkeit der Herausforderungen mit sinnvollen Belohnungen trägt dazu bei, die Spieler zu motivieren und ihnen ein Erfolgserlebnis zu vermitteln.

Machen Sie Spiele mit Levels spannender

Durch die Implementierung von Spielebenen können Sie das Spielerlebnis insgesamt verbessern und eine ansprechendere Spielumgebung schaffen. Die Level bieten Fortschritt, Herausforderung und Abwechslung und sorgen dafür, dass die Spieler investiert und motiviert bleiben. Sie ermöglichen es Ihnen, neue Mechaniken, Hindernisse, Feinde und Belohnungen einzuführen, um sicherzustellen, dass sich jedes Level anders und aufregend anfühlt.