• Braulio Madrid

Autómata celular en python



El juego de la vida es un algoritmo que simula la vida bacteriana también llamado autómata celular. como algunas bacterias o células nacen o mueren, diseñado por el matemático John Horton Conway en el 70. En resumen este algoritmo hace:


  • establece inicialmente la posición de varias células en una rejilla.

  • establece por cada casilla de la rejilla los vecinos que tiene al lado.

  • compara su posición respecto a sus vecinos y establece quien nace y quien muere según 3 reglas


  1. una célula nace si tiene exactamente 3 vecinos a su alrededor

  2. una célula muere si sus vecinos son menores a 2 o si son mayores a 3

  3. si la vecindad sigue siendo 2 o 3 se mantiene vivo.


Últimamente estoy aprendiendo a programar en python y para probar cosas a veces uso la librería pygame o a veces solo la consola. He decidido aprender este lenguaje por lo versátil que resulta, está en auge y además para salirme un poco del uso del unity y probar a hacer otra cosa que no sea videojuegos e ir probando a crear algún programa.


Que se necesita para empezar.

Realmente no se necesita nada, he decidido usar python y en esta no usar ninguna librería para que sea fácil de portar, ahora puede usar librerías como gasp o pygame para ilustrarlo mejor, pero yo usaré la consola de Repl.it para ilustrarlo.


1. Generar el primer mapa aleatoriamente


Vamos a crear 2 variables globales que ayudará a construir la rejilla, luego creamos una variable board que guardara la rejilla que crearemos a partir del Método Map():

este metodo lo unico que hace es crear un array bidimensional en la que va guardando ceros y unos, también pudiera hacerse que guarde booleanos, con letras o con binarios, pero es más fácil con números.


2. Tengo el tablero pero no veo que tengo.


Ahora crearemos el método Draw, que lo que hará será tomar los datos del tablero en el parámetro data y volver a recorrerlo para cambiar los ceros y los unos por algún caractér que nos ayude a visualizar mejor el tablero e imprimir en consola el resultado.



3. Determinar la vecindad de cada célula


Esta es la parte más importante del proceso porque esta vecindad es la base del funcionamiento de las reglas.


Empezamos recorriendo de nuevo los datos del tablero que tenemos y preguntamos en cada casilla que hay en las 8 posiciones que me rodean, no contando la novena casilla que sería el centro osea la célula que estamos analizando.


Comenzamos a crear un contador de vecinos en la variable neighbor que mirará si las casillas vecinas son 1 y las irá agregando al contador.


Python tiene una forma curiosa de recorrer las listas y es que estando en la posición 0 y al decirle que vamos a la posición -1, este irá al último elemento de la lista, pero no ocurre lo mismo de si estas parado en el último elemento de la lista ir al primer elemento, por eso establecemos unas posiciones iniciales y-1 = arriba, y = centro, y+1 = abajo, lo mismo en x donde x-1 = izquierda, x = el medio, x+1 = derecha, similar a como uno alineará textos, pero establecemos un pequeño cambio y es que si el rango de recorrido para Y es >= 0 y <= a la máxima columna -1 entonces abajo = y+1, sino y=0 y lo mismo aplica a la posición X para determinar derecha = x+1, sino x = 0.


Lo único que queda es que compruebe si hay un 1 en data[vert][hori] == 1: para agregar 1 a los vecinos.


4. Visualizar a los vecinos



Este método es opcional y no será necesario, pero lo incluyo para poder comparar el tablero e ir casilla a casilla y comparar si es cierto que los vecinos si concuerda con la realidad, sobretodo en los bordes suele presentarse errores.


Por cierto si observan los vecinos de las esquinas no corresponden, pero eso no es del todo cierto, aunque veas los datos como un cuadrado, realmente van como una esfera, o como un wrap o un envuelto, donde el último dato en X, es vecino del primero, lo mismo con el último dato en Y, donde el siguiente vecino es el primero.


5. Aplicar las reglas para el nacimiento o destrucción de las células.


Para eso creamos el método update, que lo que hará será recorrer las listas usando los mismos índices y comparar según las reglas que sinteticé en 2


  • Si la célula está muerta y tiene 3 vecinos entonces nace

  • Si la célula está viva y si los vecinos son menores a 2 o mayores a 3 entonces muere


y retorna el nuevo mapa actualizado.


6. Es hora de ver como queda todo animado


Uso un número de iteraciones fijos en el bucle for, en cada ciclo, limpio la pantalla, dibujo, analizo, comparo, asigno el nuevo tablero, espero y repito.


El código está implementado en la página Repl.it, es una pagina muy util para probar lenguajes de programacion y no tener que instalarlos en el PC.


Conclusiones.


Python en lo poco que he estado probando es un lenguaje muy versátil y muy intuitivo, mejor que C#, tiene un fácil manejo de listas, arreglos y diccionarios.


La gente pregunta y de que me puede servir este algoritmo. pues este algoritmo es usado para la generación procedural de contenidos como explosiones, humo, simulación de vegetación, generación de geometría orgánica. muy útil en juegos.


Aqui les dejo el codigo completo, Nos vemos en el próximo Blog y escuchen el Juego de la vida de Daniel Santos.




© 2023 por Darkcom. Proudly created with Wix.com | Peñol, Antioquia, Colombia| +57 3113389725 | Politica de privacidad

  • GitHub
  • BMadrid
  • DarkcomDev
  • Darkcom.dev
  • Braulio-Madrid
  • YouTube Darkcom Tech
This site was designed with the
.com
website builder. Create your website today.
Start Now