17    gamegrid – Spiele bauen mit Objekten

Nach der Pflicht jetzt endlich die Kür: Du weißt, was Objekte sind – jetzt lernst du, mit einer sehr mächtigen Objektbibliothek umzugehen. Schritt für Schritt geht es an das Programmieren richtiger Spiele.

Wir haben in den vorangegangenen Kapiteln ja schon so einige praktische Bibliotheken verwendet. Die umfangreichste war die gturtle-Bibliothek, mit der man eine zeichnende Schildkröte sowie allerlei bunte Grafiken erzeugen konnte. Auch dies war eine Objektbibliothek – nur haben wir sie noch nicht so richtig objektorientiert genutzt. Man kann damit noch weit mehr machen – zum Beispiel mehrere Schildkröten oder andere Figuren erzeugen, die miteinander kommunizieren … Aber das darfst du am Ende des Buches, wenn du möchtest, gerne selbst ausprobieren.

Wir wenden uns jetzt einem anderen Modul zu, das ebenso wie gturtle im TigerJython-Paket bereits enthalten ist. Es heißt gamegrid. Das bedeutet übersetzt so viel wie »Spiele-Raster«. Klingt harmlos – aber hinter diesem Namen verbirgt sich eine extrem umfangreiche und sehr leistungsfähige Sammlung von Objektklassen und Funktionen, die alles zur Verfügung stellt, was wir brauchen, um die verschiedenartigsten Spiele zu programmieren: Ein Spielfeld, beliebig bewegbare Figuren, einen Spielablauf, Abfragen von Maus und Tastatur usw. … gamegrid heißt eigentlich JGameGrid und wurde ursprünglich als didaktische Spiele-Engine für Java programmiert, also zum Lernen. Da ja TigerJython auch auf Java basiert, ist es möglich, die gamegrid-Bibliothek komplett in Python zu verwenden und zu steuern.

Du kannst alle diese Funktionen benutzen und ansprechen, indem du einfach die gamegrid-Bibliothek importierst und anschließend aus ihren vorgegebenen Klassen Objekte erzeugst, deren Eigenschaften und Methoden du dann mit eigenen Programmen anpasst und steuerst. Wie du ja gelernt hast, ist es dabei wichtig, genau zu wissen, wie die Klassen, Eigenschaften und Methoden heißen, mit welchen Werten sie aufgerufen werden und was sie genau bewirken. Das wollen wir jetzt Schritt für Schritt erkunden und kennenlernen.

Wie gesagt: Um die Bibliothek benutzen zu können, muss sie natürlich zuerst importiert werden. Am Anfang jedes Programms, das mit gamegrid arbeitet, steht also immer der folgende Befehl:

from gamegrid import *

Damit werden unserem Programm einfach alle Funktionen und Klassen aus der Bibliothek gamegrid zur Verfügung gestellt.

In der gamegrid-Bibliothek gibt es zwei Hauptklassen, aus denen du deine Objekte erzeugen kannst. Nämlich die Klasse mit dem Namen GameGrid – das ist das Spielfeld bzw. das Fenster, in dem dein Programm sich abspielt, und die Klasse Actor (das bedeutet Darsteller oder Schauspieler) – das sind die »Spielfiguren« – die grafischen Objekte, die sich auf dem Spielfeld bewegen können. (Daneben gibt es noch eine Menge kleinerer Klassen, die später noch zur Verwendung kommen werden).

Ein Spielfeld erzeugen

Um ein Spielfeld zu bekommen, also ein Fenster, in dem unser Spiel stattfindet, musst du zuerst ein GameGrid-Objekt erzeugen und anschließend dieses Objekt mit der Methode show() anzeigen.

Mit dem Befehl

feld = GameGrid() 

hättest du bereits ein Spielfeldobjekt mit dem Namen feld hergestellt – aber wie es bei Objekten üblich ist (erinnere dich an den Toaster), werden bei der Erstellung sinnvollerweise gleich einige grundlegende Eigenschaften des Objekts gesetzt. Zum Beispiel ist die Größe des Spielfensters sehr wichtig, sonst wäre diese nämlich 0. Man kann ein GameGrid-Objekt mit verschiedenen Parametern erzeugen – die __init__-Funktion der GameGrid-Klasse ist flexibel und kümmert sich darum, es richtig zu verstehen.

Sehr einfach zum Beispiel ist die Erzeugung mit den Parametern breite,höhe:

feld = GameGrid(400,400) 

Damit erzeugst du ein Spielfeld mit einer Breite und Höhe von jeweils 400 Pixel.

Das Erzeugen des Objekts allein genügt aber nicht – man möchte es auch noch sehen. Dafür gibt es in GameGrid die Methode show(). Jetzt also das erste komplette Programm:

from gamegrid import *
feld = GameGrid(400,400)
feld.show()

Starte das Programm – und du wirst sehen, was passiert.

Abbildung 17.1    Ein Spielfenster wurde erzeugt. Größe: 400 × 400 Pixel, Inhalt leer und schwarz.

Du hast dein erstes Spielfeld erzeugt. Der Hintergrund ist schwarz, weil keine andere Farbe definiert wurde. Im Titel steht »Jython Game Frame« – auch da kann man natürlich etwas anderes hineinschreiben.

Mit dem Schließsymbol rechts oben (links oben beim Mac) kannst du das Fenster wieder schließen. Das löscht das Objekt und beendet somit dein Programm.

