So erstellen Sie ein 2D-Spiel mit Python und einer Arcade-Bibliothek

Hallo habr Ich präsentiere Ihnen die Übersetzung des Artikels Wie man ein 2D-Spiel mit Python und der Arcade-Bibliothek von Paul Vincent Craven erstellt

So erstellen Sie ein 2D-Spiel mit Python und einer Arcade-Bibliothek

Erfahren Sie, wie Sie mit Arcade, einer benutzerfreundlichen Python-Bibliothek zum Erstellen von 2D-Videospielen, beginnen.

Phython ist eine großartige Sprache für Leute, die Programmieren lernen, und sie ist perfekt für diejenigen, die "etwas tun" wollen und nicht viel Zeit mit Code auf dem Kessel verbringen möchten. Arcade ist eine Python-Bibliothek zum Erstellen von 2D-Videospielen, die einfach zu verwenden und sehr effektiv ist, wenn Sie Erfahrung sammeln. In diesem Artikel werde ich erklären, wie Sie Python und Arcade zum Programmieren von Videospielen verwenden.

Ich habe mit der Entwicklung von Arcade begonnen, nachdem ich Studenten mit der PyGame- Bibliothek unterrichtet hatte. Ich habe fast 10 Jahre lang persönlich mit PyGame unterrichtet und ProgramArcadeGames .com entwickelt, um online zu unterrichten. PyGame ist großartig, aber am Ende hatte ich das Gefühl, Zeit zu verschwenden, um Fehler zu beheben, die nie behoben wurden .
Ich war besorgt, Dinge wie die Event- Schleife zu lehren, die nicht mehr so ​​ist, wie wir sie programmieren. Ich hatte einen ganzen Abschnitt, in dem ich erklärte, warum die Y-Koordinaten gekippt wurden. Da PyGame selten aktualisiert wurde und auf der alten SDL 1-Bibliothek basiert und nicht auf einer moderneren wie OpenGL , hatte ich nicht viel Hoffnung für die Zukunft.

Ich wollte eine Bibliothek erstellen, die benutzerfreundlicher und leistungsfähiger ist und einige der neuen Python 3-Funktionen verwendet, z. B. Dekoratoren und Tippfehler. Dies ist eine Spielhalle. Und so fangen Sie an.

Installation

Arcade ist wie viele andere Pakete über PyPi verfügbar. Dies bedeutet, dass Sie Arcade mit dem Befehl pip (oder dem Befehl pipenv) installieren können. Wenn Sie Python bereits installiert haben, können Sie wahrscheinlich einfach eine Eingabeaufforderung unter Windows öffnen und Folgendes eingeben:

pip install arcade 

Oder unter MacOS und Linux:

 pip3 install arcade 

Ausführlichere Installationsanweisungen finden Sie in der Arcade-Installationsdokumentation .

Einfaches Zeichnen

Sie können das Fenster öffnen und einfache Zeichnungen mit nur wenigen Codezeilen erstellen. Lassen Sie uns ein Beispiel erstellen, in dem ein Smiley gezeichnet wird (siehe Abbildung unten):

Der folgende Algorithmus zeigt, wie Sie dazu Arcade-Zeichenbefehle verwenden können . Beachten Sie, dass Sie nicht wissen müssen, wie man Klassen verwendet oder Funktionen definiert. Das Programmieren mit schnellem visuellem Feedback ist ideal für diejenigen, die das Programmieren erlernen möchten.

 import arcade # Set constants for the screen size SCREEN_WIDTH = 600 SCREEN_HEIGHT = 600 # Open the window. Set the window title and dimensions (width and height) arcade.open_window(SCREEN_WIDTH, SCREEN_HEIGHT, "Drawing Example") # Set the background color to white. # For a list of named colors see: # http://arcade.academy/arcade.color.html # Colors can also be specified in (red, green, blue) format and # (red, green, blue, alpha) format. arcade.set_background_color( arcade.color.WHITE) # Start the render process. This must be done before any drawing commands. arcade.start_render() # Draw the face x = 300 y = 300 radius = 200 arcade.draw_circle_filled( x, y, radius, arcade.color.YELLOW) # Draw the right eye x = 370 y = 350 radius = 20 arcade.draw_circle_filled( x, y, radius, arcade.color.BLACK) # Draw the left eye x = 230 y = 350 radius = 20 arcade.draw_circle_filled( x, y, radius, arcade.color.BLACK) # Draw the smile x = 300 y = 280 width = 120 height = 100 start_angle = 190 end_angle = 350 arcade.draw_arc_outline( x, y, width, height, arcade.color.BLACK, start_angle, end_angle, 10) # Finish drawing and display the result arcade.finish_render() # Keep the window open until the user hits the 'close' button arcade.run() 

