Zeigen Sie fallende Schneeflocken mithilfe der Arcade-Bibliothek in Python an

arcade-Bibliothek ist eine Python-Bibliothek zum Erstellen von 2D-Videospielen und Simulationen im Arcade-Stil. Wenn Sie die Arcade-Bibliothek verwenden möchten, um einen Schneeeffekt zu erzeugen, können Sie zunächst ein neues Arcade-Fenster erstellen und eine dunkelblaue Hintergrundfarbe festlegen, um den Nachthimmel darzustellen.

Verwenden der Arcade-Bibliothek in Python

Die Arcade-Bibliothek ist eine Python-Bibliothek, die zum Entwickeln von 2D-Spielen und -Anwendungen verwendet wird. Sie bietet eine einfache Schnittstelle zum Erstellen interaktiver Grafiken und Animationen. In diesem Artikel verwenden wir die Arcade-Bibliothek, um eine einfache Schneefallanimation zu erstellen

Um zu beginnen, müssen wir die Arcade-Bibliothek installieren. Sie können dies tun, indem Sie den folgenden Befehl in Ihrem Terminal oder Ihrer Eingabeaufforderung ausführen: −

pip install arcade

Sobald die Installation abgeschlossen ist, können wir mit dem Schreiben unseres Codes beginnen. Hier ist ein einfaches Programm, das Schneefall anzeigt −

import arcade
import random

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
SNOWFLAKE_SIZE = 64

class Snowflake:
   def __init__(self):
      self.x = random.randrange(SCREEN_WIDTH)
      self.y = SCREEN_HEIGHT + SNOWFLAKE_SIZE
      self.speed = random.randrange(5, 20)
      self.angle = random.uniform(0, 2 * 3.1415)
        
   def update(self):
      self.x += self.speed * math.sin(self.angle)
      self.y -= self.speed * math.cos(self.angle)
      if self.y < -SNOWFLAKE_SIZE:
         self.y = SCREEN_HEIGHT + SNOWFLAKE_SIZE
         self.x = random.randrange(SCREEN_WIDTH)
        
   def draw(self):
      arcade.draw_circle_filled(self.x, self.y, SNOWFLAKE_SIZE, arcade.color.WHITE)
        
class Snowfall(arcade.Window):
   def __init__(self, width, height):
      super().__init__(width, height, "Snowfall")
      arcade.set_background_color(arcade.color.BLUE_GRAY)
      self.snowflakes = []
      for i in range(100):
         self.snowflakes.append(Snowflake())
            
   def on_draw(self):
      arcade.start_render()
      for snowflake in self.snowflakes:
         snowflake.draw()
            
   def on_update(self, delta_time):
      for snowflake in self.snowflakes:
         snowflake.update()

if __name__ == "__main__":
   window = Snowfall(SCREEN_WIDTH, SCREEN_HEIGHT)
   arcade.run()

Ausgabe

Als nächstes können Sie eine Liste von Schneeflocken erstellen, wobei jede Schneeflocke als Tupel von (x, y, Größe)-Werten dargestellt wird. Die x- und y-Werte stellen die Position der Schneeflocke auf dem Bildschirm dar und der Größenwert stellt die dar Schneeflockengröße .

In jedem Frame der Spielschleife können Sie die Position jeder Schneeflocke aktualisieren, indem Sie einen kleinen zufälligen Betrag zu ihrem Y-Wert hinzufügen. Sie können auch überprüfen, ob die Schneeflocke vom unteren Bildschirmrand heruntergefallen ist, und wenn ja, ihre Position auf einen zufälligen x-Wert am oberen Bildschirmrand zurücksetzen.

Schließlich können Sie jede Schneeflocke auf dem Bildschirm zeichnen, indem Sie die Funktion arcade.draw_circle_filled() verwenden, die (x, y) Positions- und Größenwerte als Parameter akzeptiert.

Lassen Sie uns den Code Schritt für Schritt durchgehen.

Zuerst importieren wir die Arcade-Bibliothek und das Zufallsmodul, mit denen wir Zufallswerte für die Schneeflocken generieren. Außerdem definieren wir einige Konstanten: SCREEN_WIDTH und SCREEN_HEIGHT, die die Größe unseres Fensters definieren, und SNOWFLAKE_SIZE, die definiert die Größe unserer Schneeflocken.

Als nächstes definieren wir eine Schneeflockenklasse. Im Konstruktor generieren wir zufällige Werte für die Position, Geschwindigkeit und den Winkel der Schneeflocke Winkel. Wenn die Schneeflocke vom unteren Bildschirmrand fällt, setzen wir ihre Position auf den oberen Bildschirmrand zurück. Die Methode draw() zeichnet die Schneeflocke mithilfe der Funktion arcade.draw_circle_filled()

Danach definieren wir eine Snowfall-Klasse. Diese Klasse stellt unser Hauptanwendungsfenster dar. Im Konstruktor setzen wir die Hintergrundfarbe auf Blaugrau und erstellen eine Liste mit 100 Schneeflocken Liste der Schneeflocken und rufen Sie die Methode draw() jeder Schneeflocke auf. In der Methode on_update() durchlaufen wir die Liste der Schneeflocken und rufen die Methode update() jeder Schneeflocke auf

Schließlich erstellen wir eine Instanz der Snowfall-Klasse und rufen arcade.run() auf, um die Anwendung zu starten.

Dieser Code erstellt eine

Snowflake

-Klasse, um jede Schneeflocke darzustellen, und eine

SnowfallGame-Klasse, um die Spielschleife zu verwalten und die Schneeflocken auf dem Bildschirm zu zeichnen. Die on_draw()-Methode wird in jedem Frame aufgerufen, um die Schneeflocken zu zeichnen Die Methode on_update() wird in jedem Frame aufgerufen, um die Position der Schneeflocken zu aktualisieren. Die Funktion arcade.run() startet die Spielschleife und hält das Fenster geöffnet, bis der Benutzer es schließt. Das ist es! Wenn Sie das Programm ausführen, sollten Sie ein Fenster sehen, in dem Schneeflocken auf den Bildschirm fallen.

Darüber hinaus bietet Python eine Funktion zum Zeichnen von Schildkröten, und wir können das Zeichnen von Schildkröten verwenden, um den unten gezeigten Schneeflockeneffekt zu erzielen.

Das obige ist der detaillierte Inhalt vonZeigen Sie fallende Schneeflocken mithilfe der Arcade-Bibliothek in Python an. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!