Wir können jetzt die Eigenschaften »Hintergrundfarbe« und »Titelzeile« gleich mal ändern. In gamegrid sind für Änderungen von Eigenschaften Methoden definiert. Man kann sie also nicht direkt als Objektvariablen ändern (wie zum Beispiel feld.titel = "Mein Titel"), sondern man macht das immer über die eingebauten Objektfunktionen, hier zum Beispiel: feld.setTitle("Mein Titel")

Die Hintergrundfarbe ändert man mit der Methode:

setBgColor(Farbe)

Dabei kann die Farbe hier auf verschiedene Weisen angegeben werden: zum Beispiel als RGB-Wert (drei Zahlen, die den Rot-, Grün- und Blauanteil der Farbe bestimmen).

feld.setBgColor(255,255,255) würde die Hintergrundfarbe auf Weiß setzen (RGB 255,255,255 ist weiß). BgColor steht dabei für das englische »background color« = Hintergrundfarbe.

Dasselbe ginge aber auch so:

feld.setBgColor(Color.WHITE)

Hier wird ein Objekt Color mit einer Eigenschaft WHITE verwendet (das ist auch Bestandteil der gamegrid-Bibliothek).

Und es ginge auch noch so:

feld.setBgColor(makeColor("white"))

Hier wird die Funktion makeColor() eingesetzt, die ein englisches Standard-Farbwort in ein Farbobjekt umwandelt.

Du kannst es machen, wie du willst – in diesem Beispiel verwende ich die RGB-Werte, weil man damit über 16 Millionen unterschiedliche Farben erzeugen kann, ganz nach Geschmack.

[+]  Wie findet man heraus, welche RGB-Werte eine Farbe hat?

Dank Internet ist das sehr einfach. Suche in deiner Suchmaschine einfach mal nach »Color Picker« – dann erhältst du zahlreiche Tools, mit denen du in einem Farbwähler den gewünschten Farbton heraussuchen kannst und sofort die drei Werte für R, G und B angezeigt bekommst. Geht in Sekundenschnelle.

Nun zur Titelzeile deines Spielfensters: Die änderst du ganz einfach über die Methode: setTitle("Text")

So sieht das jetzt im Ganzen aus:

from gamegrid import *
feld = GameGrid(400,400)
feld.setBgColor(255,255,255) 
feld.setTitle("Mein Spielfeld")
feld.show() 

Abbildung 17.2    Das Ergebnis: Ein weißes Spielfenster mit eigener Titelbeschriftung

Du kannst dem GameGrid-Spielfeld noch viel mehr Eigenschaften hinzufügen, auch schon beim Erzeugen. Es kann nicht nur Hintergrundfarben, sondern auch ein Hintergrundbild erhalten, das du selbst in einem Grafikprogramm erstellen kannst oder dir anderweitig besorgst (einige Bilder sind in TigerJython auch schon eingebaut und verfügbar).

Ändere die Zeile zum Erzeugen des Feldes mal folgendermaßen:

feld = GameGrid(600,600,1,None,"sprites/reef.gif",False)

Damit erzeugst du ein Spielfeld, das 600 × 600 Pixel groß ist, dessen Zellengröße 1 Pixel groß ist, das kein Raster anzeigt (dafür steht das None), das das eingebaute Bild reef.gif als Hintergrundbild verwendet und das keine Steuerungsleiste anzeigt (False). Teste es mal und sieh dir das Ergebnis an:

Abbildung 17.3    Toll, ein Korallenriff!

Wie man an dem Befehl sieht, kann man bei der Erzeugung des Objekts auch das sogenannte Raster des Spielfelds festlegen. Zum Beispiel kann das Spielfeld eine Zellengröße von 10 Pixel haben und aus 40 × 40 Zellen bestehen. Dann wäre es ebenfalls 400 × 400 Pixel groß, aber die Spielfiguren könnten sich nur von Zelle zu Zelle bewegen, also immer 10 Pixel. Dazu kommen wir später noch ausführlicher – es ist zum Beispiel für Brettspiele sehr praktisch. Zunächst einmal begnügen wir uns aber mit einem Pixel pro Zelle, wie gehabt.

Zusammenfassung

• Die Klasse, mit der du ein Spielfenster erzeugst, in dem sich dein Programm abspielen wird, heißt GameGrid.

• Du erstellst ein Spielfenster, indem du ein Objekt der Klasse GameGrid erzeugst, wie zum Beispiel feld = GameGrid().

• Du kannst dem Objekt bei der Erzeugung gleich grundlegende Eigenschaften wie Größe, Hintergrundfarbe, Hintergrundbild usw. als Parameter in Klammern mitgeben.

• Diese Eigenschaften lassen sich aber auch nachträglich anpassen, indem du die entsprechenden Eigenschaften und Methoden deines Objekts mit passenden Werten aufrufst.

• Damit das Spielfeld nicht nur als Objekt existiert, sondern auch auf dem Bildschirm zu sehen ist, musst du es am Ende mit der Methode show() sichtbar machen.

[+]  Mehr über gamegrid erfahren

gamegrid stellt sehr viele Klassen, Funktionen und Eigenschaften zur Verfügung. Mehr als wir in diesem Buch überhaupt verwenden können. Um einen guten Überblick zu bekommen, was es eigentlich alles gibt, empfehle ich, im Menü von TigerJython auf Hilfe zu gehen. Unter APLU-Dokumentation findest du eine Menge hilfreicher Links und Verweise – unter anderem auch zum Modul gamegrid, das die wichtigsten Methoden und Eigenschaften der enthaltenen Klassen aufzählt. Das kann oft weiterhelfen.