Post

Spieleentwicklung mit PyGame - Zeichenroutinen

Spieleentwicklung mit PyGame - Zeichenroutinen

Zeichnen im Bildschirmkoordinatensystem

Bevor in einem Spiel Figuren herumspringen, muss man erst einmal wissen, wie man überhaupt etwas auf den Bildschirm bekommt. In diesem Beitrag öffnen wir ein Fenster und zeichnen darin Linien, Kreise, Rechtecke und schließlich mit Hilfe von Schleifen ganze Muster.

Die Python-Grundlagen aus dem Beitrag Python Grundlagen - Beispiel Pi-Berechnen (Variablen, import, Rechnen, die for-Schleife mit range() und print()) setzen wir hier voraus. Wie man PyGame installiert und PyCharm einrichtet, steht im Beitrag PyCharm und PyGame Grundlagen.

Das Bildschirmkoordinatensystem

Ein Bildschirmfenster besteht aus lauter kleinen Bildpunkten, den Pixeln. Ein Fenster mit 1000 x 800 Pixeln hat also 1000 Pixel nebeneinander und 800 Pixel übereinander. Jedes Pixel hat eine Adresse aus zwei Zahlen: (x, y).

Bildschirmkoordinatensystem

Das ist fast wie das Koordinatensystem aus dem Matheunterricht, aber mit zwei wichtigen Unterschieden:

  • Der Punkt (0, 0) liegt oben links, nicht unten links.
  • Die y-Werte werden nach unten größer. Ein Punkt mit y = 700 liegt also weiter unten als einer mit y = 100.

Und weil Python (wie bei range()) bei 0 anfängt zu zählen, hat das letzte Pixel ganz rechts die x-Koordinate 999 und nicht 1000. Das Pixel ganz unten rechts ist (999, 799).

Merke: In PyGame ist (0, 0) oben links, x wächst nach rechts und y wächst nach unten.

Pygame importieren und das erste Fenster auf dem Bildschirm öffnen

Hier ist das erste vollständige Programm. Es öffnet ein Fenster mit 1000 x 800 Pixeln, setzt den Fenstertitel und malt den Hintergrund weiß an:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
# =============================================================================
#  Zeichnen mit PyGame – Schritt 1: Ein leeres Fenster öffnen
# =============================================================================

# PyGame "einschalten" – genau wie "import math" beim Pi-Beispiel
import pygame


# -----------------------------------------------------------------------------
#  EINSTELLUNGEN (Konstanten in GROSSBUCHSTABEN)
# -----------------------------------------------------------------------------

# Größe des Fensters in Pixeln
BREITE = 1000
HOEHE = 800

# Farben werden als (Rot, Grün, Blau) angegeben, jeder Wert von 0 bis 255
WEISS = (255, 255, 255)


# -----------------------------------------------------------------------------
#  VORBEREITUNG
# -----------------------------------------------------------------------------

# Alle Teile von PyGame starten (Grafik, Tastatur, Sound, ...)
pygame.init()

# Das Fenster öffnen. Die Größe wird als Paar (Breite, Höhe) übergeben –
# deshalb die doppelten Klammern! Zurück bekommen wir die "Zeichenfläche"
# des Fensters, auf der wir später malen.
fenster = pygame.display.set_mode((BREITE, HOEHE))

# Text in der Titelleiste des Fensters
pygame.display.set_caption("Zeichnen mit PyGame")

# Eine Uhr, mit der wir die Geschwindigkeit der Hauptschleife bremsen
uhr = pygame.time.Clock()


# -----------------------------------------------------------------------------
#  HAUPTSCHLEIFE
# -----------------------------------------------------------------------------
#  Solange "laufend" den Wert True (wahr) hat, wird die Schleife wiederholt.
#  Jeder Durchlauf erzeugt ein neues Bild (einen "Frame").

laufend = True
while laufend:

    # 1. Ereignisse abfragen: Hat jemand eine Taste gedrückt, die Maus bewegt
    #    oder das Fenster geschlossen?
    for event in pygame.event.get():
        if event.type == pygame.QUIT:   # Klick auf das "X" im Fenster
            laufend = False             # -> Schleife endet nach diesem Durchlauf

    # 2. Zeichnen: Zuerst die ganze Fläche mit Weiß übermalen
    fenster.fill(WEISS)

    # 3. Anzeigen: Erst jetzt wird das fertige Bild auf dem Bildschirm sichtbar
    pygame.display.flip()

    # 4. Warten: höchstens 30 Bilder pro Sekunde, damit der Computer nicht
    #    unnötig auf Hochtouren läuft
    uhr.tick(30)


# PyGame ordentlich beenden und das Fenster schließen
pygame.quit()

