Greenfoot Tutorial v1.0 / german passend zum Greenfoot System, Version 1.0
Autor: Michael Kölling
Deutsche Übersetzung: Claus Eikemeier
Dieses Tutorial ist eine Einführung in die Greenfoot-Objektwelt. Greenfoot ist ein Software-Werkzeug und wurde entwickelt, damit Anfänger Erfahrung mit der objekt-orientierten Programmierung sammeln können. Greenfoot unterstützt die Entwicklung von grafischen Anwendungen in der Programmiersprache Java™. Das System wurde an der Universität von Kent, Grossbritannien und der Deakin Universität, Melbourne, Australien entwickelt und programmiert. Weitere Informationen über das Greenfoot Projekt sind verfügbar auf der Webseite www.greenfoot.org Diese Anleitung wurde geschrieben für Personen, die sich mit dem Greenfoot-System vertraut machen wollen. Ziel ist es nicht, eine umfassende und komplette Anleitung bereit zu stellen, sondern eine kurze Einführung in die Nutzung, die Funktionalität und die Möglichkeiten des Greenfoot-Systems zu geben. Ausdrücklich muss gesagt werden, dass dieses Tutorial kein Lehrbuch für die Programmiersprache Java ist. Es wird erwartet, dass dem Leser Java bereits bekannt ist oder er sich entsprechende Hilfestellung holen kann. Dieses gilt insbesondere für das Durcharbeiten des zweiten Teils der Anleitung. Alle Aufgaben in dieser Anleitung gehen davon aus, dass ein Projekt schon existiert und erläutern, wie man mit diesem Projekt und dem Greenfoot-System arbeitet. Zusätzlich wird dargestellt, wie Veränderungen am Projekt gemacht werden können. Wir arbeiten dabei mit dem Projekt "Wombats". Einige andere Projekte können von der Greenfoot-Webseite heruntergeladen werden. Anwender, die eigene Projekte implementieren oder die grosse Änderungen an existierenden Projekten durchführen möchten, sollten auch das Programmierhandbuch („The Greenfoot Programmer's Manual) lesen. Hinweise, Korrekturen oder Ergänzungen, die diese deutsche Übersetzung betreffen, senden Sie bitte an Claus Eikemeier, eMail: Ceikemeier@gmail.com. Das Greenfoot-System und dieses Tutorial werden so, wie sie hier vorhanden sind, abgegeben. Sie können kostenlos durch jede Person genutzt und für nicht-kommerzielle Zwecke weitergegeben werden. Kein Teil des Greenfoot-Systems oder seiner Dokumentation darf einzeln oder in Verbindung mit anderen Dingen verkauft werden. Hierzu bedarf es einer schriftlichen Genehmigung der Autoren. Die Rechte (insbesondere das Copyright ©) für das Greenfoot-System liegen bei Poul Henriksen und Michael Kölling. Die Software für das Greenfoot-System kann von www.greenfoot.org heruntergeladen werden. Es
sind drei verschiedene Versionen des Systems verfügbar:
Vorbereitungen Es muss mindestens Java in der Version 5 (d.h. JDK 1.5) oder eine höhere Version auf dem Rechner, auf dem das Greenfoot-System installiert werden soll, installiert sein, damit Greenfoot fehlerfrei laufen kann. Im Allgemeinen wird empfohlen, dass die jeweils letzte stabile Version (d.h. nicht mehr im Beta-Stadium) von Java installiert ist. Das JDK kann man kostenlos von der Homepage von Sun Microsystems herunterladen: http://java.sun.com/j2se Es ist zu beachten, dass die JRE-Version (Java Runtime Environment) alleine für die Arbeit mit dem Greenfoot-System nicht ausreicht. Es muss in jedem Fall das JDK (Java Development Kit), welches neben dem JRE-Paket, auch die Compiler für den Java-Quellcode und für die Dokumentation und die Dokumentation selber enthält, installiert werden. Auf MacOS X ist eine J2SE-Version vorinstalliert. Diese Version ist ausreichend und folglich muss keine andere Version nachinstalliert werden. Für die Arbeit mit einem Windows-System, lädt man die Windows Version des Greenfoot-Installationsprogramms herunter. Das Installationsprogramm wird mit einem Doppelklick gestartet und man folgt den Anweisungen. Die Installation folgt der Standardvorlage für Programminstallationen auf Windows.
Benutzer des Betriebssystems Mac OS X laden
die Mac OS-Version der Software herunter. Die heruntergeladene
Datei ist eine gepackte Datei (ZIP-Datei), die in der Regel vom
Browser automatisch entpackt wird. Falls nicht, starten Sie den
Entpack-Vorgang durch Doppelklick auf die Datei. Das Installationsprogramm für alle anderen Systeme ist eine ausführbare JAR-Datei (Java-Archiv). Das Installationsprogramm wird mittels eines Kommandozeilen-Befehls gestartet, d.h. man startet zuerst eine Kommandozeile (Shell) und tippt ein:
java -jar greenfoot-installer-XX.jar (wobei XX die Versionsnummer der Installationsdatei ist). Auf einigen Systemen reicht es aus, die Datei doppelt anzuklicken. (Achtung: Es wird davon ausgegangen, dass das Java-JDK korrekt installiert wurde und somit „java“ über die Kommandozeile ausführbar ist. Falls nicht, bitte erst die Java-Umgebung nach Anleitung korrekt installieren.) Dieses Tutorial verwendet zwei Projekte, benannt 'wombats' und 'wombats2'. Sie werden gemeinsam mit diesem Tutorial ausgeliefert. Jedes Projekt erscheint in einem eigenen Verzeichnis im Dateisystem.
Abb.1: Das Wombat-Projekt im Greenfoot-System
Falls
dieses Tutorial aus dem Greenfoot-System heraus gestartet wurde,
ist das ok. Ansonsten starten Sie das Greenfoot-System nun:
Man sollte dann das System ähnlich wie in Abb. 1 auf dem Bildschirm aussehen. (Normalerweise sollten zu dem Zeitpunkt aber noch keine Blätter und keine Wombats in der „Welt“ existieren.) Das grosse hinterlegte Gitter, welches den grössten Teil des Fensters überdeckt, stellt „die Welt“ (world) dar. Da wir es in diesem Projektbeispiel mit Wombats zu tun haben (vgl. Fussnote 1) , sieht man hier die „Wombat Welt“ (WombatWorld). Rechts vom Fenster sieht man die Klassen-Anzeige. Hier sieht man alle Java-Klassen, die am Projekt beteiligt sind. Die Klassen „World“ (Welt) und „Actor“ (Akteur) sind in jedem Projekt vorhanden – sie werden automatisch vom Greenfoot-System angelegt und angezeigt. Alle anderen Klassen gehören zum Wombat-Projekt, und sind daher in anderen Projekten in der Regel auch anders (andere Anzahl, Struktur und Bezeichnung). Unter der Welt sind die Steuer-Elemente (Execution Controls) angeordnet: dieses ist der Bereich mit der„Act“-, der „Run“- und der „Reset“-Schaltfläche und dem Schieberegler („Speed“/ Geschwindigkeit). An der oberen rechten Ecke des Fensters ist eine Schaltfläche mit der Bezeichnung „Project Information“ (Projektinformation). In den meisten Projekten werden, wenn man auf die Schaltfläche klickt, einige Informationen zum Projekt angezeigt. Diese Informationen betreffen typischerweise den Zweck und die Funktion des Projektes, möglicherweise noch Informationen zur Bedienung und zusätzliche Hinweise, wie man es erweitern kann. Nun werden Objekte in der Welt platziert: Machen Sie einen Rechts-Klick (auf MacOS: Control-Click) auf die Wombat-Klasse in der Klassenanzeige auf der rechten Seite. Ein Pop-Up-Menü erscheint. Aus diesem wählt man „New Wombat()“ aus. Dann kann man irgendwo in die „Welt“ klicken. Dieser Vorgang hat ein neues Objekt vom Typ „Wombat“ erzeugt und dieses dann in der Welt platziert. Wombats essen Blätter (leaf), daher kann man jetzt auch ein paar Blätter in gleicher Weise in der Welt platzieren: Ein Rechts-Klick auf die „Leaf“-Klasse erzeugt ein neues Objekt und ein (Links-)Klick in die Welt legt das Objekt an der Stelle ab. Es gibt eine Vereinfachung, wenn man mehrere Objekte ablegen will: man klickt an den gewünschten Ort in der Welt während man die Umschalttaste („shift“) gedrückt hält. Dazu muss man sicherstellen, dass die Blatt-Klasse („Leaf“) ausgewählt ist, d.h. mit einem dicken Rahmen angezeigt wird. Dann hält man die Umschalttaste gedrückt und klickt an mehreren Orten in die Welt. Jeder Klick legt ein neues Objekt vom gewählten Typ in der Welt ab. Klicken Sie nun auf die „Act“-Schaltfläche in der Steuer-Elemente-Leiste. Sie sehen, dass jedes Objekt agiert. Dies bedeutet: jedes Objekt macht das, was ihm als Aktion vorgegeben wurde. Was genau vom Objekt gemacht wird, hängt davon ab, wie das Objekt definiert wurde – dazu kommen wir aber später noch. In unserem Beispiel ist den Blättern (Klasse „Leaf“) nichts als Aktion zugeordnet, Objekte der Klasse „Wombat“ bewegen sich im Gegensatz dazu in der „Welt“. Falls noch nicht gemacht, platzieren Sie jetzt ein paar Wombats, d.h. Objekte der Klasse „Wombat“ auf der Welt und drücken Sie die „Act“-Schaltfläche noch einmal. Alle Wombat-Objekte bewegen sich. Wombats essen gerne Blätter. Wenn also ein Blatt auf ihrem Weg liegt, werden sie es essen. Beobachten Sie dieses Verhalten. (Eventuell müssten Sie noch ein Blatt vor einem Wombat positionieren, damit Sie sehen können, wie es wieder verschwindet.) Klicken Sie auf die „Run“-Schaltfläche. Das ist äquivalent zum wiederholten schnellen Anklicken der „Act“-Schaltfläche. Man stellt fest, dass die Bezeichnung der „Run“-Schaltfläche sich zu „Pause“ verändert. Anklicken der „Pause“-Schaltfläche stoppt den Ablauf wieder. Der Schieberegler neben den Schaltflächen „Act“- und „Run“ steuert die Geschwindigkeit der Animation. Wenn man die Animation mittels der „Run“-Schaltfläche startet und dann den Schieberegler verändert, sieht man die Auswirkung sofort.
Anstatt das gesamte Szenario ablaufen zu lassen, kann man auch einzelne Objekt-Methoden aufrufen. Eine Methode ist eine einzelne Aktion, die ein Objekt ausführen kann. Falls noch nicht gemacht, platzieren Sie nun einen Wombat auf der Welt. Stoppen Sie die Animation, falls sie noch läuft. Dann klicken Sie mit der rechten Maustaste auf den Wombat. Man sieht, dass jedes Objekt der „Wombat-Welt“ ein eigenes Kontextmenü besitzt. (Abb. 2).
Abb. 2: Ein Kontext-Menü
Nun können Sie eine der angegebenen Methoden im Kontext-Menü anwählen und das Objekt führt die zugehörige Aktion aus. Wählen Sie zum Beispiel turnLeft() durch Anklicken aus. Diese Methode lässt den Wombat eine Linksdrehung ausführen. Versuchen Sie nun die Methode move(). Einige Methoden geben Rückgabewerte aus. Probieren Sie zum Beispiel die Methode getLeavesEaten(). Diese Methode gibt aus, wie viele Blätter der Wombat bis jetzt gefressen hat. Probieren Sie es aus. Vielleicht haben Sie bemerkt, dass auch eine Methode act() vorhanden ist. Diese Methode wird jedes Mal aufgerufen, wenn man auf die „Act“-Schaltfläche klickt. Wenn man somit die act()-Methode nur eines Objektes aufrufen möchte, kann man dieses durch direkten Aufruf im Kontext-Menü des jeweiligen Objektes tun. Falls man mehrere Objekte in der Welt platziert hat und diese Objekte nicht mehr haben möchte, d.h. man von ganz vorne anfangen möchte, gibt es einen einfachen Weg: man kann die ganze Welt „aufgeben“ und einfach eine neue erzeugen. Dieses wird in der Regel durch Anklicken der „Reset“-Schaltfläche in der Steuer-Elemente-Leiste (unten) erreicht. Man erhält eine neue, leere Welt. Die alte Welt wird automatisch verworfen (und damit auch alle Objekte, die darin waren), da man nur eine Welt pro Greenfoot-System bearbeiten kann. Wir haben eben gesehen, dass die Objekte in der Welt eigene Methoden besitzen, welche über das jeweilige Kontextmenü aufgerufen werden können. Die Welt selber ist auch ein Objekt mit eigenen Methoden, die Sie auch direkt aufrufen können. Wir haben im vorhergehenden Abschnitt gesehen, wie man eine neue Welt erzeugen kann. Nun wollen wir eine Methode des Welt-Objekts aufrufen. Über der Anzeige des Welt-Objektes steht der Titel mit dem Namen der Welt - in unserem Falle „WombatWorld“. Klicken Sie mit der rechten Maustaste den Titel an: man erhält das Kontextmenü des Welt-Objektes. Eine der Methoden in diesem Menü ist populate(). Probieren Sie die Methode einfach mal aus. Es ist eine Methode, die mehrere Blatt- (Leaf) und mehrere Wombat-Objekte erzeugt und sie auf der Fläche, sprich in der Wombat-Welt platziert. Man kann nun die Animation wieder mittels der „Run“-Schaltfläche starten. Eine andere Methode des World-Objektes ist ‘randomLeaves(int howMany)’. Diese Methode setzt einige Blätter an zufällig gewählten Positionen auf die Welt. Man beachte, dass der Methodenaufruf einen sog. Parameter („howMany“ / wie viele) vom Typ int (= Ganze Zahl / Integer) besitzt. Dieses bedeutet, dass man zusätzliche Informationen angeben muss, wenn man die Methode aufrufen will. Der „Name“ des Parameters – hier „howMany“ („wie viele“) - deutet an, dass man eingeben muss, wie viele Blätter auf der Welt positioniert werden sollen. Rufen Sie eine Methode auf. Eine Dialogbox erscheint und man kann den Wert des Parameters eingeben. Geben Sie eine Zahl ein: sagen wir: 12 und klicken Sie auf „ok“. Hinweis: Man stellt ggf. fest, dass – wenn man die Blätter in der Welt zählt – die Anzahl nicht mit der eingegebenen übereinstimmt. Es sind häufig weniger Blätter sichtbar als eingegeben. Dieses kommt daher, dass einige Blätter an gleichem Ort abgelegt wurden und sich somit überdecken. Sie liegen somit übereinander. Gut, jetzt haben Sie vielleicht genug davon, den Wombats zuzuschauen, wie sie letzlich einfach im Kreis laufen (und ggf. Blätter fressen). Wir kommen jetzt zu wirklich interessanteren Dingen: der Programmierung von interessantem Verhalten für unsere eigenen Wombats. Der Rest dieses Tutorials geht davon aus, dass der Leser elementare Kenntnisse über die Programmierung mit Java hat. Dieser Teil ist nicht gedacht für die Bearbeitung durch Personen, die erst mit der Programmierung beginnen oder Java noch nicht kennen. Man kann eigene Objekte – Wombats, oder irgendetwas anderes, was man möchte – einfach durch das Schreiben von etwas Java Quellcode für die Klasse dieses Objektes programmieren. Man kann auch die fertigen Objekte der Beispiele verändern. Das ist es, was wir jetzt machen werden. Klicken Sie die Wombat-Klasse in der Klassenanzeige doppelt an. Ein Texteditor erscheint und man sieht den Java-Quellcode der Wombat-Klasse. Das Erste, was wir verändern wollen, ist das Verhalten des Wombats, damit er in eine zufällig ausgewählte Richtung läuft, wenn er an irgendeiner Stelle nicht weiterlaufen kann. Dieses ersetzt das aktuelle Verhalten, bei dem der Wombat immer nach links abbiegt. Um dieses zu erreichen, fügen wir zu den Methoden der Wombat-Klasse eine Methode hinzu, die wir „turnRandom()“ (drehe in zufällig gewählte Richtung) nennen. Fügen Sie die folgende Methode zur Wombat-Klasse hinzu. Öffnen Sie dafür die Klasse im Editor und fügen Sie die folgende Methode ein. Schreiben Sie auch den einführenden Kommentar – er wird als Beschreibung der Methode in der Dokumentation verwendet! /** * Turn in a random direction. */ public void turnRandom() { // get a random number between 0 and 3... int turns = Greenfoot.getRandomNumber(4);
// ...an turn left that many times. for(int i=0; i<turns; i++) { turnLeft(); } } Danach verändern wir die Methode „act()“, welche die neu erstellte Methode turnRandom() nun verwenden soll. Die act() Methode sieht derzeit so aus:
public void act() { if(foundLeaf()) { eatLeaf(); } else if(canMove()) { move(); } else { turnLeft(); } } Ersetzen Sie den Aufruf von „turnLeft()“ am Ende durch den Aufruf der neuen Methode „turnRandom()“. Das war es dann schon! Nun probieren wir es aus. Klicken Sie im Editor auf die Schaltfläche „Compile“ um die Übersetzung zu starten. Falls Fehler angezeigt werden, beheben Sie diese und übersetzen Sie das Programm noch einmal. Wiederholen Sie dieses so lange, bis sich die Klasse ohne Fehler übersetzen lässt. Nun kann der Editor geschlossen werden. Bevor man das Projekt ausführen kann, muss man es aber übersetzen. Man kann das aus dem Editor heraus machen, oder aus dem Hauptfenster des GreenFoot-Systems. Wenn alles erfolgreich übersetzt wurde, kann man wieder Objekte erzeugen. Das Kompilieren (wenn es erfolgreich war) erzeugt automatisch ein neues Welt-Objekt. Es gibt zwei verschiedene Arten, wie man die Bilder von Objekten verändern kann: Man kann das Bild einer Klasse verändern und somit das normale Aussehen der Bilder für alle Objekte der Klasse. Oder ein Objekt kann per Software das eigene Bild verändern. Dieses verändert dann das Bild von nur diesem einen Objekt. Jedes Objekt kann sein Bild verändern, so oft es möchte. Um das Bild für eine ganze Klasse zu setzen, wählen Sie „Set Image...“ aus dem Kontextmenü der Klasse aus. Sie können dieses mit der Klasse „Leaf“ (Blatt) ausprobieren – verändern Sie das Bild z.B. in eine Banane, und der Wombat wird die Bananen essen (so, wie er vorher die Blätter gefressen hat). (Wahrscheinlich ist das aber nicht das, was ein professioneller Tierexperte im Zoo empfehlen würde, aber deshalb machen wir ja auch nur eine Simulation ... ;-) Greenfoot hat eine Sammlung von Bildern eingebaut, die hier genutzt werden können. Sie können aber auch eigene Bilder in den „images“-Ordner im aktuellen Projekt ablegen (hier: „wombats“) und dann verwenden. Die zweite Möglichkeit besteht darin, dass das Objekt selbst das Bild durch Ausführen eines Programmstückes tauscht. Dazu muss die Methode 'setImage', die das Objekt von der Klasse 'Actor' erbt, aufgerufen werden. Es gibt zwei Versionen der Methode 'setImage': eine erwartet einen Parameter vom Typ 'GreenfootImage', die andere nimmt den Namen einer Datei, liest deren Inhalt und konvertiert ihn in ein Objekt vom Typ 'GreenfootImage'. Wir werden die veränderte Version dieser Methode nutzen. Sie liest das Bild aus einer Datei ein. Das Ziel, welches wir damit erreichen wollen, ist, dass das die Wombats nicht falsch herum erscheinen, wenn sie von rechts nach links wandern. Dafür können wir das Bild 'wombat-left.gif' nutzen, welches sich im 'images' Unterverzeichnis befindet. Das Bild ist im GIF-Format gespeichert und zeigt das gespiegelte Bild des vorher genutzten Wombat-Bildes: der Wombat schaut nun nach links. Wir können das Bild des Wombats durch die nach links schauende Version ersetzen indem man folgendes schreibt: setImage("wombat-left.gif"); Wir werden diese Methode aufrufen, wenn der Wombat seine Richtung verändert. Dazu müssen wir die Methode 'setDirection(int Direction)' (direction = Richtung) der Wombat-Klasse modifizieren. Suchen Sie diese Methode im Quellcode der Wombat-Klasse. Wir werden einige Zeilen Programmcode hinzufügen und die Rotation korrigieren, wenn wir eine neue Richtung setzen. Wie schon erläutert nutzen wir das Bild mit dem nach links schauenden Wombat ('wombat-left'), wenn wir nach Westen oder Norden gehen, verwenden jedoch das original Wombat-Bild, wenn wir nach Osten oder Süden gehen. Passen Sie auf: das 'Wombat-left'-Bild schaut immer nach links und muss daher nicht gedreht werden, wenn sich der Wombat nach Westen bewegt. So sieht nun also die neue, verbesserte Version der Methode 'setDirection' aus:
/** * Sets the direction we're facing. */ public void setDirection(int direction) { this.direction = direction; switch(direction) { case SOUTH : setImage("wombat.gif"); setRotation(90); break; case EAST : setImage("wombat.gif"); setRotation(0); break; case NORTH : setImage("wombat-left.gif"); setRotation(90); break; case WEST : setImage("wombat-left.gif"); setRotation(0); break; default : break; } } Soweit, wie wir es jetzt verändert haben, soll unser Projekt jetzt erst einmal ausreichen. Natürlich müsste man weitere Veränderungen vorsehen, wenn es wirklich professionell gemacht sein sollte. So sollten die verwendeten Bilder eigentlich nur ein einziges Mal aus den Dateien (im Klassenkonstruktor) geladen werden und dann in Attributfeldern vom Typ GreenfootImage abgelegt werden. Dann kann man die beiden Bild-Objekte nutzen, um das häufige Austauschen der Bilder zu beschleunigen. Vielleicht sollte man auch eigene Bilder vorsehen, wenn der Wombat nach oben (Norden) oder unten (Süden) läuft – dieses überlassen wir aber als kleine „Grafik-Hausaufgabe“ den Lesern. Um Veränderungen am Verhalten der Objekte zu machen, muss man häufig auf einige Standardklassen des Greenfoot-Systems zugreifen. Das Greenfoot-System besitzt vier wichtige Klassen, die der Leser dafür kennen sollte: die Welt ('World'), den Akteur ('Actor'), das Bild ('GreenfootImage') und das System selber ('Greenfoot'). Prägen Sie sich hier am besten die englischen Begriffe ein, weil wir sie im Text und natürlich in den Programmstücken verwenden werden. Die ersten beiden Klassen, d.h. 'World' und 'Actor', sind in der grafischen Benutzeroberfläche sichtbar. Wir sind mit ihnen schon einigermassen vertraut. Sie bilden die Oberklassen für die Welt und die darin enthaltenen Objekte. Die Klasse 'GreenfootImage' wird verwendet, wenn man mit Bildern arbeitet. Die Klasse 'Greenfoot' bietet verständlicherweise den Zugang zu den Interna des Greenfoot-Systems. Der einfachste Weg, diese Klassen kennen zu lernen und sie zu verstehen und sinnvoll einsetzen zu können, ist der Blick in die Online-Dokumentation des Greenfoot-Projektes. Sie ist zu finden unter folgender URL: http://www.greenfoot.org/doc/javadoc/ Ausgehend von dieser Seite, kommt man zu einer Online-Version der Klassenbeschreibungen der Greenfoot-Klassen. Sie wird „Greenfoot API“ (Anwendungs- Programmier-Schnittstelle) genannt. Die Beschreibung kann auch als ein einziges, druckbares Dokument heruntergeladen werden. Rufen Sie die 'Inspect'-Funktion aus dem Menü eines beliebigen, aktuell geladenen Wombat-Objektes auf. Diese Funktion erlaubt einen Blick quasi in das Objekt hinein und ermöglicht, dass die aktuellen internen Werte (Attribut-Felder) dargestellt werden. Dieses ist sehr hilfreich, wenn man Klassen während ihrer Entwicklung testen möchte. Vielleicht haben Sie bemerkt, dass einige Attribut-Felder – wie z.B. 'leavesEaten' (Anzahl gegessener Blätter) - in der Wombat-Klasse selbst definiert sind – andere, die aufgeführt sind, aber nicht. Diese zusätzlichen Felder – wie beispielsweise x, y und die Rotation-Information – werden von der Oberklasse 'Actor' geerbt und sind in allen Objekten des Greenfoot-Systems vorhanden. Wenn ein Wert als Pfeil-Symbol dargestellt wird, dann enthält das Attribut-Feld einen Verweis auf ein anderes Objekt. Dieses nennt man „Objekt-Referenz“. Der Verweis zeigt somit auf ein weiteres Objekt, welches man durch Anklicken wiederum untersuchen kann. Nun ist es Zeit, dass das Leben unserer Wombats etwas aufregender wird: wir werden ein paar Hindernisse einführen, nämlich Steine (=rocks)! (Und wir gehen davon aus, dass die Steine so gross sind, dass die Wombats sie nicht überwinden können, sondern um sie herum laufen müssen...). Als erstes müssen wir dafür eine neue 'Actor'-Klasse erstellen. Dazu wählt man den Menüpunkt 'New subclass' (Neue Unterklasse) aus dem Kontextmenü der Klasse 'Actor'. Dieses erzeugt eine neue Klasse als Unterklasse der Klasse 'Actor'. Wenn der Name gefragt wird, geben Sie 'Rock' (=Stein) ein. Zusätzlich muss man auch noch ein Bild für die Klasse auswählen, damit sie in der „Welt“ auch sichtbar ist. Man kann – dank Google – Bilder im Internet herunterladen oder eines in einem beliebigen Grafikprogramm erstellen und dann im Unterverzeichnis 'images' (= Bilder) ablegen. Wenn man das vor der Erstellung der Klasse durchführt, wird das Bild auch in diesem Dialog mit angeboten. Für dieses Beispiel haben wir diese Arbeit schon gemacht und ein Bild eines Steines im entsprechenden Verzeichnis abgelegt. Das Bild heisst 'rock.gif'. Damit sollte das Problem für dieses Beispiel erledigt sein. Wählen Sie dieses Bild aus, klicken Sie auf die 'OK'-Schaltfläche und schon wird eine neue Klasse mit Namen 'Rock' erzeugt. Nun öffnen Sie den Editor für diese Klasse. Sie sehen, dass das Programm-Skelett schon automatisch erzeugt wurde. Tatsächlich müssen wir an dieser Stelle für die Klasse 'Rock' überhaupt keinen Programmcode schreiben. (Steine haben kein besonderes Verhalten, sie sind „einfach nur da“ und liegen den Wombats im Weg.) Schliessen Sie daher den Editor, kompilieren und testen Sie das ganze System. Als Test erzeugen Sie bitte einen neuen Stein (Klasse 'Rock') und platzieren sie ihn in der Welt. Voilà – wir haben einen neuen Stein erzeugt! Nun nutzen Sie diese neuen Objekte und testen Sie die Wombats. (Am einfachsten und schnellsten ist es vermutlich, wenn Sie die Methoden 'populate' und 'randomLeaves' des 'World'-Objekts nutzen und damit die Wombats und Blätter in der Welt positionieren. Die Steine können Sie dann noch von Hand hinzufügen.) Funktionieren sie wie gewünscht? Sie werden feststellen, dass sich die Wombats derzeit noch nicht um die Steine „kümmern“: sie laufen einfach über die Felder mit den Steinen hinweg oder besser durch sie hindurch. Naja, es wäre auch zu schön, wenn es tatsächlich so einfach gewesen wäre. Wir müssen natürlich noch etwas tun, damit die Wombats nicht über oder durch die Steine laufen, sondern vor ihnen die Richtung ändern. Das sollte jetzt kein grosses Problem für Sie sein: modifizieren Sie einfach die entsprechenden Methoden der Wombat-Klasse, so dass sich die Wombats wie gewünscht verhalten. Auch das ist eine kleine „Hausaufgabe“ (Sie bekommen hier aber gleich noch ein paar Hinweise dafür.) Wie
man grosse Änderungen durchführt oder komplett neue
Szenarien erstellt, kann in diesem einführenden Tutorial
nicht behandelt werden. Falls Sie dieses machen möchten,
haben Sie zwei Möglichkeiten: Sie können zum einen die
vorhandenen Szenarien untersuchen oder (zum anderen) Sie können
das sogenannte 'Programmer's Manual' (Programmierhandbuch) zum
Greenfoot-System lesen. Natürlich muss man auch die Dokumentation der im Greenfoot-System verwendeten Klassen, eben die 'Greenfoot API', zu Verfügung haben und nutzen. In ihr sind wertvolle Hinweise zu den Klassen, den Attribut-Feldern und den Methoden enthalten. Das letzte, was wir hier machen möchten, ist, einen kurzen Überblick geben, wie man das Problem mit dem „Durchwandern der Wombats durch die Steine“ umgehen kann, d.h. wir skizzieren, welche Veränderungen am System Sie machen müssten. Öffnen Sie den Editor mit der
'Wombat'-Klasse und suchen Sie die Wir müssen diese Methode so veränderen, dass sie auch den Wert 'false' (=falsch) zurückgibt, wenn ein Stein vor dem Wombat liegt. Dazu müssen einfach wir die letzte 'return'-Anweisung verändern. Sie lautet derzeit so:
return true; und sollte nun ersetzt werden durch das folgende „intelligente“ Programmstück:
List rocks = myWorld.getObjectsAt(x, y, Rock.class); if(rocks.isEmpty()) { return true; } else { return false; }
Dieses Programmstück holt eine Liste aller Stein-Objekte in der Zelle vor uns (man kann mehrere Objekte auf einem Feld ablegen). Falls diese Liste leer ist, können wir vorwärts gehen, sonst können wir es nicht. Das Projekt 'wombats2', welches auch mit dem Tutorial heruntergeladen wurde, enthält alle vorgestellten Änderungen und sollte somit mit dem von Ihnen „verbesserten“ 'wombat'-Projekt übereinstimmen. Sie können auch dort nachschauen, welche Veränderungen an den Programmstücken durchgeführt wurden.
Besuchen Sie auch die Greenfoot Homepage im WWW und schauen Sie dort nach weiteren Szenarien. Und natürlich: sprechen Sie mit anderen Greenfoot-Nutzern. Um sich an der Greenfoot-Community zu beteiligen, gibt es unter anderem zwei gute Möglichkeiten:
Die Adresse der Mailing-Liste ist: http://www.greenfoot.org/about/mailing.html Viel Spass beim Erkunden der verschiedenen „Greenfoot-Welten“!
1 Ein Wombat ist ein Tier, welches in freier Wildbahn nur in Australien vorkommt. Falls Sie es nicht kennen, schauen Sie es am einfachsten in der Wikipedia nach: http://de.wikipedia.org/wiki/Wombat . |