Funktion verwenden

Natürlich ist das Schreiben von Code in einem globalen Kontext keine gute Form. Glücklicherweise ist es einfach, Ihr Programm mit Funktionen zu verbessern. Hier sehen wir ein Beispiel für das Zeichnen von Kiefern an einer bestimmten (x, y) Stelle mit der Funktion:

 def draw_pine_tree(x, y) : """ This function draws a pine tree at the specified location. """ # Draw the triangle on top of the trunk. # We need three x, y points for the triangle. arcade.draw_triangle_filled( x + 40, y, # Point 1 x, y - 100, # Point 2 x + 80, y - 100, # Point 3 arcade.color.DARK_GREEN) # Draw the trunk arcade.draw_lrtb_rectangle_filled( x + 30, x + 50, y - 100, y - 140 , arcade.color.DARK_BROWN) 

Ein vollständiges Beispiel finden Sie unter Zeichnen mit Funktionen .

Ein erfahrener Programmierer weiß, dass moderne Grafikprogramme zuerst Grafikinformationen auf die Grafikkarte hochladen und dann die Grafikkarte auffordern, diese später als Paket zu zeichnen. Arcade unterstützt dies ebenfalls. Das individuelle Zeichnen von 10.000 Rechtecken dauert ca. 800 Sekunden. Das Zeichnen als Paket dauert weniger als 0,001 Sekunden.

Fensterklasse

Größere Programme erben normalerweise von der Window- Klasse oder verwenden Dekoratoren . Auf diese Weise kann der Programmierer Code schreiben, um Benutzereingaben zu zeichnen, zu aktualisieren und zu verarbeiten. Die Vorlage zum Starten des Fensterprogramms ist unten dargestellt.

 import arcade SCREEN_WIDTH = 800 SCREEN_HEIGHT = 600 class MyGame( arcade.Window): """ Main application class. """ def __init__(self, width, height) : super( ) .__init__(width, height) arcade.set_background_color( arcade.color.AMAZON) def setup( self) : # Set up your game here pass def on_draw(self) : """ Render the screen. """ arcade.start_render() # Your drawing code goes here def update(self, delta_time) : """ All the logic to move, and the game logic goes here. """ pass def main( ) : game = MyGame( SCREEN_WIDTH, SCREEN_HEIGHT) game.setup( ) arcade.run() if __name__ = = "__main__": main() 

Die Window-Klasse verfügt über mehrere Methoden, die Ihre Programme überschreiben können, um Programmfunktionen bereitzustellen. Hier sind einige der am häufigsten verwendeten:

on_draw: Hier finden Sie den gesamten Code zum Zeichnen eines Bildschirms.
Update: Der gesamte Code zum Bewegen Ihrer Objekte und Ausführen der Spielelogik ist hier. Dies wird ungefähr 60 Mal pro Sekunde aufgerufen.
on_key_press: Behandelt Ereignisse, wenn eine Taste gedrückt wird. Geben Sie beispielsweise die Geschwindigkeit des Players an.
on_key_release: Wird ausgeführt, wenn die Taste losgelassen wird. Hier können Sie die Bewegung des Players stoppen.
on_mouse_motion: Wird bei jeder Mausbewegung aufgerufen.
on_mouse_press: Wird aufgerufen, wenn die Maustaste gedrückt wird.
set_viewport: Diese Funktion wird in Rollenspielen verwendet, wenn Ihre Welt viel größer ist als das, was Sie auf einem Bildschirm sehen können. Mit dem Aufruf von set_viewport kann der Programmierer festlegen, welcher Teil dieser Welt derzeit sichtbar ist.