Wenn du das Programm startest, erscheint ein weißes Fenster mit dem Titel “Zeichnen mit PyGame”. Mit dem “X” in der Titelleiste schließt du es wieder. Schauen wir uns die neuen Teile genauer an.

PyGame starten

1
2
import pygame
pygame.init()

import pygame funktioniert genau wie import math: Danach stehen alle Funktionen aus PyGame zur Verfügung, und man schreibt pygame. davor. Im Unterschied zu math muss PyGame aber zusätzlich mit pygame.init() “hochgefahren” werden, bevor man es benutzt. Am Ende des Programms fährt pygame.quit() es wieder herunter.

Das Fenster öffnen

1
2
fenster = pygame.display.set_mode((BREITE, HOEHE))
pygame.display.set_caption("Zeichnen mit PyGame")

set_mode() öffnet das Fenster. Die Größe wird als Paar (BREITE, HOEHE) übergeben. Ein solches Paar (oder auch eine Gruppe von drei oder mehr Werten) in runden Klammern nennt man in Python ein Tupel. Deshalb stehen hier zwei Klammern ineinander: die äußeren gehören zum Funktionsaufruf, die inneren zum Tupel. Tupel werden uns gleich ständig begegnen, z.B. für Punkte (x, y) und Farben.

Zurück bekommen wir die Zeichenfläche des Fensters, die wir in der Variablen fenster speichern. Alles, was wir später zeichnen, landet auf dieser Fläche.

set_caption() setzt den Text in der Titelleiste.

Die Größe schreiben wir übrigens nicht direkt als (1000, 800) hin, sondern speichern sie oben in BREITE und HOEHE. Die Großbuchstaben zeigen an, dass sich diese Werte während des Programms nicht ändern (man nennt solche Variablen Konstanten). Willst du ein größeres Fenster, musst du nur diese zwei Zeilen ändern.

Farben: Rot, Grün, Blau

Ein Pixel auf dem Bildschirm besteht aus drei winzigen Lämpchen: einem roten, einem grünen und einem blauen. Jede Farbe entsteht dadurch, wie hell diese drei Lämpchen leuchten. Deshalb gibt man in PyGame eine Farbe als Tupel aus drei Zahlen an, jeweils von 0 (aus) bis 255 (volle Helligkeit):

Farbe (Rot, Grün, Blau) Erklärung
Schwarz (0, 0, 0) alle Lämpchen aus
Weiß (255, 255, 255) alle Lämpchen voll an
Rot (255, 0, 0) nur Rot an
Grün (0, 255, 0) nur Grün an
Blau (0, 0, 255) nur Blau an
Gelb (255, 255, 0) Rot + Grün ergibt Gelb!
Grau (128, 128, 128) alle drei gleich, halbe Helligkeit
Hellblau (170, 200, 255) viel Blau, und etwas Rot und Grün dazu

Mit dem Befehl

1
fenster.fill(WEISS)

wird die ganze Zeichenfläche mit einer Farbe übermalt. Probiere ruhig mal andere Werte für WEISS aus!

Tipp: Viele Malprogramme und Webseiten (suche z.B. nach “color picker”) zeigen dir zu jeder Farbe die RGB-Werte an.

Die Hauptschleife mit while

Ein Spiel muss immer wieder neue Bilder zeichnen und gleichzeitig auf Tastendrücke und Mausklicks reagieren – und zwar so lange, bis man das Spiel beendet. Wie oft das ist, weiß man vorher nicht. Deshalb können wir hier keine for-Schleife mit range() verwenden, sondern brauchen eine neue Schleife, die while-Schleife:

1
2
3
laufend = True
while laufend:
    ...

while heißt “solange”: Der eingerückte Teil wird wiederholt, solange die Bedingung hinter while wahr ist. Die Variable laufend enthält einen Wahrheitswert: True (wahr) oder False (falsch). Am Anfang ist sie True, die Schleife läuft also los. Wie bei for gehört ein Doppelpunkt ans Zeilenende, und alles Eingerückte gehört zur Schleife.

Ein Durchlauf der Hauptschleife erledigt immer dieselben vier Aufgaben:

  1. Ereignisse abfragen: Was hat der Benutzer gemacht?
  2. Zeichnen: Das neue Bild auf die Zeichenfläche malen.
  3. Anzeigen: Das fertige Bild auf den Bildschirm bringen.
  4. Warten: Kurz Pause machen, damit das Spiel nicht zu schnell läuft.

Ereignisse und die if-Abfrage

1
2
3
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            laufend = False

PyGame merkt sich alles, was seit dem letzten Durchlauf passiert ist (Taste gedrückt, Maus bewegt, Fenster geschlossen, …), in einer Liste von Ereignissen (engl. events). pygame.event.get() liefert diese Liste, und mit der bekannten for-Schleife gehen wir die Ereignisse nacheinander durch.

