JUEGO DE LA VIDA

El juego de la vida es un autónoma celular fue diseñado por John Horton Conway.
Consiste en que dada una configuración inicial en un tablero automáticamente o seleccionada por el usuario, se empiezan a hacer iteraciones y las casillas van cambiando en el tablero dependiendo de ciertas reglas durante cada turno.

Solamente tiene un estado inicial y ya no es requerido alguna entrada por parte del usuario después de que empiecen las iteraciones.

COMPONENTES
Tablero: Es una malla infinita en todas las direcciones.
Células: Son los cuadros o celdas de la que esta formado la malla.
Vecinos: Son las 8 celdas al rededor de la que estamos analizando.

El estado de todas las células se lee de acuerdo a varias reglas y al siguiente turno cambian su estado a vivo o muerto, dependiendo del numero de vecinos que tengan.

REGLAS GENETICAS
Si la celula esta viva
- Si tiene 2 o 3 vecinos: Vive
- Si tiene menos de 2 vecinos o mas de 3 vecinos: Muere
Si la celula esta muerta
- Si tiene exactamente 3 vecinos: Vive
- Cualquier numero diferente de 3 vecinos: Muere

Al final o después de algunas iteraciones pueden darse tres casos con las poblaciones:
- Algunos elementos o todos desaparecen.
- Algunos elementos o todos quedan de manera estatica.
- Algunos elementos o todos pueden seguir cambiando indefinidamente o sin un patrón en particular.

MI CÓDIGO:
En este código solo muestro la función principal del juego, donde se recorre cada casilla y los alrededores de cada una para contar los vecinos que tiene, también se muestra como se aplican las reglas del juego.

int main()
{
    int xi[] = {-1,-1,-1,0,0,+1,+1,+1}; 
    int yi[] = {-1,0,+1,-1,+1,-1,0,+1}; 
   //Matriz inicial
    int M[10][10]={0};
    int AUX[10][10]={0};
    int n;
    M[0][1]=1;M[1][2]=1;M[2][0]=1;M[2][1]=1;M[2][2]=1;
        
    imprimir(M,0);  

   //Juego de la vida
  cout<<"\n\n Numero de interaciones?: ";
  cin>>n;
  for(x=1;x<=n;x++)//for de iteraciones
  {
      AUX[10][10]=0;
      for(i=0;i<10;i++)
      {
          for(j=0;j<10;j++)
          {
              vecinos=0;
              for(z=0;z<=7;z++)//for de casillas alrededor
              { 
                  if(i+xi[z]<0 || i+xi[z]>9 || j+yi[z]<0 || j+yi[z]>9)//si no existen las casillas
                  { }
                  else
                  {
                      if(M[i+xi[z]][j+yi[z]]==1)
                      {
                           vecinos++;             
                      }
                  }
              }
              //REGLAS
              if(M[i][j]==1)
              {
                   if(vecinos<2)
                   {
                        AUX[i][j]=0;
                   }else
                   {
                        if(vecinos>3)
                        {
                             AUX[i][j]=0;
                        }else
                        {
                             AUX[i][j]=1;
                        }
                   }
              }else
              {
                   if(vecinos==3)
                   {
                        AUX[i][j]=1;
                   }
              }//
              
          }
      }
      //pasar los datos del aux a la matrix principal
      for(i=0;i<10;i++)
      {
          for(j=0;j<10;j++)
          {
               M[i][j]=AUX[i][j];                           
          }
      }
      imprimir(M,x);    
  }
  system("PAUSE");
  return 0;
}

Utilice una configuración inicial llamada "Glider" igual a la de la siguiente pagina: http://www.bitstorm.org/gameoflife/ para comprobar que mi algoritmo funciona.

Interfaz Glider en el juego interactivo

Interfaz Glider en este programa

Conclusión: El juego de la vida es un interesante autómata celular y es muy sencillo de programar, con este ejemplo se puede tener mas claro lo que es un autómata celular, pues ya no tenemos que dar datos de entrada y el programa va generando datos el mismo.