Sprites

Sprites sind eine einfache Möglichkeit, ein zweidimensionales Rasterobjekt in Arcade zu erstellen. Arcade verfügt über Methoden, die das Zeichnen, Verschieben und Animieren von Sprites vereinfachen. Sie können auch problemlos Sprites verwenden, um Kollisionen zwischen Objekten zu erkennen.

Sprite-Erstellung

Das Erstellen einer Instanz der Sprite Arcade-Klasse aus Grafiken ist einfach. Ein Programmierer benötigt nur einen Bilddateinamen, auf dem das Sprite basiert, und optional eine Zahl, um das Bild zu vergrößern oder zu verkleinern. Zum Beispiel:

 SPRITE_SCALING_COIN = 0,2 coin = arcade.Sprite("coin_01.png", SPRITE_SCALING_COIN) 

Dieser Code erstellt ein Sprite mit dem in coin_01.png gespeicherten Bild. Das Bild wird auf 20% seiner ursprünglichen Höhe und Breite verkleinert.

Sprite-Listen

Sprites sind normalerweise in Listen organisiert. Diese Listen erleichtern die Verwaltung von Sprites. Die Sprites in der Liste verwenden OpenGL, um Sprites als Gruppe im Stapel zu zeichnen. Der folgende Code richtet ein Spiel mit einem Spieler und einem Haufen Münzen ein, die der Spieler sammelt. Wir verwenden zwei Listen, eine für den Spieler und eine für die Münzen.

 def setup(self): """ Set up the game and initialize the variables. """ # Create the sprite lists self.player_list = arcade.SpriteList() self.coin_list = arcade.SpriteList() # Score self.score = 0 # Set up the player # Character image from kenney.nl self. player_sprite = arcade.Sprite("images/character.png", SPRITE_SCALING_PLAYER) self.player_sprite.center_x = 50 # Starting position self.player_sprite.center_y = 50 self.player_list.append(self.player_sprite) # Create the coins for i in range( COIN_COUNT): # Create the coin instance # Coin image from kenney.nl coin = arcade.Sprite("images/coin_01.png", SPRITE_SCALING_COIN) # Position the coin coin.center_x = random.randrange(SCREEN_WIDTH) coin.center_y = random.randrange(SCREEN_HEIGHT) # Add the coin to the lists self.coin_list.append(coin) 

Wir können alle Münzen in den Münzenlisten leicht zeichnen:

 def on_draw(self): """ Draw everything """ arcade.start_render() self.coin_list.draw() self.player_list.draw() 

Sprite-Kollisionserkennung

Sprite-Kollisionserkennung
Mit der Funktion check_for_collision_with_list können wir feststellen, ob ein Sprite auf ein anderes Sprite in der Liste trifft. Hiermit können wir alle Münzen anzeigen, mit denen das Sprite des Spielers in Kontakt steht. Mit einer einfachen for-Schleife können wir die Münze aus dem Spiel entfernen und unsere Punktzahl erhöhen.

 def update(self, delta_time): # Generate a list of all coin sprites that collided with the player. coins_hit_list = arcade.check_for_collision_with_list(self.player_sprite, self.coin_list) # Loop through each colliding sprite, remove it, and add to the score. for coin in coins_hit_list: coin.kill() self.score += 1 

Ein vollständiges Beispiel finden Sie unter collect_coins.py .

Spielphysik

