🎮 Erstes Spiel mit Pygame: von Grund auf in Python schreiben

Möchten Sie Ihr erstes Spiel schreiben, wissen aber nicht, wo Sie mit der Spieleentwicklung anfangen sollen? Pygame räumt diese Hürde aus dem Weg. Sie programmieren in reinem Python und sehen sofort das Ergebnis auf dem Bildschirm: einen bewegten Sprite, eine Reaktion auf Tastatureingaben, lebendige Mechaniken. Keine schwergewichtigen Engines, keine tausenden Zeilen Boilerplate-Code.

Das Problem der meisten Tutorials: Sie begraben Sie entweder unter 40 Seiten Theorie oder lassen Sie mit einem „Den Rest schaffen Sie selbst" zurück. Wir nehmen hier den Mittelweg: Wir erklären gerade genug, damit Sie jede Zeile verstehen, und bauen sofort ein funktionierendes Spiel mit einer Figur, die sich per WASD über den Bildschirm bewegt. Der gesamte Code passt in 60 Zeilen.

💡 Kurzüberblick:

• Pygame via pip installieren und eine Spieledatei anlegen, das dauert wenige Minuten
• Die Game Loop verstehen: Events, Berechnungen, Rendering, drei Phasen, die in einer endlosen while True-Schleife ablaufen
• Eine Spielerklasse schreiben und zum Leben erwecken: WASD-Tasten bewegen den Sprite, der Bildschirm wird 60-mal pro Sekunde neu gezeichnet
• Das Koordinatensystem und die Farbbehandlung verstehen, zwei Grundpfeiler, die jede 2D-Grafik tragen

Was Pygame ist und warum Sie es wählen sollten

Pygame ist eine Bibliothek für Python, die das Multimedia-System SDL (Simple DirectMedia Layer) in eine komfortable Python-API verpackt. SDL übernimmt die Low-Level-Arbeit mit Grafik, Sound und Eingabegeräten, während Pygame den Zugriff über vertraute Klassen und Methoden bereitstellt. Die aktuelle Version 2.6.0 wird aktiv gepflegt und läuft unter Windows, macOS und Linux.

Für Einsteiger bietet Pygame drei unbestreitbare Vorteile. Erstens, niedrige Einstiegshürde: Sie nutzen gewöhnlichen Python-Code, keine neue Sprache und kein visueller Editor. Zweitens, sofortiges Feedback: Sie schreiben pygame.draw.rect(...) und ein Rechteck erscheint auf dem Bildschirm, keine Zauberei. Drittens, das Fundament verstehen: Pygame versteckt die Game Loop und die Event-Warteschlange nicht vor Ihnen, Sie sehen, wie ein Spiel im Inneren funktioniert. Nach Pygame fällt Ihnen der Umstieg auf Godot oder Unity leichter, weil Sie bereits wissen, was Delta Time und Event Polling sind.

Die Bibliothek versucht nicht, eine Game Engine zu sein. Sie hat kein Szenensystem, keine Physik und keinen eingebauten Level-Editor, und das ist eine bewusste Entscheidung. Sie kontrollieren jedes Pixel und jeden Tick, was bedeutet, dass Sie lernen, wie ein Spieleentwickler zu denken, nicht wie ein Bediener fremder Werkzeuge.

Pygame in zwei Minuten installieren

Haben Sie Python 3.9 oder neuer? Dann öffnen Sie ein Terminal und führen Sie einen Befehl aus:

1
pip install pygame

Zur Projekttrennung empfiehlt es sich, eine virtuelle Umgebung anzulegen:

1
python -m venv game_env
2
game_env\Scripts\activate     # Windows
3
source game_env/bin/activate  # macOS / Linux
4
pip install pygame

Prüfen Sie, ob die Bibliothek installiert ist:

1
import pygame
2
print(pygame.version.ver)

Erhalten Sie als Antwort 2.6.0 (oder neuer, die aktuelle Version können Sie auf pygame.org prüfen), sind Sie startklar. Legen Sie einen Projektordner an, platzieren Sie darin ein beliebiges Sprite-Bild mit 80×80 Pixeln namens player.png und eine Textdatei game.py, damit beginnen wir.

Wie die Game Loop funktioniert: Events, Berechnungen, Rendering

Das Herzstück eines jeden Spiels ist die Hauptschleife. Solange das Spiel läuft, wechseln sich innerhalb einer endlosen while True-Schleife drei Phasen ab:

