Ein Pygame-Grundgerüst

Da ich ja nun Pygame auch unter meinem Anaconda-Python zur Mitarbeit bewegen konnte und mich die Video-Tutorials von Chris und Priya Bradfield inspiriert hatten, habe ich mir vorgenommen, in der nächsten Zeit verstärkt mit der Spieleprogrammierung mit Pygame zu experimentieren. Mir schweben da kleinere Tutorials zu speziellen Themen vor, wie sie zum Beispiel Jorge Rodriguez in seiner YouTube-Playlist Math for Game Developers (in C++) anspricht. Damit ich aber nicht jedes mal das Rad neu erfinden muß, habe ich zur Vorbereitung erst einmal ein lauffähiges Grundgerüst entwickelt, das minimal aus zwei Dateien besteht, einmal der Hauptdatei main.py und dann noch einer Konfigurationsdatei settings.py. Die Datei main.py sieht so aus:

# Erweitertes Pygame-Grundgerüst
# Als Template für alle größeren Python/Pygame-Projekte zu verwenden
import pygame as pg
from settings import Settings
import random
import os

class World:
    
    def __init__ (self):
        # Initialisiert die Spielewelt
        pg.init()
        pg.mixer.init()
        self.screen = pg.display.set_mode((s.WIDTH, s.HEIGHT))
        pg.display.set_caption(s.TITLE)
        self.clock = pg.time.Clock()
        self.keep_going = True
    
    def new(self):
        # Initializes and Resets the Game
        self.all_sprites = pg.sprite.Group()
        self.run()
        
    def run(self):
        # Game Loop
        self.playing = True
        while self.playing:
            self.clock.tick(s.FPS)
            self.events()
            self.update()
            self.draw()
    
    def update(self):
        # Game-Loop Update
        self.all_sprites.update()
    
    def events(self):
        # Game-Loop Events
        for event in pg.event.get():
            if event.type == pg.QUIT or (event.type == pg.KEYDOWN and event.key == pg.K_ESCAPE):
                if self.playing:
                    self.playing = False
                self.keep_going = False
  
    def draw(self):
        # Game-Loop Draw
        self.screen.fill(s.BLACK)
        self.all_sprites.draw(self.screen)
        pg.display.flip()

    def splash_screen(self):
        # Start-Screen
        pass
        
    def game_over(self):
        pass
        

s = Settings()
w = World()
w.splash_screen()
while w.keep_going:
    w.new()
    w.game_over()
    
pg.quit()

Erst einmal habe ich die Importe vorgenommen, wobei die Module os und random noch nicht benötigt werden, aber da man sie praktisch für jedes Spiele benötigt (os für die Pfadangaben zu den Assets und random – kennt einer ein Spiel, in dem der Zufall keine Rolle spielt?).

In der Klasse World wird die Spielewelt, also das Hauptfenster und die darin stattfindenden Aktionen definiert. Nach der Initialisierung im Constructor wird in der Methode new() das Spiel initialisiert und – nach einem Neustart – auf seine Anfangswerte zurückgesetzt. Danach ruft sie die Methode run() auf, die die eigentliche Game Loop enthält. Innerhalb dieser (Endlos-) Schleife werden bei jedem Durchlauf die Methoden events() (die die Tastatur und Mauseingaben etc. verarbeiten soll), update() (zuständig für die Berechnung der Bewegungen und der Kollisionserkennung) und draw() (hier wird dann das Fenster neugezeichnet) aufgerufen.

Die Methoden für den Start- und den Ende-Bildschirm sind noch Platzhalter, aber da auch sie bei jedem ernstzunehmenden Spiel benötigt werden, habe ich sie schon einmal in mein Grundgerüst eingebaut.

Das eigentliche Programm ist dann sehr kurz: Hier wird eine Instanz der Spielewelt erzeugt, gegebenenfalls der Startbildschirm aufgerufen und dann läuft in einer weiteren (Endlos-) Schleife das Spiel ab. Hier gibt es nach Ende des Spieles gegebenfalls einen Game Over Screen, von dem das Spiel auch neu gestartet werden kann. Und wenn keep_going auf False gesetzt wird, ist endgültig Schluß.

Und dann habe ich noch das Modul settings.py erstellt:

# Konstanten und Einstellungen für das Spiel
import pygame as pg

class Settings():
    
    def __init__(self):

        # Einige nützliche Konstanten
        self.TITLE = "🐍 Hällo Pygäme! 🐍"
        self.WIDTH = 640
        self.HEIGHT = 480
        self.FPS = 60   # Framerate

        # Nützliche Farbdefinitionen 
        self.WHITE = (255, 255, 255)
        self.BLACK = (0, 0, 0)
        self.RED = (255, 0, 0)
        self.GREEN = (0, 255, 0)
        self.BLUE = (0, 0, 255)
        self.YELLOW = (255, 255, 0)
        self.GREY = (160, 160, 160)

Es soll in der Hauptsache nur ein paar nützliche Konstanten für alle Werte enthalten, die mehr als einmal im Spiel vorkommen, so daß man sie nur in dieser Konfigurationsdatei ändern, und nicht in den übrigen Quelltexten verzweifelt nach einem Vorkommen dieser Werte suchen muß.

Wie man sieht, ist Pygame mit Python3 wirklich UTF-8 fest und verträgt auch ohne Verrenkungen Emojis in der Titelzeile.

Auf Grundlage dieses Templates habe ich schon angefangen, ein paar kleinere Dinge mit Python und Pygame anzustellen. Ihr werdet daher in den nächsten Tagen noch mehr von mir darüber lesen. Still digging!

(Kommentieren)