Mit if (“wenn”) prüft man eine Bedingung. Nur wenn sie wahr ist, wird der eingerückte Teil darunter ausgeführt. Hier fragen wir: “Ist das Ereignis vom Typ QUIT?” Das ist der Fall, wenn jemand auf das “X” des Fensters klickt. Dann setzen wir laufend auf False, und die while-Schleife hört nach diesem Durchlauf auf.

Achtung: Für den Vergleich schreibt man zwei Gleichheitszeichen ==. Ein einzelnes = bedeutet ja “speichere in der Variablen” (siehe Pi-Beitrag). Weitere Vergleiche sind:

Python Bedeutung
a == b ist gleich
a != b ist ungleich
a < b ist kleiner
a > b ist größer
a <= b ist kleiner oder gleich
a >= b ist größer oder gleich

Zeichnen und Anzeigen

PyGame zeichnet zuerst unsichtbar “hinter den Kulissen”. Erst pygame.display.flip() bringt das fertige Bild auf einen Schlag auf den Bildschirm. So sieht man nie ein halb fertig gezeichnetes Bild, und nichts flackert (dieses Verfahren nennt man Double Buffering).

uhr.tick(30) sorgt dafür, dass die Schleife höchstens 30-mal pro Sekunde durchläuft – also 30 Bilder pro Sekunde (engl. frames per second, kurz FPS). Ohne diese Bremse würde der Computer so schnell wie möglich immer wieder dasselbe Bild zeichnen und dabei unnötig heiß werden.

Auf dem Bildschirm Linien zeichnen

Jetzt wollen wir endlich etwas zeichnen. Damit die Hauptschleife übersichtlich bleibt, packen wir die Zeichenbefehle in eine eigene Funktion.

Eigene Funktionen mit def

Funktionen kennst du schon: print(), math.sqrt() oder range() sind Funktionen, die andere für uns geschrieben haben. Man ruft sie mit ihrem Namen und runden Klammern auf, und sie erledigen eine Aufgabe. Mit dem Schlüsselwort def (von engl. define = festlegen) können wir uns eigene Funktionen schreiben:

1
2
3
def zeichneLinien():
    # hier stehen die Befehle der Funktion (eingerückt!)
    ...
  • Nach def folgt der Name der Funktion, dann runde Klammern und ein Doppelpunkt.
  • Alle eingerückten Zeilen darunter gehören zur Funktion – genau wie bei Schleifen.
  • Wichtig: Durch def wird die Funktion nur beschrieben, aber noch nicht ausgeführt! Das ist wie ein Rezept im Kochbuch: Es steht drin, aber gekocht wird erst, wenn jemand es benutzt.

Ausgeführt wird die Funktion erst, wenn man sie aufruft:

1
zeichneLinien()

Dann springt Python in die Funktion, führt alle ihre Befehle aus und macht danach hinter dem Aufruf weiter. Eine Funktion muss im Programm oberhalb der Stelle stehen, an der sie aufgerufen wird – sonst kennt Python sie noch nicht.

Funktionen haben zwei große Vorteile: Das Programm wird übersichtlicher, weil jede Funktion einen sprechenden Namen hat, und man kann eine Funktion beliebig oft aufrufen, ohne die Befehle mehrmals abzuschreiben.

Der Befehl pygame.draw.line()

Eine Linie zeichnet man mit:

1
pygame.draw.line(fenster, farbe, (x1, y1), (x2, y2), dicke)

Parameter der Zeichenbefehle

  • fenster – die Zeichenfläche, auf die gemalt wird
  • farbe – ein RGB-Tupel wie (255, 0, 0)
  • (x1, y1) – der Startpunkt
  • (x2, y2) – der Endpunkt
  • dicke – die Liniendicke in Pixeln. Diesen Wert darf man auch weglassen, dann ist die Linie 1 Pixel dick.

Das Programm mit Linien

Wir ergänzen oben bei den Einstellungen ein paar Farben und schreiben die Funktion zeichneLinien():

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
# Farben als (Rot, Grün, Blau)
WEISS   = (255, 255, 255)
SCHWARZ = (  0,   0,   0)
ROT     = (220,  30,  30)
GRUEN   = ( 30, 170,  60)
BLAU    = ( 30,  80, 220)
ORANGE  = (255, 140,   0)
LILA    = (150,  50, 200)


# -----------------------------------------------------------------------------
#  FUNKTIONEN
# -----------------------------------------------------------------------------
#  Eine Funktion wird mit "def" nur DEFINIERT (also beschrieben). Ausgeführt
#  wird sie erst, wenn man sie weiter unten mit zeichneLinien() AUFRUFT.

