Projekt "Game of Life" - Entwurf
1. Wahl der Programmiersprache
Gem. Vorgabe ist das System in der Programmiersprache Java zu entwickeln.
Da Alternativen nicht zugelassen sind, entfallen in den folgenden Abschnitten
die üblicherweise erforderliche Überlegungen zur Wahl einer Implementierunsgsprache.
2. Gestaltung der Benutzungsoberfläche
Gem. Anforderungsdefinition sind folgende Funktionalitäten auf der
Benutzungsoberfläche bereitzustellen:
Eingaben
-
Spielfeldlänge: Eingabefeld für positive ganze Zahl zwischen
5 und 200 (Zellen)
-
Spielfeldbreite: Eingabefeld für positive ganze Zahl zwischen 5 und
200 (Zellen)
-
Anzahl der bei Zufallsbelegung zu setzenden lebenden Zellen: Eingabefeld
für positive ganze Zahl
-
Zeit zwischen der Anzeige zweier Generationswechsel: Eingabefeld für
positive ganze Zahl (Millisekunden)
-
Startknopf: Mausknopf zum Starten der Simulation
-
Stopknopf: Mausknopf zum Stoppen der Simulation
-
Knopf "Zufall": Mausknopf zum zufälligen Belegen des Spielfelds mit
einer vorgegebenen Zahl von lebenden Zellen
-
Knopf "Löschen": Mausknopf zum Löschen des Spielfelds
-
Drei Radioknöpfe "klein", "mittel" und "groß": Wahl der Anzeigegröße
Ausgaben
-
Spielfeld: rechteckiges Feld mit schwarzen und roten Punkten
-
Generationszahl: Nr. der Generation (positive ganze Zahl)
-
Fehlermeldungen und Hilfen: kurze Texte bis zu etwa 100 Zeichen, die die
Bedeutung der Eingabefelder beschreiben bzw. bei Fehleingaben kurze Hinweise
geben.
-
Zusätzlich werden alle o.g. Eingaben zur Kontrolle ausgegeben bzw.
fortlaufend angezeigt.
Die Wahl der Benutzungsoberfläche fällt auf ein Bildschirmfenster,
das alle o.g. Ein- und Ausgaben übersichtlich gegliedert darstellt.
Ein- und Ausgaben werden funktional und inhaltlich zu Gruppen zusammengefaßt
und auf dem Fenster angezeigt. Das wichtigste Ausgabeelement, die Spielfeldsimulation,
wird dabei in das Zentrum gerückt, alle übrigen Bedienelemente
werden an der oberen Fensterseite plaziert.
Abb. 2-1 zeigt den Entwurf der Benutzungsoberfläche, links oben
befinden sich die Knöpfe, in der Mitte die Radioknöpfe für
die Einstellung der Anzeigegröße, rechts die Textfelder für
die Eingabe. Unmittelbar über dem Spielfeld ist ein Hilfetext zu sehen,
wie er beim Überstreichen des Knopfes "Stop" angezeigt wird.
Abb. 2-1: Entwurf der Benutzungsoberfläche
3. Grobstruktur des Systems
Gem. Anforderungsdefinition ist das System mausgesteuert. Dies legt eine
Struktur des Systems nahe, bei dem die für die Berechnung des Game
of Life erforderlichen Objekte und Operationen sowie die für die Benutzungsoberfläche,
also für Ein- und Ausgabe einschl. zugehöriger Fehlerbehandlung,
erforderlichen Objekte und Operationen in getrennten Klassen untergebracht
werden. Hinzu kommt eine Klasse für den Start des Programms, in dem
die Methode main definiert wird.
Als Bezeichner für die drei Klassen wird gewählt:
-
starteGame: Klasse für den Start des Programms
-
GameFenster: Klasse für die Ein- und Ausgabe: Verwaltung des Anzeigefensters,
Fehlermeldungen, Hilfe etc.
-
Game: Klasse für die Operationen auf dem Spielfeld: Verwaltung des
Spielfelds, zufällige oder benutzergesteuerte Belegung der Zellen,
Berechnung von Folgegenerationen etc.
Das Zusammenspiel der drei Klassen zeigt die Darstellung in Abb. 3-1.
Abb. 3-1: Zusammenspiel der Klassen starteGame, GameFenster, Game
4. Klasse Game
Die Klasse Game stellt Objekte und Methoden für die Verwaltung des
Spielfelds bestehend aus lebenden und toten Zellen bereit. Wesentliche
Aufgaben sind die Initialisierung des Spielfelds und die Berechnung von
Folgekonfigurationen.
4.1. Datenstruktur
Bei dem Spielfeld handelt es sich um eine 2-dimensionale Matrix der Größe
nxm Zellen, wobei jede Zelle aus einer lebenden oder einer toten Zelle
besteht. Naheliegend ist die Implementierung durch ein 2-dimensionales
Array. Da die zu erwartenden bzw. überhaupt durch den Benutzer wählbaren
Spielfeldgrößen eine überschaubare Größe nicht
überschreiten, kann das gesamte Spielfeld im Hauptspeicher gehalten
werden. Überlegungen zur Reduktion des Speicherbedarfs, etwa durch
Implementierung des Spielfelds als dünnbesetzte Matrix, können
entfallen.
Auf dieser Grundlage ist eine Reihe unterschiedlicher Implementierungsalternativen
denkbar, die jeweils spezifische Vor- und Nachteile besitzen:
-
Abspeicherung einer Generation in einem Array der Größe nxm
vom Typ boolean:
-
Dies ist die naheliegendste Variante. Schwierigkeiten treten bei der Berechnung
der Zahl der Nachbarn für Zellen an den Rändern des Spielfelds
auf. Hierzu sind besondere Erweiterungen des Prüfalgorithmus erforderlich,
um Überschreitungen der Feldgrenzen abzufangen.
-
Abspeicherung einer Generation in einem Array der Größe (n+2)x(m+2)
vom Typ boolean:
-
Hier wird der Rand des Spielfelds an allen vier Seiten um jeweils eine
Zellenreihe/-spalte erweitert. Diese Zellen werden als permanent "tot"
angenommen. Die in der ersten Variante genannte Schwierigkeit entfällt,
da der Prüfalgorithmus nun für alle Zellen des eigentlichen Spielfelds
in gleicher Weise arbeitet.
-
Realisierung durch zwei Arrays vom Typ boolean:
-
Der Algorithmus verwendet zwei gleichgroße Arrays, von denen im Wechsel
das eine die aktuelle Konfiguration lebender und toter Zellen und das andere
die zugehörige Folgekonfiguration enthält. Ist die Folgekonfiguration
vollständig berechnet, tauschen beide Arrays ihre Funktion. Die beiden
Arrays lassen sich entweder durch zwei voneinander getrennte Arrays implementieren
oder - besser - durch ein dreidimensionales Array nxmx2 darstellen, bei
dem die ersten beiden Dimensionen nxm die Spielfeldgröße und
die dritte Dimension das erste bzw. zweite Array unterscheidet.
-
Realisierung durch ein Array eines Aufzählungstyps mit vier Elementen
(tot, lebendig, wird_tot, wird_lebendig):
-
Der Algorithmus verwendet nur ein Array. Die Werte wird_tot bzw. wird_lebendig
zeigen einen Wechsel des Zustands einer Zelle in der nächsten Generation
an. Die Herstellung einer Konfiguration besteht aus zwei Durchläufen
durch das Spielfeld: Im ersten Durchlauf wird für alle Zellen ihr
Folgezustand berechnet; bei einem Zustandswechsel wird die Zelle auf den
zugehörigen Wert wird_X gesetzt. Bleibt der Zustand erhalten, behält
die Zelle den Wert tot oder lebendig bei. In einem zweiten Durchlauf durch
das Feld werden dann die Zellen des Felds auf die korrekten Werte tot oder
lebendig aktualisiert.
Variante 1 und Variante 2 werden hinsichtlich Aufwand und Ersparnis als
gleichwertig eingeschätzt. Variante 4 reduziert zwar - obwohl nicht
zwingend erforderlich - den Speicherbedarf, erhöht jedoch den Implementierungsaufwand.
Für das geplante System wird daher eine Datenstruktur gem. Variante
1 in Kombination mit Variante 3 gewählt, wobei die booleschen Werte
false bzw. true tote bzw. lebendige Zellen markieren.
Als weitere Datenelemente für die Verwaltung des Spielfelds werden
verwendet:
-
Variablen für Länge und Breite des Feldes,
-
Variable zur Festlegung einer Anzahl zufällig zu belegender Zellen
für den Fall, daß vom Benutzer eine zufällige Belegung
des Spielfelds gewählt wurde,
-
Variable zur Protokollierung der aktuellen Generationenzahl.
4.2. Methoden
Auf der in 4.1 gewählten Datenstruktur sind folgende Methoden zu implementieren:
Konstruktor:
-
Game: dient zur Erzeugung eines neuen Spielfelds vorgegebener Größe
(Parameter: n, m) mit einer vorgegebenen Zahl zufällig lebender Zellen
(Parameter: anzahl)
Initialisierungsmethoden:
-
initializeMatrix
Funktion: Belegung aller Zellen beider Spielfelder mit false.
Arbeitsweise: Beginnend bei Matrixeintrag (0,0) bis Matrixeintrag (n-1,m-1)
werden alle Zellen beider Spielfelder auf false gesetzt.
-
randomMatrix
Funktion: Belegung einer bestimmten Zahl zufällig gewählter
Zellen mit true.
Arbeitsweise: Durch die Variable anzahl, die entweder mit dem Wert
50 vorbelegt ist oder durch den Benutzer gesetzt wurde, wird die Zahl der
gewünschten zufällig auf den Zustand "lebendig" gesetzten Zellen
bestimmt. Die Methode wählt dazu mit jedem Schritt zufällig und
unabhängig eine Zeile und eine Spalte des Spielfelds ausgewählt
und markiert sie als lebendig.
Die Methode verwendet die vordefinierte Methode random des Standardpakets
Math.
Methoden für Generationswechsel:
-
initializeGeneration
Funktion: Initialisierung des Zählers für die Zahl der Generationen.
Arbeitsweise: Belegung des Generationenzählers mit dem Wert 1.
-
incGeneration
Funktion und Arbeitsweise: Inkrementieren des Zählers für
die Zahl der Generationen
-
getGeneration
Funktion und Arbeitsweise: Lieferung des Zählerwerts für
die Zahl der Generationen
-
nextGeneration
Funktion: Berechnung einer Folgegeneration nach den vorgegebenen Spielregeln.
Arbeitsweise: Die zugrundeliegende Datenstruktur für das Spielfeld
besteht aus zwei gleichgroßen Spielfeldern, von denen das zweite
(3. Feldkomponente=1) als Hilfsfeld verwendet wird. Es nimmt kurzfristig
die Folgegeneration auf, wird aber nach deren vollständiger Berechnung
in das erste Feld zurückkopiert.
Formalisierung im Pseudocode:
var nb: integer;
for all Zellen c im Spielfeld (0) do
nb:=Anzahl der Nachbarn von c;
if c lebt und nb=2 oder nb=3 then mache c in Spielfeld(1)
lebendig;
if c lebt und nb>3 then mache c in Spielfeld(1) tot;
if c ist tot und nb=3 then mache c in Spielfeld(1) lebendig;
od;
Kopiere Spielfeld(1) nach Spielfeld(0);
Erhöhe Generationenzahl.
nextGeneration verwendet folgende lokale Methode für das Zählen
der Nachbarn einer Zelle (x,y):
-
countNeighbours
Funktion: Zählen der lebenden Nachbarn einer Zelle mit den Koordinaten
x und y.
Arbeitsweise: Alle Nachbarn der Zelle (x,y), also die Zellen mit Koordinaten
zwischen (x-1,y-1) bis (x+1,y+1), sofern innerhalb des Spielfelds, werden
überprüft und - sofern lebendig - in der Variablen zahl gezählt.
-
isSet
Funktion und Arbeitsweise: Prüft, ob eine Zelle (x,y) aktuell
lebendig oder tot ist, und liefert den zugehörigen Wert false oder
true.
-
setXY
Funktion und Arbeitsweise: Setzt eine Zelle bestimmter Koordinaten
(x,y) auf den Zustand "lebendig" (true).
-
deleteXY
Funktion und Arbeitsweise: Setzt eine Zelle bestimmter Koordinaten
(x,y) auf den Zustand "tot" (false).
Die Struktur der Klasse Game zeigt Abb. 4-1. Die vollständige Spezifikation
der Klasse befindet sich im Anhang.
Abb. 4-1: Struktur der Klasse Game
5. Klasse GameFenster
Die Klasse verwaltet die Ein- und Ausgabe des Systems und stellt die dazu
benötigten Objekte und Methoden bereit. Entsprechend der Anforderungsdefinition
nach einer mausorientierten, möglichst einfachen Bedienung des Systems
wird die Fenstertechnik eingesetzt. Ein durch die Klasse erzeugtes Fenster
enthält Schaltflächen und Eingabefelder für die Steuerung
des Programms durch den Benutzer, Textfelder zur Kommentierung, als Bedienungshilfe
und für Fehlermeldungen sowie einen Bereich für die Ausgabe der
jeweiligen Spielsituation als Matrix von lebenden und toten Zellen.
Ferner startet die Klasse die Simulation durch Aktivierung der Klasse
Game.
5.1. Datenstrukturen
Die Aufgaben der Klasse bestehen vorrangig in der Reaktion auf elementare
Ereignisse (z.B. Mausklicks, Texteingaben). Die Datenhaltung ist folglich
sehr einfach; sie besteht im wesentlichen aus der Speicherung von Eingaben
in elementaren Variablen oder Textfeldern, die der Benutzer zu Beginn oder
im Verlauf der Spielsimulation vornimmt.
Folgende Eingaben sind zu speichern; die zugehörigen Eingabewerte
werden in Variablen passenden Typs abgelegt:
-
Start und Stop einer Simulation: Hierfür werden zwei Schaltflächen
vorgesehen. Vorgesehene Variable: abbruch vom Typ boolean.
-
Wahl des Zoomfaktors (der Anzeigegröße, nicht der Größe
des Spielfelds): Es werden drei Schaltflächen "klein", "mittel" und
"groß" für drei verschiedene Größendarstellungen
definiert. Vorgesehene Variable: groesse vom Typ integer mit den Zoomfaktoren
2, 4 oder 8 für die Auswahlen "klein", "mittel" bzw. "groß".
-
Zwei Textfelder für die Eingabe von Länge und Breite des Spielfelds.
Vorgesehene Variablen: x und y vom Typ integer; Zahleneingaben außerhalb
des Intervalls [5..200] werden automatisch auf den kleinsten bzw. größten
zulässigen Wert korrigiert.
-
der Anzahl zufällig zu setzender lebender Zellen für den Fall,
daß eine Zufallssetzung gewählt wird. Vorgesehene Variable:
anzahl vom Typ integer.
-
Wahl der Anzeigegeschwindigkeit, d.h. der Dauer einer Anzeige in Millisekunden.
Vorgesehene Variable: warteZeit vom Typ integer.
Bei Fehleingaben, wie Werten falschen Typs, werden Fehlermeldungen ausgegeben.
5.2. Methoden
Entsprechend der Vorgabe, eine mausorientierte Bedienungsoberfläche
zu erstellen, wird zur Realisierung eine Ereignissteuerung gewählt.
Sie gestattet es dem Benutzer, zu beliebigen Zeiten in den Simulationslauf
eines Spiels einzugreifen und Eingaben vorzunehmen, ohne Eingabeaufforderungen
des Systems abwarten zu müssen. Eingaben werden vom System sofort
verarbeitet und ggf. für den weiteren Simulationsverlauf verwendet.
Dazu wird eine Reihe von Methoden als Ereignishandler implementiert.
Sie werden bei allen Benutzereingaben, seien es Klicken auf Knöpfe
oder Eingaben in Textfelder, aufgerufen, analysieren die entsprechenden
Ereignisse und aktivieren die dafür vorgesehenen Methoden für
die weitere Bearbeitung der Ereignisse.
Folgende Ereignisse sind auf der Benutzungsoberfläche vorgesehen,
die jeweils durch eine zugehörige Handler-Methode bearbeitet wird:
-
Mausklick in das Spielfeld
Anwendung: Definition von Zellen als "lebendig" oder "tot" bei manueller
Eingabe, Starten und Stoppen der Simulation, Zufallsbelegung, Spiel löschen.
Handler: mousePressed
-
Mausbewegung
Anwendung: Bei Bewegen der Maus über eines der Eingabeelemente
(Schaltfläche, oder Textfeld) wird ein passender Hilfetext angezeigt.
Handler: mouseMoved
-
Maus-Drag (Ziehen der Maus bei gedrückter Taste)
Anwendung: Definition aller beim Drag berührter Zellen als lebendig
oder tot. Alle berührten Zellen werden lebendig, wenn die Zelle, bei
der der Drag begann tot war, bzw. umgekehrt.
Handler: mouseDragged
-
Markieren eines Radio-Knopfs
Anwendung: Durch Markieren eines Radio-Knopfs kann zwischen den drei
verschiedenen Anzeigegrößen "klein", "mittel" und "groß"
umgeschaltet werden.
Handler: itemStateChange
-
Mausklick in ein Textfeld
Anwendung: Klicken in ein Textfeld mit Änderung eines Wertes,
z.B. der Spielfeldgröße.
Handler: actionPerformed
-
Mausklick auf eine Schaltfläche
Anwendung: Klicken des Start- oder Stop-Knopfs.
Handler: actionPerformed
5.2.1. Arbeitsweise der Methoden im Detail
Konstruktor:
-
GameFenster
Funktion: Erstellung eines neuen Fensters mit allen Eingabeelementen,
Zuordnung von Ereignisbearbeitern zu jedem Eingabeelement, Initialisierung
des Spielfelds
Arbeitsweise: Formalisierung im Pseudocode:
Erzeuge eine Population (Länge, Breite, Anzahl zufällig lebender
Zellen);
Erzeuge Spielfenster (Farbe, Größe, Bildschirmkoordinaten,
Layout);
Erzeuge Schaltflächen Start, Stop, Zufall, Löschen;
binde Schaltflächen an Handler;
Erzeuge Radio-Knopf(Beschriftung "klein",Knopfgröße,Initialwert
"nicht gedrückt");
Erzeuge Radio-Knopf(Beschriftung "klein",Knopfgröße,Initialwert
"gedrückt");
Erzeuge Radio-Knopf(Beschriftung "klein",Knopfgröße,Initialwert
"nicht gedrückt");
Erezuge Textfelder für Länge, Breite des Spielfelds, Anzahl
der zufällig lebenden Zellen und Wartezeit zwischen Generationen;
binde Textfelder an Handler;
Initialisierungsmethoden:
Ereignishandler:
-
actionPerformed
Funktion: Abfangen von Ereignissen, Analyse der Herkunft und Behandlung
Arbeitweise: Formalisierung im Pseudocode
Analysiere Ereignistyp;
if Ereignistyp=Textfeldeingabe then
tf=ereignisauslösendes Textfeld;
case tf of
Textfeld für Wartezeit zwischen Generationswechseln: Ändere
Wartezeit gem. Eingabe;
Textfeld für Länge des Spielfelds: Ändere Länge
gem. Eingabe;
Textfeld für Breite des Spielfelds: Ändere Breite gem. Eingabe
Textfeld für Anzahl der zufälligen Zellen: Ändere Anzahl
gem. Eingabe
esac
else
if Ereignistyp=Knopfdruck then
str=ereignisauslösender Knopf;
case str of
Startknopf: startAnimation
Stopknopf: stopAnimation
Knopf für Zufallsbelegung des Spielfelds:
begin
initializeMatrix;
randomMatrix
end;
Löschknopf: initializeMatrix;
esac
fi.
-
mousePressed
Funktion: Abfangen von Mausklicks in das Spielfeld und Setzen bzw.
Löschen von Zellen
Arbeitweise: Bestimmung der Koordinaten (x,y) der Zelle anhand der
Mausposition innerhalb des Fensters im Moment des Mausklicks
-
mouseMoved
Funktion: Abfangen von Mausbewegungen über ein Bedienungselement,
Ausgabe einer Kurzhilfe
Arbeitweise: Formalisierung im Pseudocode
Analysiere Position der Maus;
if Maus über Textfeld tf then Zeige geeigneten Hilfetext(tf)
else
if Maus über Schaltfläche b then Zeige geeigneten
Hilfetext(b)
else
if Maus über Radio-Knopf r then Zeige geeigneten
Hilfetext(r) fi
fi
fi
-
mouseDragged
Funktion: Abfangen von Mausbewegungen bei gedrückter Taste über
das Spielfeld
Arbeitweise: wie mousePressed. Der Zustand der Zelle beim ersten Tastendruck
(lebendig bzw. tot) bestimmt, ob die beim Überstreichen mit der Maus
bei gedrückter Taste berührten Zellen lebendig oder tot gesetzt
werden.
-
itemStateChanged
Funktion: Abfangen von Anklicken eines Radio-Knopfs
Arbeitweise: Formalisierung im Pseudocode
Analysiere Klick der Maus;
if Klick bei Radio-Knopf "klein" then
Zeichne Spielfenster in passender Größe neu;
Zoomfaktor:=2
else
if Klick bei Radio-Knopf "mittel" then
Zeichne Spielfenster in passender Größe neu;
Zoomfaktor:=4
else
if Klick bei Radio-Knopf "groß" then
Zeichne Spielfenster in passender Größe neu;
Zoomfaktor:=8
fi
fi
fi
Methoden zur Weiterverarbeitung von Ereignissen:
-
startAnimation
Funktion: Starten der Simulation
Arbeitweise: Erzeugung und Start eines neuen Prozesses (thread)
-
run
Funktion: Ablauf der Simulation
Arbeitweise: Formalisierung im Pseudocode
repeat
Berechne nächste Generation;
Zeichne Fenster mit paint neu;
until Benutzerabbruch;
-
setzeFensterGroesse
Funktion: Größe des Spielfensters je nach Wahl des Zoomfaktors
(Radio-Knöpfe: "klein", "mittel", groß") neu definieren
Arbeitweise: klar.
-
paint
Funktion: Abfangen von Anklicken eines Radio-Knopfs
Arbeitweise: Zeichnen des gesamten Spielfelds in das vorgesehene Rechteck
des Spielfensters.
Die Struktur der Klasse GameFenster zeigt Abb. 5-1. Die vollständige
Spezifikation der Klasse befindet sich im Anhang.
Abb. 5-1: Struktur der Klasse GameFenster
6. Klasse starteGame
Die einzige Aufgabe dieser Klasse besteht darin, ein neues Fenster zu erzeugen
und anzuzeigen. Dazu wird der Konstruktor GameFenster der gleichnamigen
Klasse aufgerufen, eine Instanz dieser Klasse erzeugt und mit dem Bezeichner
"neu" benannt. Als aktuelle Parameter für GameFenster werden die festen
Werte
-
50 (Zellen) für die Breite des Spielfeldes,
-
50 (Zellen) für die Länge des Spielfeldes und
-
400 für die Zahl der zufällig erzeugten lebenden Zellen
verwendet. Alle Werte können vom Benutzer anschließend im Dialog
abgeändert werden. Die vollständige Spezifikation der Klasse
befindet sich im Anhang.
Anhang
Klasse Game
Funktion: Bereitstellung von einer Methode zur Belegung
eines Feldes mit toten und lebenden Zellen sowie Methoden zur Berechnung
der neuen Generation
Instanzvariablen:
-
feld[][][]/ boolesches Feld mit lebenden und toten Zellen,
die dritte Dimension wird für die Berechnung neuer Generationen
benötigt
Belegung des Feldes: false = tote Zelle, true = lebende
Zelle
-
n,m/ Laenge und Breite des Feldes
-
anzahl/ Anzahl der mit zufall() zufällig belebten
Zellen
-
generation/ Zähler für die Generation
Verwendet von: class GameFenster
Verwendete Klassen: keine
Autor: Nina Schumer Datum: 04.09.2001
Konstruktor: Game
Funktion: Konstruktor, erstellt eine neue Game-Population
(tot)
Parameter:
-
n, m / Laenge und Breite des Feldes
-
anzahl / Anzahl der per Zufall erstellten lebenden Zellen
Aufgerufen von: Konstruktor in class GameFenster
Verwendung folgender globaler Variablen: feld[][][],
n, m, anzahl
Benutzte Methoden: initializeMatrix(), initializeGeneration()
Methode: initializeMatrix
Funktion: Initialisiert die Populationsmatrix mit toten
Zellen
Parameter: keine
Aufgerufen von: Game-Konstruktor in class GameFenster:
actionPerformed(ActionEvent) bei Betätigung des "Löschen"-Buttons
Verwendung folgender globaler Variablen: feld[][][],
n, m
Benutzte Methoden: keine
Methode: randomMatrix
Funktion: Belebung von "anzahl" zufällig ausgewählten
Zellen in der Populationsmatrix
Parameter: keine
Aufgerufen von: in class GameFenster: actionPerformed(ActionEvent)
bei Betätigung des "Zufall"-Buttons
Verwendung folgender globaler Variablen: feld[][][],
n, m
Benutzte Methoden: keine
Methode: nextGeneration
Funktion: Berechnet die nächste Generation der Population
nach den vorgegebenen Regeln
Parameter: keine
Aufgerufen von: in class GameFenster: run() (wenn
die Simulation läuft)
Verwendung folgender globaler Variablen: feld[][][],
n, m
Benutzte Methoden: countNeighbours(int, int), incGeneration()
Methode: isSet
Funktion: Liefert true zurück, wenn die angegebene
Zelle lebt, andernfalls (oder falls die Koordinaten außerhalb der
Arraygrenzen liegen) false
Parameter: x, y / Koordinaten der Zelle, welche nach
Lebendigkeit geprüft wird
Aufgerufen von:
in class GameFenster: mousePressed(MouseEvent) bei
MouseClick auf die grafische Darstellung des Feldes, um eine Zelle zu beleben
bzw zu töten
Verwendung folgender globaler Variablen: feld[][][]
Benutzte Methoden: keine
Methode: setXY
Funktion: Belebt eine Zelle
Parameter: x, y / Koordinaten der Zelle, welche belebt
wird
Aufgerufen von:
in class GameFenster: mousePressed(MouseEvent),mouseDragged(MouseEvent)
bei MouseClick und Ziehen auf der grafischen Darstellung des Feldes, um
Zellen zu beleben
Verwendung folgender globaler Variablen: feld[][][]
Benutzte Methoden: keine
Methode: deleteXY
Funktion: Tötet eine Zelle
Parameter: x, y / Koordinaten der Zelle, welche getötet
wird
Aufgerufen von:
in class GameFenster: mousePressed(MouseEvent),
mouseDragged(MouseEvent)
bei MouseClick und Ziehen auf der grafischen Darstellung
des Feldes, um Zellen zu töten
Verwendung folgender globaler Variablen: feld[][][]
Benutzte Methoden: keine
Methode: countNeighbours
Funktion: Zählt die Nachbarzellen einer Zelle
Parameter: x, y / Koordinaten dieser Zelle
Aufgerufen von: nextGeneration()
Verwendung folgender globaler Variablen: feld[][][]
Benutzte Methoden: keine
Methode: initializeGeneration
Funktion: Initialisiert generation mit 1
Parameter: keine
Aufgerufen von: Game-Konstruktor
in class GameFenster: actionPerformed(ActionEvent)
Betätigung des "Zufall"- oder "Löschen"-Buttons
Verwendung folgender globaler Variablen: generation
Benutzte Methoden: keine
Methode: incGeneration
Funktion: Inkrementiert generation um 1
Parameter: keine
Aufgerufen von: nextGeneration()
Verwendung folgender globaler Variablen: generation
Benutzte Methoden: keine
Methode: getGeneration
Funktion: Liefert den aktuellen Inhalt von generation
zurück
Parameter: keine
Aufgerufen von:
in class GameFenster: actionPerformed(ActionEvent),
run()
Verwendung folgender globaler Variablen: generation
Benutzte Methoden: keine
Klasse GameFenster
Funktion: Bereitstellung eines Fensters mit Schaltflächen
und Textfeldern zur Bedienung sowie einer Fläche zur grafischen Darstellung
der Bewegungssimulation
Instanzvariablen:
-
population / Eine Instanz von class Game
-
start, stop, zufall, loeschen / Schaltflächen
-
klein, mittel, gross / Checkboxen
-
xField, yField, anzahlField, geschwField/ TextFelder
-
groesse/ Multiplikator für die Darstellungsgroesse
-
warteZeit/ Zahl der Milisekunden zwischen dem Generationswechsel
-
t/ Thread - wird benötigt, damit die Veränderung
in der Matrix zeitlich gesehen visuell überschaubar bleibt
-
anzeigeText/ enthält den Text, der bei mouseMove
über Schaltflächen und Textfelder angezeigt wird
-
abbruch/ enthält true, wenn die Simulation gestopt
wird
-
anzeige/ true, wenn sich der anzeigeText ändert
und neu geschrieben werden soll
-
setzen/
-
true, wenn per MouseClick eine Zelle belebt wird
-
false, wenn eine Zelle per MouseClick getötet wird
Verwendet von: class starteGame
Verwendete Klassen: Game
Autor: Nina Schumer Datum: 04.09.2001
Konstruktor: GameFenster
Funktion: Konstruktor, erstellt ein neues Fenster mit
Bedienungselementen
Parameter:
-
n, m / Laenge und Breite des Feldes
-
anzahl / Anzahl der per Zufall erstellten lebenden Zellen
Aufgerufen von: class starteGame
Verwendung folgender globaler Variablen: population,
start, stop, zufall, loeschen, klein, mittel, gross, xField, yField, anzahlField,
geschwField
Benutzte Methoden:
in class Game: Konstruktor
Methode: actionPerformed
Funktion: Fängt Action-Ereignisse ab, erfragt deren
Herkunft und agiert entsprechend
Parameter: event/ enthält wichtige Daten über
das Ereignis
Aufgerufen: wenn ein ActionEvent auftritt
Verwendung folgender globaler Variablen: population,
xField, yField, anzahlField, geschwField, warteZeit, anzeigeText, abbruch
Benutzte Methoden: setzeFensterGroesse(), startAnimation()
in class Game: Konstruktor, getGeneration(), randomMatrix(),
initializeGeneration()
Methode: mousePressed
Funktion: Belebt oder löscht bei Mausclick eine
Zelle
Parameter: event/ enthält wichtige Daten über
das Maus-Ereignis
Aufgerufen: wenn ein MouseClick auftritt
Verwendung folgender globaler Variablen: setzen, groesse,
population
Benutzte Methoden:
in class Game: isSet(int, int), setXY(int, int),
deleteXY(int,
int)
Methode: mouseMoved
Funktion: Zeigt bei MouseMove über ein Bedienungselement
einen
erlklärenden Kommentar an
Parameter: event/ enthält wichtige Daten über
das Maus-Ereignis
Aufgerufen: wenn ein MouseMove auftritt
Verwendung folgender globaler Variablen: xField, yField,
anzahlField, geschwField, start, stop, zufall, loeschen, klein, mittel,
gross, anzeigeText
Benutzte Methoden: keine
Methode: mouseDragged
Funktion: Belebt oder löscht bei Ziehen der Maus
Zellen
Parameter: event/ enthält wichtige Daten über
das Maus-Ereignis
Aufgerufen: wenn die Maus bei gedrückter Taste
bewegt wird
Verwendung folgender globaler Variablen: setzen, groesse,
population
Benutzte Methoden:
in class Game: setXY(int, int), deleteXY(int, int)
Methode: itemStateChanged
Funktion: Fängt Item-Ereignisse ab, erfragt deren
Herkunft und agiert entsprechend
Parameter: event/ enthält wichtige Daten über
das Ereignis
Aufgerufen: wenn ein ItemEvent auftritt (Click auf
Checkbox)
Verwendung folgender globaler Variablen: groesse
Benutzte Methoden: setzeFensterGroesse()
Methode: startAnimation
Funktion: Startet den Thread, welcher für die Simulation
verantwortlich ist
Parameter: keine
Aufgerufen von: actionPerformed(ActionEvent) bei Start-Button-Betätigung
Verwendung folgender globaler Variablen: t
Benutzte Methoden: keine (automatischer Aufruf von
run())
Methode: run
Funktion: Startet den Thread, welcher für die Simulation
verantwortlich ist
Parameter: keine
Aufgerufen von: automatisch aufgerufen bei Start des
Threads
Verwendung folgender globaler Variablen: population,
t, abbruch, warteZeit
Benutzte Methoden:
in class Game: nextGeneration(), getGeneration()
Methode: setzeFensterGroesse
Funktion: Setzt die Fenstergroesse in Abbhängigkeit
von Feldgroesse und der Darstellungsgroesse
Parameter: keine
Aufgerufen von:
-
GameFenster-Konstruktor
-
actionPerformed(ActionEvent)
-
itemStateChanged(ItemEvent)
Verwendung folgender globaler Variablen: population,
groesse
Benutzte Methoden: keine
Methode: paint
Funktion: Funktion für die grafische Darstellung
Parameter: g/ stellt die grafischen Methoden zur Verfügung
Aufgerufen:
-
indirekt durch
-
repaint() in actionPerformed(ActionEvent),
-
mousePressed(MouseEvent),
-
mouseDragged(MouseEvent),
-
run()
-
direkt durch update()
Verwendung folgender globaler Variablen: population,
groesse, anzeige, anzeigeText
Benutzte Methoden: keine
Methode: update
Funktion: Diese Methode wird überlagert, damit repaint()
ohne flackern erfolgt. Es wird nur der Teil auf dem Bildschirm gelöscht,
der wirklich gelöscht werden muß
Parameter: g/ stellt die grafischen Methoden zur Verfügung
Aufgerufen: durch repaint() in
-
actionPerformed(ActionEvent),
-
mousePressed(MouseEvent),
-
mouseDragged(MouseEvent),
-
run()
Verwendung folgender globaler Variablen: population,
groesse, anzeige,
Benutzte Methoden: keine
Klasse starteGame
Funktion: Startet die Applikation, indem ein neues GameFenster
erstellt wird; enthält die main-Methode
Instanzvariablen: keine
Verwendet von: -
Verwendete Klassen: GameFenster
Autor: Nina Schumer Datum: 04.09.2001
|
|
Benutzer: Gast •
Besitzer: schwill • Zuletzt geändert am:
|
|
|
