John Conway's Game of Life

Conways Spiel des Lebens (nicht zu verwechseln mit dem gleichnamigen Familienspiel Spiel des Lebens) ist ein von dem Mathematiker John Horton Conway 1970 entworfenes System zweidimensional angeordneter zellulärer Automaten.

Das Spielfeld

Das Spielfeld ist in Zeilen und Spalten unterteilt und im Idealfall unendlich groß. Jedes Quadrat ist ein Zellulärer Automat (Zelle), der einen von zwei Zuständen einnehmen kann, welche oft als lebendig und tot bezeichnet werden. Zunächst wird eine Anfangsgeneration von lebenden Zellen auf dem Spielfeld platziert. Jede lebende oder tote Zelle hat auf diesem Spielfeld genau acht Nachbarzellen, die berücksichtigt werden. Die nächste Generation ergibt sich durch die Befolgung einfacher Regeln.

Die Spielregeln

Die Folgegeneration wird für alle Zellen gleichzeitig berechnet und ersetzt die aktuelle Generation. Der Zustand einer Zelle, lebendig oder tot in der Folgegeneration hängt nur vom Zustand der acht Nachbarzellen dieser Zelle in der aktuellen Generation ab.

Die von Conway zu Anfang verwendeten Regeln sind:

• Eine Zelle mit genau drei lebenden Nachbarn wird in der Folgegeneration neu geboren (birth).
  
  

  

  rot: Tote Zelle, die in der nächsten Generation geboren wird; grün: Nachbarn der Zelle
  
  
• Lebende Zellen mit weniger als zwei lebenden Nachbarn sterben in der Folgegeneration an Einsamkeit (death by isolation).
  
  
• Lebende Zellen mit mehr als drei lebenden Nachbarn sterben in der Folgegeneration an Überbevölkerung (death by overcrowding).
  
  

  

  magenta: Zelle, die in der nächsten Generation sterben wird; grün: Nachbarn der Zelle

Mit diesen drei einfachen Regeln entsteht aus bestimmten Anfangsmustern im Laufe des Spiels eine Vielfalt komplexer Strukturen. Einige bleiben unverändert, andere oszillieren und wieder andere wachsen oder vergehen. Manche Strukturen, sogenannte Gleiter (gliders), bewegen sich auf dem Spielfeld fort.

Es existieren weitere Varianten des Game of Life, bei denen Conways Regeln geändert oder ergänzt werden.

Realisierung als Java-Applikation nach MVC-Pattern

Hier einige Vorgaben, die die Funktionalität der einzelnen Komponenten näher spezifizieren sollen:

Model

Im Model-Objekt ist der derzeitige Zustand der Zellen der Zellkolonie in Form einer Boolschen Matrix gespeichert. Weitere Instanzvariablen sollten die Anzahl der Zeilen und Spalten der Matrix sein. Neben dem Konstruktor sind vor allem folgende Methoden zu implementieren:

• Die Methode int numberOfNeighbors(int x, int y) berechnet die Anzahl der lebenden Nachbarzellen der Zelle an der Stelle (x,y) innerhalb der Matrix.
• die Methode nextGeneration() berechnet aus der alten Zellmatrix die neue Zellmatrix,
• die Methode invertCell(int x, int y), die den Zustand einer Zelle umkehrt, also aus tot lebendig und aus lebendig tot macht,
• die Methode clear() versetzt die Matrix in einen ganz und gar leblosen Anfangszustand,
• die Methode randomFill() füllt die Matrix zufällig mit Boolschen Werten.

Es ist weiterhin zu beachten, dass sich an unserem Model-Objekt Observer registrieren lassen müssen. Damit muss die Model-Klasse von der Klasse Observable abgeleitet werden. Nach jeder Modifikation an der Zellmatrix müssen die Observer (bei uns das View-Objekt) benachrichtigt werden.

View

Das View-Objekt sorgt für die grafische Darstellung der Zellkolonie und ist Observer des Model-Objekts (Observer-Interface implementieren). Bei jeder Änderung des Model-Objektes bekommt das View-Objekt einen Zeiger auf das Model-Objekt übergeben. Das View-Objekt soll in Form eines Custom-JPanels realisiert werden. Dabei wollen wir die Zellmatrix mit Hilfe der JComponent-Methode (JPanel ist Unterklasse von JComponent) paintComponent(Graphics g) zeichnen. Innerhalb dieser Methode kann man mittels g.drawLine() bzw. g.fillRect() Linien bzw. Rechtecke zeichnen (das Objekt g repräsentiert quasi die Zeichenfläche). Die Methode paintComponent() wird bei Erzeugung des View-Objektes automatisch aufgerufen. Innerhalb des Konstruktors sollte die Größe unseres Custom-JPanels mit Hilfe eines Dimension-Objektes und der Methode setPreferredSize() so festgelegt werden, dass die Matrix auch vollständig angezeigt wird. Die Observer-Methode update() können wir später mit Inhalt füllen. Erzeugt zu Testzwecken einfach selbst eine Boolsche Matrix, die euer View-Objekt visualisieren kann.

Controller

Hier wird die Benutzeroberfläche unserer Applikation zusammengebaut. Folgende Benutzereingaben sollten vorgesehen werden:

• Eingabe der Anzahl der Reihen und Spalten der Zellmatrix,
• Leeren der Matrix,
• Auswahl eines 'schönen' Anfangspatterns per Auswahlliste, die Anfangspattern (einfache, kleine Pattern auswählen) zunächst mal direkt in Boolschen Matrizen speichern,
• Zufälliges Füllen der Zellmatrix,
• Schrittweise Animation,
• Generations-Counter,
• Einstellen eines Zoomfaktors (Angabe der Seitenlänge eines Zellquadrats in Pixeln),
• Automatisierte Animation mit steuerbarer Geschwindigkeit (mit Hilfe eines Threads SPÄTER),
• ein Menü, über das SPÄTER Pattern in einer Datei gespeichert bzw. aus einer Datei nachgeladen werden können, usw.

Neben dem Erzeugen und Zusammensetzen der Komponenten müssen die entsprechenden Listener implementiert werden. Im Konstruktor muss außerdem das View-Objekt beim Model-Objekt mittels addObserver() als Oberserver registriert werden. Als LayoutManager für die contentPane eigent sich wohl am besten das GridBagLayout.

» drucken: pdf | html