• Event-Verarbeitung, was ist seit dem letzten Frame passiert? Taste gedrückt? Maus bewegt? Fenster geschlossen? Pygame sammelt alle Events in einer Warteschlange, und wir iterieren mit for event in pygame.event.get() darüber.

• Logik-Berechnung, wie hat sich die Welt als Reaktion auf die Events verändert? Spieler hat W gedrückt, Y-Koordinate erhöhen. Kugel mit Asteroid kollidiert, beide zur Entfernung vormerken.

• Rendering, alles zeichnen, was auf den Bildschirm soll. Hintergrund füllen, Sprites an neuen Koordinaten platzieren, pygame.display.update() aufrufen, und der Spieler sieht einen Frame.

Diese drei Schritte wiederholen sich 60-mal pro Sekunde, exakt die Bildrate (FPS), die wir am Timer einstellen. Die Illusion von Bewegung entsteht dadurch, dass der Sprite zwischen den Frames um wenige Pixel versetzt wird, während das Auge dies als kontinuierliche Animation wahrnimmt.

Ersten Code schreiben: Einen Sprite über den Bildschirm bewegen

Hier ist der vollständige Spielcode. Speichern Sie ihn als game.py und legen Sie player.png im selben Ordner ab:

1
#!/usr/bin/env python3
2
 
3
import pygame
4
import sys
5
 
6
WIDTH, HEIGHT = 360, 480
7
WHITE = (255, 255, 255)
8
 
9
class Player(pygame.sprite.Sprite):
10
 
11
    def __init__(self, image_path):
12
        super().__init__()
13
        self.image = pygame.image.load(image_path)
14
        self.x = WIDTH / 2
15
        self.y = HEIGHT / 2
16
        self.speed = 5
17
 
18
    def move(self, dx, dy):
19
        self.x += dx
20
        self.y += dy
21
 
22
def main():
23
    pygame.init()
24
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
25
    pygame.display.set_caption("First Game on Pygame")
26
 
27
    clock = pygame.time.Clock()
28
    fps = 60
29
 
30
    player = Player("player.png")
31
    dx, dy = 0, 0
32
 
33
    running = True
34
    while running:
35
        for event in pygame.event.get():
36
            if event.type == pygame.QUIT:
37
                running = False
38
 
39
            elif event.type == pygame.KEYDOWN:
40
                if event.key == pygame.K_d:
41
                    dx = player.speed
42
                elif event.key == pygame.K_a:
43
                    dx = -player.speed
44
                elif event.key == pygame.K_w:
45
                    dy = -player.speed
46
                elif event.key == pygame.K_s:
47
                    dy = player.speed
48
 
49
            elif event.type == pygame.KEYUP:
50
                if event.key in (pygame.K_d, pygame.K_a):
51
                    dx = 0
52
                elif event.key in (pygame.K_w, pygame.K_s):
53
                    dy = 0
54
 
55
        player.move(dx, dy)
56
        screen.fill(WHITE)
57
        screen.blit(player.image, (player.x, player.y))
58
        pygame.display.update()
59
        clock.tick(fps)
60
 
61
    pygame.quit()
62
    sys.exit()
63
 
64
if __name__ == "__main__":
65
    main()

Führen Sie python game.py aus, ein Fenster mit weißem Hintergrund und Ihrem Sprite in der Mitte öffnet sich. Halten Sie W, A, S oder D gedrückt, bewegt sich die Figur. Lassen Sie los, bleibt sie stehen. Das ist bereits ein echtes Spiel, wenn auch ein minimales.

Was gegenüber klassischen Tutorials verbessert wurde: Der KEYUP-Handler ist für das Loslassen von Tasten hinzugefügt. Ohne ihn würde der Sprite nach dem ersten Tastendruck für immer vom Bildschirm verschwinden. Und der Code ist in das Konstrukt if __name__ == "__main__" verpackt, eine gute Praxis, die es erlaubt, die Datei als Modul zu importieren, ohne das Spiel zu starten.

Koordinatensystem und Farbbehandlung

In Pygame werden Koordinaten von der oberen linken Ecke aus gezählt: (0, 0), ganz oben links. Nach rechts steigt X, nach unten steigt Y. Das unterscheidet sich vom Schul-Koordinatensystem, wo Y nach oben wächst, merken Sie es sich einfach und prüfen Sie es bei den ersten beiden Durchläufen: S gedrückt, Sprite bewegt sich nach unten, W gedrückt, nach oben.

