Trasteando con el "Juego de la vida" de John Horton Conway

El Juego de la vida es un diseño de programación ideado por el matemático británico John Horton Conway en 1970, y basa su funcionamiento en un "mundo" en dos dimensiones (2D) el cual contiene cierto número finito de celdas que pueden estar o no ocupadas por una estructura. Posteriormente estas celdas varían su estado gracias a una "física" (conjunto de reglas) que dictan la dinámica y el estado del tablero. Aunque lo más importante y destacable de este proyecto, es el hecho de ver como un diseño tan simple es capaz de conseguir con su dinámica temporal que a veces emerjan interesantes y complejos patrones de movimiento.

Las reglas del juego original son las siguientes:

1. Una celda puede estar activa (on) o no activa (off). Si está activa se dice que es una célula viva.
2. Una célula muerta (celda off) con exactamente 3 células vecinas vivas "nace" (al turno siguiente esta celda muerta estará viva).
3. Una célula viva con 2 ó 3 células vecinas vivas sigue viva, en otro caso muere o permanece muerta (por "soledad" o "superpoblación").

Y esto es todo. Una reglas muy sencillas, que dan lugar a patrones a veces asombrosamente complicados. Esta es de hecho, la clave de todo: comprobar como es posible que surja complejidad a partir de un comportamiento de base muy simple.

A continuación os muestro brevemente lo fácil que es programar esta "física" en Javascript:

	var Game = function(board) {
	this.board = board;
	this.width = board.width;
	this.height = board.height;
	};
	Game.prototype.get = function(x, y) {
	return this.board.get(x,y);
	};
	Game.prototype.set = function(x, y, value) {
	this.board.set(x,y, value);
	};
	Game.prototype.step = function() {
	var
	current = this.board,
	width = current.width,
	height = current.height,
	i, j, neighbours, cell
	;
	this.board = new Board(width, height);
	for (i = 0; i < width; i++) {
	for (j = 0; j < height; j++) {
	neighbours = current.neighbours(i,j);
	cell = current.get(i,j);
	if (neighbours === 3)
	this.board.set(i,j, 1);
	else if (neighbours === 2)
	this.board.set(i,j, cell);
	else
	this.board.set(i,j, 0);
	}
	}
	};

Apenas 38 líneas de código que nos van a permitir disfrutar de increíbles patrones de movimiento como los siguientes (es importante hacer notar de nuevo que el estado inicial de las celdas va a determinar también el patrón de movimiento al principio):

Pues bien, a petición de la idea de un amigo (Sergio Hernandez), he desarrollado una variación sobre el Juego de la vida, donde simplemente vamos a tener en el "mundo" dos tipos de células vivas (en on): células verdes y células rojas (y también celdas muertas en off). Las reglas serán las mismas para cada tipo de célula viva, las cuales vivirán siguiendo sus propias normas (como si fuesen cepas independientes).

Dos pequeños cambios se añaden no obstante a las reglas orginales:

1. Si una celda resulta que es ocupada en un paso (step) a la vez por una célula roja y una verde se elige aleatoriamente el tipo de célula viva que permanecerá en esa casilla (dado que una celda sólo puede tener un estado determinado).
2. Si una célula viva detecta que en el siguiente paso (step) morirá por "soledad" o "superpoblación", cambiará su tipo. De modo que si una célula viva roja detecta que morirá en el siguiente paso, pero que si se vuelve verde no lo hará, cambiará su estado a célula verde.

El resultado de estos cambios es el siguiente (generando al azar el estado inicial del tablero):

Es interesante ver el modo en que estas dos cepas de células vivas compiten de alguna manera por el espacio disponible. A veces da la sensación de que se fagocitan unas a otras, o que incluso intenan "escapar" cuando notan la proximidad de "rivales". En muchas ocaciones incluso una cepa completa es eliminada por la contraria, terminando el tablero exclusivamente con células verdes o rojas.

Nota:  como ya hemos dicho, el resultado dependerá del estado inicial de las celdas, y en este ejemplo dicho estado inicial es aleatorio, por lo tanto, si queréis ver una nueva configuración dinámica simplemente tenéis que refrescar esta página en el navegador (botón F5). También es posible hacer 'click' en cualquier lugar del tablero para generar nuevas celdas vivas aleatoriamente, con lo cual podremos "modificar" el estado dinámico del juego sin necesidad de actualizar la página completa. 

También es importante ver como esta modificación parece de algún modo haber estabilizado el comportamiento del sistema, puesto que ahora, de media, la duración del movimiento dinámico antes de caer en estructuras fijas (que no avanzan sino que se quedan quitas con patrones estáticos) parece haber aumentado. Por ejemplo, en el siguiente caso os muestro el comportamiento del nuevo Juego de la vida desarrollado, pero en lugar de comenzar con una configuración al azar, voy a comenzar con una configuración muy parecida a la que usamos antes para el juego original (5 células vivas de cada color dispuesta en similar configuración):

Futuro trabajo.

Creo que es interesante seguir explotando este tipo de desarrollos en un intento de sacar algún tipo de conclusión teórica sobre la base del mismo. En este sentido es seguro que Sergio Hernandez me comentará algunas nuevas ideas de cambio, y yo, por mi parte, tengo intención de aplicar al desarrollo anterior un algoritmo de computación evolutiva buscando en principio aquellas configuraciones que más movimiento producen tras n pasos (es decir, aquellas que más "calor" generan, que más "energía" consumen y por lo tanto que maximizan la "entropía"), con lo cual espero conseguir (descubrir) aquellas configuraciones que den lugar a los patrones más complejos posibles, y detectar también si es cierto que complejidad y entropía (consumo de energía libre) correlacionan necesariamente, y si dicho resultado se puede generalizar para otras "físicas" (quizás incluso la de nuestro propio mundo).

Un saludo.