def zeichneLinien():
    # Aufbau des Befehls:
    #   pygame.draw.line(Zeichenfläche, Farbe, Startpunkt, Endpunkt, Dicke)
    # Start- und Endpunkt sind jeweils ein Paar (x, y).
    # Lässt man die Dicke weg, ist die Linie 1 Pixel dick.

    # Diagonale von oben links nach unten rechts (1 Pixel dick)
    pygame.draw.line(fenster, SCHWARZ, (0, 0), (999, 799))

    # Diagonale von unten links nach oben rechts (3 Pixel dick)
    pygame.draw.line(fenster, ROT, (0, 799), (999, 0), 3)

    # Waagerechte Linie: beide Punkte haben denselben y-Wert
    pygame.draw.line(fenster, BLAU, (100, 400), (900, 400), 5)

    # Senkrechte Linie: beide Punkte haben denselben x-Wert
    pygame.draw.line(fenster, GRUEN, (500, 50), (500, 750), 8)

    # Zwei schräge Linien kreuz und quer
    pygame.draw.line(fenster, ORANGE, (100, 700), (400, 100), 2)
    pygame.draw.line(fenster, LILA, (600, 100), (900, 700), 12)

Die Farben schreiben wir nicht jedes Mal als Zahlen hin, sondern geben ihnen Namen. So liest sich ROT viel leichter als (220, 30, 30). Die zusätzlichen Leerzeichen in den Tupeln sind übrigens egal, sie sorgen nur dafür, dass die Zahlen schön untereinander stehen.

Die Funktion wird in der Hauptschleife aufgerufen, und zwar nach fill() und vor flip():

1
2
3
4
5
6
7
    # Erst den Hintergrund löschen ...
    fenster.fill(WEISS)

    # ... dann die Linien darauf zeichnen (Funktionsaufruf!)
    zeichneLinien()

    pygame.display.flip()

Das Ergebnis:

Bunte Linien

Die Reihenfolge ist wichtig: PyGame malt wie mit Farbe auf Papier – was später gemalt wird, liegt obendrauf. Würdest du zeichneLinien() vor fenster.fill(WEISS) aufrufen, würde die weiße Farbe alle Linien sofort wieder übermalen und du sähest nur ein leeres Fenster. Schau dir im Bild auch an, wie die dicke lila Linie über der roten Diagonale liegt, weil sie später gezeichnet wurde.

Vielleicht wunderst du dich, dass die Funktion die Variable fenster benutzen kann, obwohl sie erst weiter unten mit set_mode() angelegt wird. Das klappt, weil die Funktion ja erst in der Hauptschleife aufgerufen wird – und da gibt es fenster schon.

Zum Ausprobieren: Die Koordinaten in zeichneLinien() sind fest eingetragen (man sagt auch “hartcodiert”). Ändere oben BREITE = 600 und HOEHE = 400 – was passiert mit den Linien? Die Diagonalen gehen jetzt nicht mehr in die Ecken, und einige Linien ragen aus dem Fenster heraus. Wie man das besser macht, kommt im nächsten Abschnitt.

Kreise und Rechtecke

Funktionen mit Argumenten

Damit sich die Zeichnung an die Fenstergröße anpasst, muss die Zeichenfunktion die Breite und Höhe kennen. Dafür kann man einer Funktion Werte mitgeben, so wie math.sqrt(16) die Zahl 16 mitbekommt. Diese Werte heißen Argumente (oder Parameter). Man schreibt sie bei def in die Klammern:

1
2
3
def zeichneKreiseUndRechtecke(breite, hoehe):
    mitteX = breite // 2
    ...

Beim Aufruf schreibt man die Werte in derselben Reihenfolge in die Klammern:

1
zeichneKreiseUndRechtecke(BREITE, HOEHE)

Python macht dann Folgendes: Der Wert von BREITE (also 1000) wird in die Variable breite der Funktion kopiert, und der Wert von HOEHE (800) in die Variable hoehe. Innerhalb der Funktion kann man mit breite und hoehe dann ganz normal rechnen.

Die Variablen breite, hoehe und alle Variablen, die in der Funktion angelegt werden (wie mitteX), gibt es nur, solange die Funktion läuft. Man nennt sie lokale Variablen. Außerhalb der Funktion sind sie unbekannt.

Ganzzahlige Division mit //

Um die Mitte des Fensters zu finden, teilen wir die Breite durch 2. Mit / bekommen wir aber immer eine Kommazahl: 1000 / 2 ergibt 500.0, und 999 / 2 ergibt 499.5. Pixel gibt es aber nur ganzzahlig – ein halbes Pixel kann man nicht anmalen. Deshalb gibt es in Python noch die ganzzahlige Division //, die die Nachkommastellen einfach abschneidet:

Python Ergebnis
1000 / 2 500.0
1000 // 2 500
999 / 2 499.5
999 // 2 499

Der Befehl pygame.draw.circle()

1
pygame.draw.circle(fenster, farbe, (x, y), radius, dicke)
  • (x, y) – der Mittelpunkt des Kreises
  • radius – der Radius in Pixeln
  • dicke – lässt man diesen Wert weg (oder schreibt 0), wird der Kreis ausgefüllt. Ist der Wert größer als 0, wird nur der Rand in dieser Dicke gezeichnet, und innen bleibt der Kreis durchsichtig.

Möchte man einen Kreis mit einer Füllfarbe und einem andersfarbigen Rand, zeichnet man ihn zweimal an dieselbe Stelle: erst gefüllt, dann den Rand darüber. Weil wir das öfter brauchen, schreiben wir dafür eine kleine Hilfsfunktion mit gleich sechs Argumenten:

1
2
3
4
5
6
def zeichneKreisMitRand(x, y, radius, fuellfarbe, randfarbe, randdicke):
    # Ein Kreis mit Füllfarbe UND andersfarbigem Rand entsteht in zwei Schritten:
    # 1. gefüllten Kreis malen (Dicke weggelassen -> Kreis wird ausgefüllt)
    pygame.draw.circle(fenster, fuellfarbe, (x, y), radius)
    # 2. denselben Kreis noch einmal nur als Umriss darüber malen
    pygame.draw.circle(fenster, randfarbe, (x, y), radius, randdicke)

Hier sieht man schön, wie eine Funktion uns Arbeit spart: Statt jedes Mal zwei Befehle zu schreiben, reicht ein Aufruf wie zeichneKreisMitRand(100, 100, 60, HELLBLAU, BLAU, 4).

Der Befehl pygame.draw.rect()

1
pygame.draw.rect(fenster, farbe, (x, y, breite, hoehe), dicke)

Ein Rechteck wird durch ein Tupel aus vier Zahlen beschrieben:

  • (x, y) – die linke obere Ecke des Rechtecks (nicht die Mitte wie beim Kreis!)
  • breite und hoehe – wie breit und hoch das Rechteck ist

Für dicke gilt dasselbe wie beim Kreis: weglassen bedeutet gefüllt, ein Wert größer 0 ergibt nur einen Rahmen.

Zusätzlich kann man mit border_radius=20 die Ecken abrunden. Das ist ein sogenanntes benanntes Argument: Man schreibt den Namen des Arguments, ein = und den Wert. Benannte Argumente sind praktisch für Zusatzeinstellungen, die man nur selten braucht – man muss dann nicht alle Argumente davor angeben und sich auch nicht die Reihenfolge merken.

Die Funktion zeichneKreiseUndRechtecke()

Für die neuen Formen ergänzen wir zunächst noch ein paar Farben:

1
2
3
4
5
GRAU      = (120, 120, 120)
HELLROT   = (255, 170, 170)
HELLGRUEN = (170, 230, 170)
HELLBLAU  = (170, 200, 255)
GELB      = (255, 220,  40)

Und hier ist die neue Funktion:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
def zeichneKreiseUndRechtecke(breite, hoehe):
    # "breite" und "hoehe" sind die ARGUMENTE (Parameter) der Funktion.
    # Sie bekommen beim Aufruf ihre Werte, z.B. 1000 und 800.

    # Mittelpunkt des Fensters ausrechnen.
    # "//" teilt ohne Nachkommastellen – Pixel gibt es nur ganzzahlig.
    mitteX = breite // 2
    mitteY = hoehe // 2

    # --- Kreise --------------------------------------------------------------
    # Aufbau des Befehls:
    #   pygame.draw.circle(Zeichenfläche, Farbe, Mittelpunkt, Radius, Dicke)
    #   Dicke weggelassen (oder 0)  -> gefüllter Kreis
    #   Dicke größer als 0          -> nur der Umriss in dieser Dicke

    # Großer gelber Kreis mit orangem Rand genau in der Mitte
    zeichneKreisMitRand(mitteX, mitteY, 150, GELB, ORANGE, 6)

    # Ein dünner blauer Ring drumherum (nur Umriss, keine Füllung)
    pygame.draw.circle(fenster, BLAU, (mitteX, mitteY), 200, 2)

    # Kleiner gefüllter Kreis im Zentrum
    pygame.draw.circle(fenster, ROT, (mitteX, mitteY), 20)

    # Je ein Kreis in den beiden oberen Ecken, jeweils 100 Pixel vom Rand.
    # Die rechte Ecke hängt von der Breite ab -> breite - 100
    zeichneKreisMitRand(100, 100, 60, HELLBLAU, BLAU, 4)
    zeichneKreisMitRand(breite - 100, 100, 60, HELLROT, ROT, 4)

    # Zwei kleinere Kreise links und rechts neben dem großen Kreis
    zeichneKreisMitRand(mitteX - 330, mitteY, 40, HELLGRUEN, GRUEN, 3)
    zeichneKreisMitRand(mitteX + 330, mitteY, 40, HELLGRUEN, GRUEN, 3)

    # --- Rechtecke -----------------------------------------------------------
    # Aufbau des Befehls:
    #   pygame.draw.rect(Zeichenfläche, Farbe, (x, y, Breite, Höhe), Dicke)
    #   (x, y) ist die linke OBERE Ecke des Rechtecks.
    #   Auch hier gilt: ohne Dicke -> gefüllt, mit Dicke -> nur Rahmen

    # Grünes, gefülltes Rechteck unten links mit schwarzem Rahmen
    pygame.draw.rect(fenster, HELLGRUEN, (50, hoehe - 200, 200, 150))
    pygame.draw.rect(fenster, SCHWARZ, (50, hoehe - 200, 200, 150), 3)

    # Rotes Rechteck unten rechts, nur als Rahmen
    pygame.draw.rect(fenster, ROT, (breite - 250, hoehe - 200, 200, 150), 5)

    # Lila Rechteck mit abgerundeten Ecken, waagerecht zentriert
    # (border_radius ist ein benanntes Argument, siehe Erklärung im Text)
    pygame.draw.rect(fenster, LILA, (mitteX - 150, hoehe - 130, 300, 80),
                     border_radius=20)

    # Grauer Rahmen um das ganze Fenster
    pygame.draw.rect(fenster, GRAU, (0, 0, breite, hoehe), 10)

Der Aufruf in der Hauptschleife ersetzt den bisherigen Aufruf von zeichneLinien(). Damit wir die Linien-Funktion nicht löschen müssen, machen wir aus ihrem Aufruf einfach einen Kommentar:

1
2
3
4
5
6
    fenster.fill(WEISS)

    # zeichneLinien()                          # Schritt 2 (abgeschaltet)
    zeichneKreiseUndRechtecke(BREITE, HOEHE)   # Schritt 3

    pygame.display.flip()

Kreise und Rechtecke

Ein paar Dinge, die man an dem Beispiel lernen kann:

  • Positionen relativ zum Rand berechnen: Der rote Kreis oben rechts sitzt bei breite - 100, also immer 100 Pixel vom rechten Rand entfernt – egal wie breit das Fenster ist. Genauso stehen die Rechtecke bei hoehe - 200 immer 200 Pixel über dem unteren Rand.
  • Ein Rechteck zentrieren: Das lila Rechteck ist 300 Pixel breit. Damit seine Mitte genau bei mitteX liegt, muss seine linke Kante um die halbe Breite (150) weiter links liegen: mitteX - 150.
  • Füllung und Rand: Beim grünen Rechteck sieht man wieder den Trick mit zwei Befehlen: erst gefüllt, dann der Rahmen darüber.
  • Nur ein Rahmen: Der blaue Ring und das rote Rechteck sind innen leer – dort sieht man den weißen Hintergrund.

Zum Ausprobieren: Ändere jetzt BREITE und HOEHE (z.B. auf 1200 und 700). Die Kreise in den Ecken und die Rechtecke wandern mit, und der große Kreis bleibt in der Mitte!

Zeichnen mit Schleifen

Bisher haben wir für jede Linie einen eigenen Befehl geschrieben. Will man aber z.B. ein Karoraster wie auf einem Mathe-Heft zeichnen, bräuchte man bei einem Linienabstand von 50 Pixeln schon 20 senkrechte und 16 waagerechte Linien – viel zu viel Tipparbeit. Genau dafür gibt es Schleifen!

range() mit Start, Ende und Schrittweite

Aus dem Pi-Beispiel kennst du range(10), das die Zahlen 0 bis 9 liefert. Man kann range() aber auch drei Zahlen mitgeben:

1
range(start, ende, schritt)

Dann beginnt die Zählung bei start, es wird jeweils schritt dazugezählt, und man hört vor ende auf (das Ende selbst ist wieder nicht dabei):

Aufruf erzeugte Zahlen
range(5) 0, 1, 2, 3, 4
range(2, 6) 2, 3, 4, 5
range(0, 20, 5) 0, 5, 10, 15
range(0, 1000, 50) 0, 50, 100, 150, ..., 900, 950

Mit range(0, breite, 50) bekommen wir also genau die x-Positionen aller senkrechten Rasterlinien.

Die Funktion zeichneLinienRaster()

Wir brauchen noch eine helle Farbe für das Raster:

1
HELLGRAU  = (220, 220, 220)

Die erste Version der Funktion ist erstaunlich kurz:

1
2
3
4
5
6
7
8
9
10
def zeichneLinienRaster(breite, hoehe):
    abstand = 50

    # Senkrechte Linien: x = 0, 50, 100, ... , 950
    for x in range(0, breite, abstand):
        pygame.draw.line(fenster, HELLGRAU, (x, 0), (x, hoehe - 1))

    # Waagerechte Linien: y = 0, 50, 100, ... , 750
    for y in range(0, hoehe, abstand):
        pygame.draw.line(fenster, HELLGRAU, (0, y), (breite - 1, y))

Bei einer senkrechten Linie haben Start- und Endpunkt denselben x-Wert. Die Linie geht von ganz oben (y = 0) bis ganz unten (y = hoehe - 1, das letzte Pixel). Bei jedem Schleifendurchlauf hat x einen anderen Wert, und so entsteht Linie für Linie das ganze Raster. Bei den waagerechten Linien ist es genau umgekehrt: Der y-Wert ist für Start- und Endpunkt gleich, und die Linie geht von links nach rechts.

Mit nur zwei Schleifen zeichnen wir so 36 Linien. Und wenn du den abstand auf 20 änderst, sind es sogar 90 – ohne eine einzige Zeile mehr!

Jede zweite Linie hervorheben: % und if/else

Wie auf Millimeterpapier sollen nun alle 100 Pixel etwas dunklere und dickere Linien kommen. Wir müssen also bei jeder Linie entscheiden: Ist x durch 100 teilbar oder nicht?

Dafür gibt es den Rest-Operator % (auch “Modulo” genannt). Er liefert den Rest, der bei einer ganzzahligen Division übrig bleibt – so wie du es von der schriftlichen Division aus der Grundschule kennst:

Python Rechnung Ergebnis
7 % 3 7 : 3 = 2 Rest 1 1
150 % 100 150 : 100 = 1 Rest 50 50
200 % 100 200 : 100 = 2 Rest 0 0

Ist der Rest 0, dann ist die Zahl ohne Rest teilbar. Die Bedingung x % 100 == 0 ist also genau dann wahr, wenn x durch 100 teilbar ist.

Jetzt brauchen wir noch eine Erweiterung der if-Abfrage: Mit else (“sonst”) gibt man an, was passieren soll, wenn die Bedingung nicht zutrifft:

1
2
3
4
5
6
if x % 100 == 0:
    # wird ausgeführt, wenn x durch 100 teilbar ist
    ...
else:
    # wird ausgeführt, wenn x NICHT durch 100 teilbar ist
    ...

else steht auf derselben Einrückungstiefe wie das zugehörige if und hat ebenfalls einen Doppelpunkt.

Damit sieht die fertige Funktion so aus:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def zeichneLinienRaster(breite, hoehe):
    # Abstand zwischen zwei Rasterlinien in Pixeln
    abstand = 50

    # Senkrechte Linien: x läuft von 0 bis (ohne) breite in 50er-Schritten,
    # also x = 0, 50, 100, 150, ... , 950
    for x in range(0, breite, abstand):
        # Jede zweite Linie (alle 100 Pixel) etwas dunkler und dicker.
        # x % 100 ist der Rest der Division x / 100. Ist er 0, dann ist x
        # durch 100 teilbar.
        if x % 100 == 0:
            pygame.draw.line(fenster, GRAU, (x, 0), (x, hoehe - 1), 2)
        else:
            pygame.draw.line(fenster, HELLGRAU, (x, 0), (x, hoehe - 1))

    # Waagerechte Linien: genauso, nur mit y statt x
    for y in range(0, hoehe, abstand):
        if y % 100 == 0:
            pygame.draw.line(fenster, GRAU, (0, y), (breite - 1, y), 2)
        else:
            pygame.draw.line(fenster, HELLGRAU, (0, y), (breite - 1, y))

Beachte die Einrückung: Das if steht innerhalb der for-Schleife (eine Stufe eingerückt), und die Zeichenbefehle stehen innerhalb von if bzw. else (zwei Stufen eingerückt).

Linienraster

Jetzt sieht man übrigens auch sehr schön das Bildschirmkoordinatensystem: Jedes dunkle Kästchen ist 100 x 100 Pixel groß. Du kannst also abzählen, dass der Fenstermittelpunkt bei (500, 400) liegt.

Alles zusammen: Die Reihenfolge entscheidet

Zum Schluss rufen wir das Raster und die Kreise und Rechtecke auf. Da das Raster der Hintergrund sein soll, muss es zuerst gezeichnet werden:

1
2
3
4
5
6
7
8
    fenster.fill(WEISS)

    # Die Reihenfolge ist wichtig: Was zuerst gezeichnet wird, liegt hinten!
    zeichneLinienRaster(BREITE, HOEHE)         # Schritt 4: Raster als Hintergrund
    # zeichneLinien()                          # Schritt 2 (abgeschaltet)
    zeichneKreiseUndRechtecke(BREITE, HOEHE)   # Schritt 3: liegt über dem Raster

    pygame.display.flip()

Raster mit Kreisen und Rechtecken

Die gefüllten Formen verdecken das Raster, aber durch den blauen Ring und das rote Rahmen-Rechteck sieht man es durchscheinen, weil diese innen leer sind. Probier mal aus, die beiden Aufrufe zu vertauschen – dann liegt das Raster über den Kreisen!

Bonus: Fadengrafik

Mit Schleifen kann man auch hübsche Muster erzeugen, die gar nicht nach geraden Linien aussehen. Bei dieser “Fadengrafik” spannen wir Fäden von der linken Kante zur unteren Kante. Bei jedem Durchlauf rutscht der Startpunkt links ein Stück nach unten und der Endpunkt unten ein Stück nach rechts:

1
2
3
4
5
6
7
8
9
10
def zeichneFadengrafik(breite, hoehe):
    # Wie viele Fäden gespannt werden
    anzahl = 20

    # Bei jedem Durchlauf rutscht der Startpunkt auf der linken Kante ein Stück
    # nach unten und der Endpunkt auf der unteren Kante ein Stück nach rechts.
    for i in range(anzahl + 1):
        y = i * (hoehe - 1) // anzahl    # von 0 bis zum letzten Pixel (799)
        x = i * (breite - 1) // anzahl   # von 0 bis zum letzten Pixel (999)
        pygame.draw.line(fenster, BLAU, (0, y), (x, hoehe - 1), 2)

Hier läuft i von 0 bis 20 (deshalb anzahl + 1). Beim ersten Faden (i = 0) geht die Linie von (0, 0) nach (0, 799), beim letzten (i = 20) von (0, 799) nach (999, 799). Dazwischen werden die Positionen gleichmäßig verteilt. Obwohl nur gerade Linien gezeichnet werden, entsteht dabei eine schöne Kurve:

Fadengrafik

Zusammenfassung

Befehl / Schlüsselwort Bedeutung
pygame.init() / pygame.quit() PyGame starten / beenden
pygame.display.set_mode((b, h)) Fenster öffnen, liefert die Zeichenfläche
pygame.display.set_caption("...") Fenstertitel setzen
fenster.fill(farbe) ganze Zeichenfläche mit einer Farbe füllen
pygame.display.flip() fertiges Bild auf dem Bildschirm anzeigen
pygame.draw.line(fenster, farbe, p1, p2, dicke) Linie von p1 nach p2
pygame.draw.circle(fenster, farbe, m, r, dicke) Kreis mit Mittelpunkt m und Radius r
pygame.draw.rect(fenster, farbe, (x, y, b, h), dicke) Rechteck mit linker oberer Ecke (x, y)
(255, 0, 0) Tupel, hier eine Farbe aus Rot, Grün, Blau
while bedingung: Schleife, die läuft, solange die Bedingung wahr ist
if bedingung: … else: Abfrage: wenn … sonst …
==, !=, <, > Vergleiche
def name(arg1, arg2): eigene Funktion mit Argumenten definieren
// und % ganzzahlige Division und Rest
range(start, ende, schritt) Zahlenfolge mit Startwert und Schrittweite

Zum Ausprobieren

  1. Gib der Funktion zeichneLinienRaster() ein drittes Argument abstand, sodass man beim Aufruf selbst festlegen kann, wie eng das Raster ist, z.B. zeichneLinienRaster(BREITE, HOEHE, 25).
  2. Zeichne mit einer for-Schleife eine Reihe von 10 Kreisen nebeneinander. Tipp: Der x-Wert des Mittelpunkts ist 50 + i * 100.
  3. Zeichne mit einer Schleife konzentrische Kreise (alle mit demselben Mittelpunkt, aber immer größerem Radius) – wie eine Zielscheibe. Tipp: for r in range(20, 400, 20):
  4. Erweitere die Fadengrafik um eine zweite Fadenschar von der oberen zur rechten Kante in einer anderen Farbe.
  5. Für Fortgeschrittene: Zeichne ein Schachbrett. Dafür brauchst du zwei ineinander geschachtelte for-Schleifen (eine für die Zeilen, eine für die Spalten). Ob ein Feld schwarz oder weiß ist, kannst du mit if (zeile + spalte) % 2 == 0: entscheiden.
This post is licensed under CC BY 4.0 by the author.