Viele Spiele beinhalten eine Art Physik. Die einfachsten sind Top-Down-Programme, die den Spieler daran hindern, durch Wände zu gehen. Platformers erhöhen die Komplexität der Schwerkraft und der sich bewegenden Plattformen. Einige Spiele verwenden eine vollwertige 2D-Physik-Engine mit Masse, Reibung, Federn und vielem mehr.

Top-down-Spiele

Für einfache Top-Down-Spiele benötigt das Arcade-Programm eine Liste von Wänden, durch die der Spieler (oder irgendetwas anderes) nicht passieren kann. Normalerweise nenne ich es wall_list. Anschließend wird die Physik-Engine im Installationscode der Window-Klasse erstellt, indem Folgendes verwendet wird:

 self.physics_engine = arcade.PhysicsEngineSimple(self.player_sprite, self.wall_list) 

Player_sprite empfängt einen Bewegungsvektor mit zwei Attributen: change_x und change_y. Ein einfaches Beispiel hierfür ist das Bewegen eines Players über die Tastatur. Dies könnte beispielsweise in einem benutzerdefinierten untergeordneten Element der Window-Klasse sein:

 MOVEMENT_SPEED = 5 def on_key_press(self, key, modifiers) : """Called whenever a key is pressed. """ if key = = arcade.key.UP: self.player_sprite.change_y = MOVEMENT_SPEED elif key = = arcade.key.DOWN: self.player_sprite.change_y = -MOVEMENT_SPEED elif key = = arcade.key.LEFT: self.player_sprite.change_x = -MOVEMENT_SPEED elif key = = arcade.key.RIGHT: self.player_sprite.change_x = MOVEMENT_SPEED def on_key_release(self, key, modifiers) : """Called when the user releases a key. """ if key = = arcade.key.UP or key = = arcade.key.DOWN: self.player_sprite.change_y = 0 elif key = = arcade.key.LEFT or key = = arcade.key.RIGHT: selfplayer_sprite.change_x = 0 

Dieser Code legt zwar die Geschwindigkeit des Players fest, bewegt den Player jedoch nicht. Bei der Methode zum Aktualisieren der Window-Klasse bewegt sich der Player beim Aufrufen von Physics_engine.update (), jedoch nicht durch die Wände.

 def update(self, delta_time): """ Movement and game logic """ self.physics_engine.update() 

Ein vollständiges Beispiel finden Sie unter sprite_move_walls.py .

Platformers

Der Wechsel zu einem Plattformspiel mit Seitenansicht ist ganz einfach. Der Programmierer muss lediglich die Physik-Engine auf PhysicsEnginePlatformer umstellen und die Gravitationskonstante hinzufügen.

 self.physics_engine = arcade.PhysicsEnginePlatformer(self.player_sprite, self.wall_list, gravity_constant= GRAVITY) 

Sie können ein Programm wie Tiled verwenden , um die Kacheln / Blöcke zu legen, aus denen Ihr Level besteht.

Ein Beispiel finden Sie unter sprite_tiled_map.py .

Für eine vollständige 2D-Physik können Sie die PyMunk-Bibliothek integrieren.

Lernen Sie aus einem Beispiel

Eine der besten Möglichkeiten zum Lernen ist ein Beispiel. Die Arcade-Bibliothek enthält eine lange Liste von Beispielen für Programme , mit denen Benutzer Spiele erstellen können. Jedes dieser Beispiele zeigt das Konzept eines Spiels, nach dem die Schüler im Laufe der Jahre in meinem Unterricht oder im Internet gefragt haben.

Das Ausführen dieser Demos ist nach der Installation von Arcade ganz einfach. Jedes der Beispiele enthält am Anfang des Programms einen Kommentar mit einem Befehl, den Sie in die Befehlszeile eingeben können, um das Beispiel auszuführen. Beispiel:

 python -m arcade.examples.sprite_moving_platforms 

Kurzinformation

Mit Arcade können Sie Grafiken und Spiele mit leicht verständlichem Code programmieren. Viele neue Programmierer haben kurz nach dem Start großartige Spiele entwickelt. Probieren Sie es aus!