In diesem Artikel erfahren wir, wie Sie unseren Arcade-Spielen in Python verschiedene Level hinzufügen können.

Ebenen hinzufügen

Wir können unserem Arcade-Spiel ganz einfach mehrere Level hinzufügen, indem wir die folgenden Schritte ausführen:

  • Erstellen Sie eine neue Variable, um das aktuelle Niveau zu speichern.
self.level = 1
  • Laden Sie die Sprites, die Sie im aktuellen Level verwenden werden, mit Hilfe der Variable self.level. In diesem Beispiel laden wir Sprites mit dem Namen „Platform1“ für Level 1, Sprites mit dem Namen „Platform2“ für Level 2 und so weiter. Dazu können wir die Plattformen mit dem folgenden Code laden.
platform = arcade.Sprite(f"Platform{self.level}.png", 1)
  • Wenn der Spieler die rechte Seite des Bildschirms überquert, erhöhen wir den Wert der Variable self.level, um zum nächsten Level zu gelangen.
 if self.player_sprite.center_x>690:
    self.level += 1

Verwendete Funktionen:

  • Camera(): Die Camera-Klasse wird zur Steuerung des sichtbaren Ansichtsfensters verwendet.

Syntax: arcade.Camera( width , height, window)

Parameter:

  • Breite: Breite des Ansichtsfensters
  • Höhe: Höhe des Ansichtsfensters
  • Fenster: Fenster, das dieser Kamera zugeordnet werden soll
  • Scene(): Eine Klasse, die ein Szenenobjekt darstellt.

Syntax: arcade.Scene(Sprite_lists , name_mapping)



Parameter:

  • sprite_lists: Eine Liste von SpriteList-Objekten
  • name_mapping: Ein Wörterbuch von SpriteList-Objekten
  • PhysicsEnginePlatformer(): Vereinfachte Physik-Engine zur Verwendung in einem Plattformer.

Syntax: arcade.PhysicsEnginePlatformer( player_sprite , Plattformen, Schwerkraft, Leitern)

Parameter:

  • player_sprite: Sprite des Spielers
  • Plattformen: Die Sprites, durch die es sich nicht bewegen kann
  • Schwerkraft: Abwärtsbeschleunigung pro Frame
  • Leitern: Leitern, auf die der Benutzer steigen kann

Verwendete Sprites:

Im folgenden Beispiel erstellen wir eine MainGame()-Klasse. In dieser Klasse werden wir zuerst einige Variablen für Geschwindigkeit, Kamera, Level und Sprite des Spielers initialisieren, dann werden wir 6 Funktionen innerhalb dieser Klasse erstellen.

  • on_draw(): Innerhalb dieser Funktion verwenden wir unsere Kamera und zeichnen die Szene.
  • setup(): In dieser Funktion initialisieren wir unsere Kamera und unser Szenenobjekt, dann laden wir die Sprites unseres Players und unserer Plattform. Danach rufen wir die Funktion PhysicsEnginePlatformer() auf.
  • on_update(): In dieser Funktion aktualisieren wir die x-Koordinaten des Sprites, der Kamera und der Physik-Engine des Spielers. Wir werden auch unser Level in dieser Funktion ändern.
  • on_key_press() und on_key_release(): In dieser Funktion ändern wir den Wert der Velocity-Variablen entsprechend der gedrückten oder losgelassenen Tastaturtaste.
  • camera_move(): In dieser Funktion bewegen wir unsere Kamera entsprechend der aktuellen Position unseres Spielers.

Nachfolgend die Umsetzung:

Python3

# Importing arcade module
import arcade
  
# Creating MainGame class
class MainGame(arcade.Window):
    def __init__(self):
        super().__init__(600, 600,
                         title = "Player Movement")
  
        # Initializing a variable to store
        # the velocity of the player
        self.vel_x = 0
  
        # Creating variable for Camera
        self.camera = None
  
        # Creating variable to store current level
        self.level = 1
  
        # Creating scene object
        self.scene = None
  
        # Creating variable to store player sprite
        self.player = None
  
        # Creating variable for our game engine
        self.physics_engine = None
  
    # Creating on_draw() function to draw on the screen
    def on_draw(self):
        arcade.start_render()
  
        # Using the camera
        self.camera.use()
          
        # Drawing our scene
        self.scene.draw()
  
    def setup(self):
         # Initialize Scene object
        self.scene = arcade.Scene()
          
        # Using Camera() function
        self.camera = arcade.Camera(600, 600)
  
        # Creating different sprite lists
        self.scene.add_sprite_list("Player")
        self.scene.add_sprite_list("Platforms",
                                   use_spatial_hash=True)
  
        # Adding player sprite
        self.player_sprite = arcade.Sprite("Player.png", 1)
  
        # Adding coordinates for the center of the sprite
        self.player_sprite.center_x = 64
        self.player_sprite.center_y = 600
  
        # Adding Sprite in our scene
        self.scene.add_sprite("Player", self.player_sprite)
  
        # Adding platform sprite according to level
        platform = arcade.Sprite(f"Platform{self.level}.png", 1)
          
        # Adding coordinates for the center of the platform
        platform.center_x = 300
        platform.center_y = 32
        self.scene.add_sprite("Platforms", platform)
  
        # Creating Physics engine
        self.physics_engine = arcade.PhysicsEnginePlatformer(
            self.player_sprite, self.scene.get_sprite_list("Platforms"), 0.5
        )
  
    # Creating on_update function to
    # update the x coordinate
    def on_update(self, delta_time):
  
        # Changing x coordinate of player
        self.player_sprite.center_x += self.vel_x * delta_time
          
        # Updating the physics engine to move the player
        self.physics_engine.update()
  
        # Calling the camera_move function
        self.camera_move()
  
        # Changing level if player crosses the right
        # end of screen
        if self.player_sprite.center_x > 690:
            self.level += 1
            self.setup()
  
    # Creating function to change the velocity
    # when button is pressed
    def on_key_press(self, symbol, modifier):
  
        # Checking the button pressed
        # and changing the value of velocity
        if symbol == arcade.key.LEFT:
            self.vel_x = -300
        elif symbol == arcade.key.RIGHT:
            self.vel_x = 300
  
    # Creating function to change the velocity
    # when button is released
    def on_key_release(self, symbol, modifier):
  
        # Checking the button released
        # and changing the value of velocity
        if symbol == arcade.key.LEFT:
            self.vel_x = 0
        elif symbol == arcade.key.RIGHT:
            self.vel_x = 0
  
    def camera_move(self):
        
        # Getting the x coordinate for the center of camera
        screen_x = self.player_sprite.center_x - \
            (self.camera.viewport_width / 2)
          
        # Getting the y coordinate for the center of camera
        screen_y = self.player_sprite.center_y - \
            (self.camera.viewport_height / 2)
  
        # Moving the camera
        self.camera.move_to([screen_x, screen_y])
  
  
# Calling MainGame class
game = MainGame()
game.setup()
arcade.run()

Ausgabe: