Game Of Life - Lebenssimulation mit einem zellulären Automaten

Unter einem zellulären Automaten soll hier ein unendlich ausgedehntes zweidimensionales Gitternetz aus quadratischen Flächen verstanden werden, zusammen mit einer Uhr und einer endlichen Anzahl Zuständen. Jedes Quadrat des Gitternetzes befindet sich zu einem gegebenen Zeitpunkt in genau einem der möglichen Zustände. Mit jedem Uhrtick geht jede Zelle nach bestimmten Regeln in Abhängigkeit vom Zustand der umgebenden Zellen in einen neuen Zustand über.

Das Spielfeld von Game Of Life ist ein Zeilen-/Spaltenraster auf einer abgewickelten Torus-Oberfläche, d.h., dass die jeweils gegeüberliegende Seiten miteinander verbunden sind. Der Automat verfügt über zwei Zustände ( hier Schwarz und Weiß ), von denen jede Zelle zu jedem Zeitpunkt genau einen annimmt.

Die hier verwendeten Regeln sind:

• wenn Weiß und genau drei  Nachbarn Schwarz, dann Schwarz
• wenn Schwarz und weniger als zwei schwarze Nachbarn, dann Weiß
• wenn Schwarz und zwei oder drei schwarze Nachbarn, dann Schwarz
• wenn Schwarz und mehr als drei schwarze Nachbarn, dann Weiß

Das Spiel beginnt  mit einer gewichteten Zufalls-Konstellation aus weißen und schwarzen Zellen, wobei die höhere Gewichtung auf den weißen Zellen liegt. Im Simulationsverlauf lassen sich verschiedene schwarze Zellgruppen mit auffälligen, mehr oder weniger stabilen Verhaltensmustern erkennen. Wer Spaß hat, kann mit dem  Programm ein wenig experimentieren. Durch einen Klick mit der Maus in das Spielfeld gelangt man in den Editier-Modus. Dort gibt es auch einen Beispiel-Modus mit drei von vielen möglichen stabilen Formen. Zwei dieser Formen bewegen sich über die Simulationsoberfläche und nach einer gewissen Zeit kommt es zu einer Kollision, die eine längere Kettenreaktion auslöst.

Das Kernstück des Programms wird durch zwei Vektoren gebildet, L_prev für den vorhergegangen Zustand aller Zellen und L für deren neuen Zustand:

var L_prev:Vector.<uint>;
var L:Vector.<uint>;

Der Startzustand ( Anfangs-Generation ) wird durch die folgende Schleife erzeugt, wobei die Gewichtung 90% zugunsten der weißen Zellen (BGCOLOR) gegenüber den schwarzen Zellen ( LIFECOLOR ) beträgt:

var ix:int=idx(m/2,n/2);			
for(var i:int=0;i<m;i++){
	ix=idx(i,0);
	for(var j:int=0;j<n;j++){
		L[ix]=Math.random()>0.90?LIFECOLOR:BGCOLOR;
		ix++;					
	};
};

Für die Neuberechnung wird zunächst mittels Zeigertausch der aktuelle Zustand zum "vorhergegangenen" Zustand umdeklariert und der ehemals "vorhergegangene" Zustand zum "Folgezustand". Man beachte, dass die für den Tausch notwendige Hilfsvariable tmp aufgrund der AS3-Vektor-Eigenschaften zwangsläufig vom gleichen Typ sein muss wie L und L_prev. Ein Vektor in AS3 ist ein typisiertes Array.

function swapL():void
{
	tmp=L;L=L_prev;L_prev=tmp;
}

In dem darauf folgenden Schleifenkonstrukt werden dann die o.g. Regeln bei der  Bildung des neuen Zustands umgesetzt. Die Funktion anzahlNachbarn(i,j) ermittelt die Anzahl der schwarzen Nachbarn einer Zelle (i,j).

swapL();
for(var i:int=0;i<m;i++){
	ix=idx(i,0);
	for(var j:int=0;j<n;j++){
		nachbarn=anzahlNachbarn(i,j);
		if(nachbarn>=2 && nachbarn<=3){						
			if(nachbarn==3){
				L[ix]=LIFECOLOR; 
			}
			else{
				L[ix]=L_prev[ix];	
			};
		}
		else{
			L[ix]=BGCOLOR; 		
		};		
		ix++;				
	};
};		

Schließlich wird der neue Zustand gezeichnet und der Game Of Life Zyklus kann sich wiederholen.

this.graphics.clear();
this.graphics.lineStyle(0.1,0xffffff);
for(i=0;i<m;i++){
	ix=idx(i,0);
	for(j=0;j<n;j++){
		with(this.graphics){						
			beginFill(L[ix],1.0);
			drawRect((j-1)*BITSIZE,(i-1)*BITSIZE,BITSIZE,BITSIZE);
			endFill();
		};
		ix++;					
	};
};