Farbe wird durch ein Tupel aus drei Zahlen (R, G, B) angegeben, jede von 0 bis 255. Weiß entspricht (255, 255, 255), Schwarz entspricht (0, 0, 0), Rot entspricht (255, 0, 0). Die Methode screen.fill(WHITE) füllt vor dem Rendern jedes Frames den gesamten Bildschirm mit der gewählten Farbe. Tun Sie das nicht, hinterlässt der Sprite eine Spur seiner vorherigen Positionen.

Was unter der Haube passiert: Zeile für Zeile erklärt

Die Klasse Player erbt von pygame.sprite.Sprite, Pygames eingebauter Klasse für Spielobjekte. Im Konstruktor laden wir das Bild via pygame.image.load() und setzen die Startposition auf die Bildschirmmitte: WIDTH / 2 und HEIGHT / 2. Die Methode move(dx, dy) empfängt eine Verschiebung und addiert sie zu den aktuellen Koordinaten, reine Arithmetik, keine Zauberei.

Die Funktion main() führt alles zusammen. pygame.init() startet die internen Subsysteme. pygame.display.set_mode() erzeugt ein Fenster, und screen ist eine Surface, auf die wir zeichnen. pygame.time.Clock() erzeugt einen Timer: Seine Methode tick(fps) am Ende der Schleife weist Pygame an: „Warte, bis 1/60 Sekunde seit dem letzten Frame vergangen ist", so fixieren wir die Bildrate und verschwenden keine CPU-Zeit.

Die Hauptschleife while running dreht sich, bis das Flag running auf False gesetzt wird. Darin die drei oben besprochenen Phasen:

In der Schleife for event in pygame.event.get() fragen wir die Event-Warteschlange ab. pygame.QUIT ist das Signal „Benutzer hat den Schließen-Knopf des Fensters geklickt": running = False setzen, und bei der nächsten Iteration endet die Schleife. pygame.KEYDOWN feuert, wenn eine Taste gedrückt wird, und KEYUP, wenn sie losgelassen wird. Für D und A ändern wir dx, für W und S ändern wir dy. Beim Loslassen der Taste nullen wir die entsprechende Geschwindigkeitskomponente, der Sprite stoppt.

screen.blit(player.image, (player.x, player.y)), die Methode, die ein Bild auf ein anderes „überblendet". In unserem Fall den Spieler-Sprite auf die Hauptbildschirm-Surface an den aktuellen Koordinaten. pygame.display.update() aktualisiert das Fenster, und der Spieler sieht den fertigen Frame.

Hinweis: player.move() wird vor screen.fill() aufgerufen. Vertauschen Sie die Reihenfolge, wird der Sprite in derselben Millisekunde gelöscht, in der er erscheint, Sie sehen ihn schlicht nicht auf dem Bildschirm. Die Reihenfolge der Operationen in der Game Loop ist entscheidend.

Klicken Sie den Schließen-Knopf, entlädt pygame.quit() die Pygame-Subsysteme ordnungsgemäß, und sys.exit() beendet den Python-Prozess. Ohne pygame.quit() kann das Fenster beim Schließen einfrieren, ein kleines Detail, aber Code sollte sauber sein.

Kurzes Video zum Thema

Falls die Textanleitung nicht ganz zündet, hier ein exzellenter Videokurs auf Englisch, in dem Schritt für Schritt Space Invaders mit Pygame gebaut werden. Alle Konzepte aus dem Artikel werden live gezeigt:

⁉️🤔 Häufig gestellte Fragen

Muss ich OOP für Pygame beherrschen?

Ja, auf grundlegendem Niveau. Klassen, Methoden, Vererbung und self brauchen Sie vom ersten Tag an: Spieler, Gegner, Kugeln und Boni fügen sich ganz natürlich in ein Objektmodell. Wenn Sie einen beliebigen Python-Einführungskurs absolviert haben, der class und __init__ erklärt hat, reicht das aus. Den Rest lernen Sie unterwegs: Pygame verlangt keine Design Patterns, gewöhnliche Vererbung von Sprite genügt für dutzende Prototypen. Ein Spielobjekt in Pygame ist eine Klasse, die von pygame.sprite.Sprite erbt. Im Konstruktor laden Sie den Sprite via pygame.image.load(), setzen Anfangskoordinaten und Geschwindigkeit. Die Methode update() (oder Ihre eigene, wie move()) ändert jeden Frame die Position. Die Hauptschleife ruft update() auf allen Objekten auf und rendert sie dann via screen.blit(). Keine Zauberei, nur Methodenaufrufe in der richtigen Reihenfolge, 60-mal pro Sekunde.

