Erstellen einer Code-Regen-Animation mit Pygame

Einführung

In diesem Projekt lernst du, wie du eine einfache Code-Regen-Animation mit der Pygame-Bibliothek in Python erstellst. Code-Regen-Animationen, die durch Filme wie "The Matrix" populär geworden sind, zeigen fallende Zeichen auf einem Bildschirm und vermitteln den Eindruck eines digitalen Regens. Wir werden die Pygame-Bibliothek verwenden, um die Animation zu erstellen und auf einem Fenster anzuzeigen.

👀 Vorschau

🎯 Aufgaben

In diesem Projekt wirst du lernen:

• Wie du das Animationsfenster in Pygame einrichtest
• Wie du eine "Regentropfen"-Klasse definierst, um jedes fallende Zeichen darzustellen
• Wie du mehrere Instanzen der Regentropfen-Klasse generierst und anzeigst
• Wie du die Hauptschleife implementierst, um die Animation ständig zu aktualisieren
• Wie du das Animationsfenster richtig schließt

🏆 Errungenschaften

Nach Abschluss dieses Projekts wirst du in der Lage sein:

• Die Pygame-Bibliothek zum Erstellen von Animationen zu verwenden
• Eine Klasse in Python zu definieren und zu verwenden
• Benutzerereignisse in Pygame zu behandeln
• Eine Hauptanimationsschleife in Pygame zu erstellen
• Das Animationsfenster in Pygame richtig zu schließen

Erstellen Sie die Projekt-Dateien

Bevor Sie beginnen, stellen Sie sicher, dass Sie Pygame installiert haben. Wenn Sie Pygame nicht installiert haben, können Sie es mit pip installieren:

sudo pip install pygame

Als Nächstes erstellen Sie in Ihrem bevorzugten Code-Editor oder IDE eine Datei namens code_rain.py. Dies wird die Hauptdatei sein, in der Sie den Code für das Code-Regen-Spiel schreiben.

cd ~/project
touch code_rain.py

Einrichten des Animationsfensters

Im code_rain.py-Datei importieren Sie die erforderlichen Bibliotheken am Anfang des Codes:

import pygame
import random

Initialisieren Sie dann Pygame, indem Sie pygame.init() aufrufen:

pygame.init()

Als Nächstes richten Sie das Animationsfenster ein, indem Sie die Breite, Höhe und den Titel definieren:

width, height = 800, 600
screen = pygame.display.set_mode((width, height))
pygame.display.set_caption("Code Rain")

Definieren Sie die in der Animation verwendeten Farben:

background_color = (0, 0, 0)
text_color = (0, 255, 0)

Schriftarten-Einstellungen:

font = pygame.font.Font(None, 36)

Definieren der Regentropfen-Klasse

Als Nächstes definieren wir die Regentropfen-Klasse, die jedes fallende Zeichen in der Code-Regen-Animation darstellt. Die Regentropfen-Klasse enthält Attribute wie die Anfangsposition, den Text und die Fallgeschwindigkeit jedes Regentropfens.

class Raindrop:
    def __init__(self):
        self.x = random.randint(0, width)
        self.y = random.randint(0, height)
        self.text = chr(random.randint(33, 126))
        self.speed = random.randint(1, 5)

    def fall(self):
        self.y += self.speed
        if self.y > height:
            self.y = 0
            self.x = random.randint(0, width)

    def display(self):
        text_surface = font.render(self.text, True, text_color)
        screen.blit(text_surface, (self.x, self.y))

Die __init__-Methode wird aufgerufen, wenn die Klasse instanziiert wird, um die Eigenschaften des Regentropfens zu initialisieren, einschließlich der zufälligen Anfangsposition (x, y), zufälliger Textzeichen (ASCII zwischen 33 und 126) und zufälliger Fallgeschwindigkeit (zwischen 1 und 5).

Die fall-Methode wird verwendet, um die Regentropfen nach unten zu bewegen. Sie erhöht den Wert von self.y gemäß der Geschwindigkeit des Regentropfens. Wenn der Regentropfen außerhalb des Bildschirms bewegt wird (wenn self.y größer als die Bildschirmhöhe ist), wird er auf die obere Hälfte des Bildschirms zurückgesetzt und eine neue x-Position auf dem Bildschirm zufällig ausgewählt.

Die display-Methode wird verwendet, um die Regentropfen anzuzeigen. Sie verwendet die font.render-Funktion aus der pygame-Bibliothek, um eine Textoberfläche zu erstellen und sie an der Regentropfenposition (self.x, self.y) auf dem Bildschirm zu rendern.

Generieren und Anzeigen von Regentropfen

Jetzt werden wir mehrere Instanzen der Regentropfen-Klasse erstellen und anzeigen, um die fallenden Zeichen zu simulieren. Der folgende Code erzeugt eine bestimmte Anzahl von Regentropfen und aktualisiert ihre Positionen auf dem Bildschirm.

num_raindrops = 100
raindrops = [Raindrop() for _ in range(num_raindrops)]

Behandeln der Hauptschleife

In diesem Schritt implementieren wir die Hauptschleife, die die Animation behandelt, indem sie den Bildschirm kontinuierlich aktualisiert. Sie hört auch auf das Beenden-Ereignis, um das Fenster ordnungsgemäß zu schließen.

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    screen.fill(background_color)

    for drop in raindrops:
        drop.fall()
        drop.display()

    pygame.display.flip()

pygame.quit()

Der Hauptteil der Animationsschleife ist eine while-Schleife, in der die Variable running die Schleife steuert. Die Schleife wird nur dann fortgesetzt, wenn running True ist.

Innerhalb der Animationsschleife wird pygame.event.get() verwendet, um eine Liste von pygame-Ereignissen zu erhalten, und jedes Ereignis wird durch Iterieren über die Ereignisliste untersucht. In diesem Fall ist die Hauptprüfung, ob es ein Beenden-Ereignis pygame.QUIT gibt, das generiert wird, wenn der Benutzer das Animationsfenster schließt. Wenn ein Beenden-Ereignis detektiert wird, wird running auf False gesetzt, um die Animationsschleife zu verlassen.

screen.fill(background_color) füllt die Hintergrundfarbe des Animationsfensters screen aus, um die Inhalte des vorherigen Rahmens zu überdecken, um einen neuen Rahmen zu zeichnen.

Iterieren Sie durch die raindrops-Liste, rufen Sie die fall()-Methode auf jedem Regentropfen-Objekt auf, um ihn fallen zu lassen, und rufen Sie die display()-Methode auf, um den Regentropfen auf dem Spiel-Fenster anzuzeigen.

pygame.display.flip() wird verwendet, um alle oben genannten Zeichnungen auf den Bildschirm für die Animation zu aktualisieren.

Nachdem die Animationsschleife beendet ist, ruft man pygame.quit() auf, um die pygame-Bibliothek aufzuräumen und die Animation zu beenden.

Führen Sie das Projekt aus

Schließlich wechseln Sie zum Desktop und führen Sie das Projekt mit dem folgenden Befehl aus:

python code_rain.py

Zusammenfassung

In diesem Projekt haben Sie gelernt, wie man eine einfache Code-Regen-Animation mit der Pygame-Bibliothek in Python erstellt. Sie haben das Pygame-Modul initialisiert, die Regentropfen-Klasse definiert, mehrere Regentropfen generiert und angezeigt und die Hauptschleife implementiert, um die Animation zu behandeln. Dieses Projekt vermittelt ein grundlegendes Verständnis dafür, wie man mit Pygame einfache Animationen erstellt.