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).
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 = 700liegt also weiter unten als einer mity = 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:
- Ereignisse abfragen: Was hat der Benutzer gemacht?
- Zeichnen: Das neue Bild auf die Zeichenfläche malen.
- Anzeigen: Das fertige Bild auf den Bildschirm bringen.
- 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
deffolgt 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
defwird 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)
fenster– die Zeichenfläche, auf die gemalt wirdfarbe– ein RGB-Tupel wie(255, 0, 0)(x1, y1)– der Startpunkt(x2, y2)– der Endpunktdicke– 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:
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 Kreisesradius– der Radius in Pixelndicke– lässt man diesen Wert weg (oder schreibt0), wird der Kreis ausgefüllt. Ist der Wert größer als0, 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!)breiteundhoehe– 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()
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 beihoehe - 200immer 200 Pixel über dem unteren Rand. - Ein Rechteck zentrieren: Das lila Rechteck ist 300 Pixel breit. Damit seine Mitte genau bei
mitteXliegt, 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).
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()
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:
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
- Gib der Funktion
zeichneLinienRaster()ein drittes Argumentabstand, sodass man beim Aufruf selbst festlegen kann, wie eng das Raster ist, z.B.zeichneLinienRaster(BREITE, HOEHE, 25). - Zeichne mit einer
for-Schleife eine Reihe von 10 Kreisen nebeneinander. Tipp: Der x-Wert des Mittelpunkts ist50 + i * 100. - 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): - Erweitere die Fadengrafik um eine zweite Fadenschar von der oberen zur rechten Kante in einer anderen Farbe.
- 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 mitif (zeile + spalte) % 2 == 0:entscheiden.