Wird Pygame bei komplexer 2D-Grafik langsam?

Bei einer vernünftigen Anzahl von Sprites: nein. Surfaces in Pygame leben im RAM, und blit ist schnelles Pixel-Kopieren, kein Software-Rendering. Bei tausend gleichzeitig bewegten Objekten könnten Sie an die Leistungsgrenze von Python stoßen, aber für einen Plattformer, Top-Down-Shooter oder Tower Defense ist reichlich Luft. Wenn Sie maximale Performance herausholen müssen, nutzen Sie pygame.sprite.Group mit automatischem Rendering und Dirty Rectangles für partielle Bildschirm-Updates.

Kann ich in Pygame Sound und Musik einbinden?

Ja, direkt ab Werk. Das Modul pygame.mixer kann WAV und MP3 abspielen. Ein Schussgeräusch wird via pygame.mixer.Sound("shoot.wav").play() ausgelöst, und Hintergrundmusik wird via pygame.mixer.music.load("theme.mp3") und pygame.mixer.music.play(-1) geladen (das Flag -1 sorgt für Endlosschleife). Einziger Haken: pygame.mixer.init() muss vor dem Laden von Sounds aufgerufen werden, und für MP3 unter Linux benötigen Sie möglicherweise die Bibliothek libmpg123.

Hat es 2026 noch Sinn, Pygame zu lernen, wo es doch Godot und Unity gibt?

Unbedingt. Pygame ist kein Godot-Konkurrent, sondern ein Lernwerkzeug und eine leichtgewichtige Schicht für 2D-Prototypen. Sie lernen nicht C#, nur um ein Quadrat zu bewegen, und Sie arbeiten sich nicht für Pong in ein Node-System ein. Pygame vermittelt Ihnen ein Verständnis dafür, wie Spiele auf einer niedrigeren Ebene funktionieren: Game Loop, Frame-Buffering, Kollisionen. Programmierer, die mit Pygame angefangen haben, tun sich mit Unity und Godot leichter, weil sie die lebendige Mechanik hinter den Abstraktionen der Engine erkennen. Es werden echte Indie-Projekte in Pygame geschrieben, auch kommerzielle, ein kleiner Plattformer oder ein Puzzle kann auf Steam veröffentlicht werden, ohne C++ anzufassen.

Was tun, wenn der Sprite den Bildschirm verlässt?

Fügen Sie der Methode move() eine Begrenzungsprüfung hinzu: Wenn self.x < 0, setzen Sie sie auf 0; wenn self.x + sprite_width > WIDTH, setzen Sie sie auf WIDTH - sprite_width. Dasselbe für Y. Das nennt man Clamping, und ohne diese Prüfung wird die Figur irgendwann in einen unsichtbaren Bereich entschwinden. In fortgeschritteneren Spielen sind Begrenzungen Level-Wände, die über ein Kachelraster oder ein Kollisions-Array definiert werden.

Bereit, Ihr erstes Spiel zu starten?

Kopieren Sie den Code aus dem Abschnitt „Ersten Code schreiben", speichern Sie ihn als game.py, legen Sie ein beliebiges Sprite-Bild daneben, und in wenigen Sekunden sehen Sie ein Fenster mit einer beweglichen Figur. Das ist der Einstiegspunkt in die Spieleentwicklung: nicht lesen, sondern starten und anfangen, Parameter zu verändern.

Ändern Sie WIDTH und HEIGHT, das Fenster wird größer. Setzen Sie player.speed = 10, die Figur wird schneller. Ersetzen Sie WHITE durch (35, 35, 35), Sie erhalten einen dunklen Hintergrund. Experimentieren Sie, und Sie werden verstehen, dass ein Spielprogramm keine Zauberei ist, sondern eine Abfolge von Schritten, die Sie kontrollieren.

Wenn Sie die Bewegung beherrschen, nehmen Sie sich Kollisionen (pygame.sprite.collide_rect()), Animation (Umschalten von Sprite-Sheet-Frames) und prozedurale Level-Generierung vor. Für den Anfang genügen eine game.py-Datei und der Wille zu verstehen, wie es funktioniert.