Das Grundgerüst

Für die Programmierung mit der Bibliothek pygame habe ich für mich folgende Grundstruktur festgelegt:

###################################################
#  Definition der Importe
###################################################
import pygame

###################################################
#  Definition der Konstanten und Variablen
###################################################

#  Werte fuer das Spielefenster
BREITE = 800
HOEHE = 400

# Spielsteuerung
spielen = True

###################################################
#  Definition der Funktionen
###################################################

def fenster_definieren():
    print('in fenster_definieren')
    pygame.init()
    f = pygame.display.set_mode((BREITE,HOEHE))
    pygame.display.set_caption('Snake - das Schlangenspiel')
    return f


def spielschleife_aufrufen():
    print('in spielschleife_aufrufen')
    global spielen
    while spielen:
        print('in der Schleife selbst')
        spielen = False 
 

def spiel_verlassen():
    print('in spiel_verlassen')
    pygame.quit()
    quit()


###################################################
#  Programmstart
###################################################

print('Programmstart!')

fenster = fenster_definieren()

spielschleife_aufrufen()

spiel_verlassen()

Sieht aufgeräumt aus, oder?

Gehen wir es kurz durch.

Zur besseren Lesbarkeit habe ich wie oben beschrieben 4 Kommentarblöcke eingefügt, die Definition der Importe, Definition der Variablen, Definitionen der Funktionen und den Programmstart.

Warum ist der Programmstart jetzt unten? Das Programm fängt doch schon mit dem ersten import an?

Berechtigte Frage. Für mich ist alles, was vor Zeile 46 steht, die Deklaration des Programms. Also die grundsätzlichen Vorbedingungen, die gegeben sein müssen, damit das Programm läuft.

Also von oben nach unten, zuerst alle Importe. Im weiteren Verlauf brauchen wir noch eine weitere (random).

Der nächste Block sind die Konstanten und Variablen. Der Unterschied ist klar, oder? Konstanten verändern sich nicht während der Laufzeit des Programms, Variablen dagegen schon. Um das zu kennzeichnen, werden Konstanten durchgängig GROSS geschrieben, Variablen durchgängig klein.

Die beiden Konstanten BREITE und HOEHE sind die Pixel-Angaben für das Spielfenster, wir brauchen sie in Zeile 24.

Die Variable spielen ist vom Typ boolean (also "wahr" oder "unwahr"). Sie ist die zentrale Abbruchbedingung unserer Schleife um das ganze Spiel. Zu sehen ist das in Zeile 32.

Die Funktionen überspringe ich kurz, ich mache weiter mit Zeile 47. Hier beginnt für mich das eigentliche Programm. Der Start wird in Zeile 46 mit der print() -Funktion ausgegeben, das kennen wir ja schon.

Das eigentliche Programm besteht als aus den 3 hintereinander laufenden Funktionen fenster_definieren(), spielschleife_aufrufen() und spiel_verlassen().

Was machen die einzelnen Funktionen nun?

In fenster_definieren() wird die Bibliothek pygame intitialisert (Zeile 23) und das Fenster wird erzeugt. Hier ist das, was ich in Kapitel 4.2 angesprochen habe. In der Funktion wird die lokale Variable f benötigt, um das Fenster zu instanziieren. Die lokale Variable f wird zurückgegeben und in Zeile 48 in der globalen (weil außerhalb der Funktion benötigten) Variable fenster gespeichert.

Die Funktion spielschleife_aufrufen() beherbergt unsere zentrale Spielsteuerung, nämlich die Schleife while spielen:. Solange die Variable spielen wahr ist (also True) wird die Schleife nicht verlassen. Und hier sehen wir die vorangestellte Deklaration global spielen, das sagt uns, dass wir im Verlauf der Funktion die globale Variable spielen (die in Zeile 15, also außerhalb der Funktion definiert wurde) ansprechen und ändern wollen.

In unserem Gerüst setzen wir spielen sofort nach der Ausgabe von 'in der Schleife selbst' auf unwahr (also False), das beendet die Schleife nach nur einem Durchgang.

Weiter geht es dann mit der Funktion spiel_verlassen() in der das Fenster und auch das Programm selbst beendet werden.

Soviel zum Grundgerüst.

Wenn Ihr mögt, findet Ihr direkt unten ein Button zum Herunterladen des Codes. Die Datei ist gezippt und liegt als txt-Datei vor. Aufrufen Kopieren und in Thonny einfügen.

Wenn Ihr das Programm laufen lasst, passiert so gut wie nichts, einmal kurz flackert ein Fenster auf, das geht aber gleich wieder zu. In der Ausgabe der Kommandozeile von Thonny sollten aber sämtliche print()-Anweisungen erscheinen:

Damit ist der Grundstock gelegt, machen wir weiter.

• Zurück
• Source Kapitel
• Weiter