Juego de la vida - Simulacion en Java

[LuisCardenas123]

Hola, muy buenas, que tal, estoy intentando simular el juego de la vida en Java, es un proyecto que me han mandado y me gustaría saber si alguien podría echarme un cable. Este es el enunciado del proyecto, y me gustaría saber mas o menos una idea para saber estructurarlo.
Muchas gracias de antemano.

---------------------------------------------------------------------------------------------------

El juego de la vida es en realidad un juego de cero jugadores, lo que quiere decir que su evolución está determinada por el estado inicial y no necesita ninguna entrada de datos posterior. El tablero de juego es una malla formada por cuadrados ("células") que se extiende por el infinito en todas las direcciones. Cada célula tiene 8 células vecinas, que son las que están próximas a ella, incluyendo las diagonales.  Las células que se encuentran en los extremos del tablero no son adyacentes. Las células tienen dos estados: están "vivas" o "muertas". El estado de la matriz evoluciona a lo largo de unidades de tiempo discretas (se podría decir que por turnos). El estado de todas las células se tiene en cuenta para calcular el estado de las mismas al turno siguiente. Todas las células se actualizan en cada turno. Las transiciones dependen del número de células vecinas vivas:
   -Una célula muerta con exactamente 3 células vecinas vivas "nace" (al turno siguiente estará viva).
   -Una célula viva con 2 o 3 células vecinas vivas sigue viva.
   -Una célula viva que tenga 0 o 1 células vecinas muere por "soledad".
   -Una célula que tenga más de 3 vecinas vivas o permanece muerta o muere por "sobrepoblación".

Diseña un programa en Java que simule una versión reducida del juego de la vida, teniendo en cuenta las siguientes restricciones:

   -Las dimensiones de la matriz son N x N, esto es, una matriz cuadrada, que no podrá superar las 25 casillas de
   largo y ancho.
   -La colocación de las células vivas se podrá realizar de forma aleatoria o bien manualmente por el usuario.
   -El número de células vivas a poner vendrá determinado por un porcentaje que determine el usuario por
   teclado. Esto es, suponiendo que el usuario introduce 25% y el tablero es de 10x10, entonces el número de
   células vivas a colocar sería el 25% de 100 (10*10).

Una vez creada la matriz y cargadas las células vivas, se mostrará la 1ª generación o generación inicial. A continuación se preguntará al usuario si quiere mostrar la generación siguiente o si quiere terminar. En caso de crear una nueva generación de células, se mostrarán la generación siguiente y la anterior, para poder comparar los cambios. El juego termina a petición del usuario o cuando no haya cambios de estados en 3 generaciones sucesivas.

---------------------------------------------------------------------------------------------------

[Serapis]

Puedes hacerlo de modo procedimental o con clases, a tu gusto...

Si lo haces con clases, por ejemplo crearía una clase 'tablero', en el constructor se recibe las filas y columnas (o cantidad) si ambos valores serán iguales.
También un parámetro para indicar cuandos e considera el mundo muerto, es decir si hay 25x25 casillas (625 células, podría consdierarse muerto (por ejemplo), si quedna menos de 50), un valor de cero o menor, podría indicar que vive mientras queden células vivas...
Acto seguido se crea un array bidimensional de  NxM casillas...

Código [Seleccionar] Expandir


int Filas, Columnas, MundoMuere

funcion New(int F, int C, int MM)
   filas = f
   columnas = C
   Si (MM < 0) luego MM=0)
   MundoMuere = MM

   dimensionar Mapa(filas, columnas)
fin funcion

ó:

Código [Seleccionar] Expandir

funcion New(int Casillas)



Una enumeración de 2-3 estados. Celula viva = '*' , célula muerta = ' ', celula 'enferma' = '-' (caso de que quisieras complicarlo y que una célula necesitara x estados (por ejemplo 1, y al siguiente muere) seguidos de transición por debajo del umbral de vida). es decir si no tiene los vecinos esperados y está viva, enferma, pero si está enferma muere.

Código [Seleccionar] Expandir

enumeración EstadoCelula
  ESTADO_VIVA = 0
  ESTADO_ENFERMA = 1  ' de 1 a 8, podría alojar 8 transiciones antes de morir, o pasar directamente del 1 al 9, o del 0 al 9
  ESTADO_MUERTA = 9
FIN ENUMERACION

Un array con los valores a dibujar (char/string)

Código [Seleccionar] Expandir


char  representa(0 a 9)
// con estos valores
   representa(0) = "*"  // viva
   representa(1) = "-"  //enferma
   // representa(2) = "-"
   //...  si se prefieriese dibujar estados de enfermedad diferentes o todos con '1'
   representa(9) = " " //muerta
 // tambén se puede hacer otro array con colores, para dibujar de diferente color vivas de 'enfermas'.

Otra enumeración de los valores de transicion:
(Tu pon los valores que quieras, de hecho es bueno modificarlos, para ver como se comporta).

Código [Seleccionar] Expandir

enumeracion Transicion
   TR_MUERE_INANICION = 1 // con 3 o menos células muere.
   // TR_VIVE = 2,3,4,5,6  / se entiende que viven con el rango dentro de ambos extremos.
   TR_MUERE_SOBREPOBLACION = 7
fin enumeracion

Una estructura retiene el estadO (de esos valores enumerados) y el recuento de vecinos.

Código [Seleccionar] Expandir


Estructura DatosDeCelula
   EstadoCelula Estado
   Transicion NumVecinos
fin estructura

Array de DatosDeCelula Mapa()



Una función se encarga de contar los vecinos, para cada célula:

Código [Seleccionar] Expandir

Funcion ContarVecinos()
   int i, j, k, n

   bucle para j desde 0  a filas-1
       bucle para k desde 0 a Columnas -1
           Mapa(j,k).Vecinos = ContarMisVecinos(j,k)
       siguiente
   siguiente
fin funcion

// contar los vecinos para esta célula...
Transicion = funcion ContarMisVecinos(int fila, int Columna)  
   int x, y, w, h
   int j, k
   Transicion vecinos

   Si (fila <2)    // tiene 1 o 0 vecinos a la izquierda
        x = 0
        w = fila + 2
   Si (fila > filas-3)  // tiene 1 ó 0 vecinos a la derecha
        x= fila - 2
        w = filas -1
   sino
        x= fila - 2
        w = fila + 2
   fin si

   Si (columna <2)    // tiene 1 o 0 vecinos arriba
        y = 0
        h = columna + 2
   Si (columna > Columnas-3)  // tiene 1 ó 0 vecinos abajo
        y = columna - 2
        h = columnas -1
   sino
        y = columna - 2
        h = columna + 2
   fin si

   bucle para j desde y hasta h
       bucle para k desde x hasta w
           Si (mapa(j,k).estado = ESTADO_VIVA ) luego  vecinos +=1
       siguiente
   siguiente

   devolver vecinos
fin funcion


Luego otra función que actualice el estado en base a sus vecinos:

Código [Seleccionar] Expandir


funcion UpdateMapa
   int j, k, vivas

   bucle para j desde 0 a filas -1
       bucle para k desde 0 hasta columnas -1
           si (Mapa(j,k).vecinos <= TR_MUERE_INANICION)
           o si (Mapa(j,k).vecinos <= TR_MUERE_SOBREPOBLACION)  // es una sola línea con la anterior, queda cortada en 2 por ser larga...
               mapa(j,k).estado = ESTADO_MUERTA
           si no  // hay que señalarla viva, porque antes podría estar muerta
               mapa(j,k).estado = ESTADO_VIVA
               vivas +=1
           fin si

           // char que representa el estado, fila, columna, color
           Dibujar(representa(mapa(j,k).estado ) ,j, k , color)
       siguiente
   siguiente

   Si (vivas <= MundoMuere) luego
       finpartida // no quedan células suficientes...
   fin si
fin funcion

Y una función dibujar para dibujar cada casilla (si no es muy complejo lo que deba hacer, puede subsumirse en la función anterior... (en 'dibujar...').

Básicamente eso es lo principal, generar las células al azar al comienzo de la partida, y algún otro detalle resulta ya nimio...

p.d.: Se me olvidada... al contar los vecinos, debe descontarse 1, si la célula en cuestión esta 'viva' (ella no debe contarse como su vecina). Es más fácil el doble bucle sin considerarla y luego descontarla que filtrarlo en el propio bucle (pués sucede 1 de las hasta 9 veces por cada casilla).

[rub'n]

Puedes hacerlo de modo procedimental o con clases, a tu gusto...

Si lo haces con clases, por ejemplo crearía una clase 'tablero', en el constructor se recibe las filas y columnas (o cantidad) si ambos valores serán iguales.
También un parámetro para indicar cuandos e considera el mundo muerto, es decir si hay 25x25 casillas (625 células, podría consdierarse muerto (por ejemplo), si quedna menos de 50), un valor de cero o menor, podría indicar que vive mientras queden células vivas...
Acto seguido se crea un array bidimensional de  NxM casillas...

Código [Seleccionar] Expandir


int Filas, Columnas, MundoMuere

funcion New(int F, int C, int MM)
   filas = f
   columnas = C
   Si (MM < 0) luego MM=0)
   MundoMuere = MM

   dimensionar Mapa(filas, columnas)
fin funcion

ó:

Código [Seleccionar] Expandir

funcion New(int Casillas)



Una enumeración de 2-3 estados. Celula viva = '*' , célula muerta = ' ', celula 'enferma' = '-' (caso de que quisieras complicarlo y que una célula necesitara x estados (por ejemplo 1, y al siguiente muere) seguidos de transición por debajo del umbral de vida). es decir si no tiene los vecinos esperados y está viva, enferma, pero si está enferma muere.

Código [Seleccionar] Expandir

enumeración EstadoCelula
  ESTADO_VIVA = 0
  ESTADO_ENFERMA = 1  ' de 1 a 8, podría alojar 8 transiciones antes de morir, o pasar directamente del 1 al 9, o del 0 al 9
  ESTADO_MUERTA = 9
FIN ENUMERACION

Un array con los valores a dibujar (char/string)

Código [Seleccionar] Expandir


char  representa(0 a 9)
// con estos valores
   representa(0) = "*"  // viva
   representa(1) = "-"  //enferma
   // representa(2) = "-"
   //...  si se prefieriese dibujar estados de enfermedad diferentes o todos con '1'
   representa(9) = " " //muerta
 // tambén se puede hacer otro array con colores, para dibujar de diferente color vivas de 'enfermas'.

Otra enumeración de los valores de transicion:
(Tu pon los valores que quieras, de hecho es bueno modificarlos, para ver como se comporta).

Código [Seleccionar] Expandir

enumeracion Transicion
   TR_MUERE_INANICION = 1 // con 3 o menos células muere.
   // TR_VIVE = 2,3,4,5,6  / se entiende que viven con el rango dentro de ambos extremos.
   TR_MUERE_SOBREPOBLACION = 7
fin enumeracion

Una estructura retiene el estadO (de esos valores enumerados) y el recuento de vecinos.

Código [Seleccionar] Expandir


Estructura DatosDeCelula
   EstadoCelula Estado
   Transicion NumVecinos
fin estructura

Array de DatosDeCelula Mapa()



Una función se encarga de contar los vecinos, para cada célula:

Código [Seleccionar] Expandir

Funcion ContarVecinos()
   int i, j, k, n

   bucle para j desde 0  a filas-1
       bucle para k desde 0 a Columnas -1
           Mapa(j,k).Vecinos = ContarMisVecinos(j,k)
       siguiente
   siguiente
fin funcion

// contar los vecinos para esta célula...
Transicion = funcion ContarMisVecinos(int fila, int Columna)  
   int x, y, w, h
   int j, k
   Transicion vecinos

   Si (fila <2)    // tiene 1 o 0 vecinos a la izquierda
        x = 0
        w = fila + 2
   Si (fila > filas-3)  // tiene 1 ó 0 vecinos a la derecha
        x= fila - 2
        w = filas -1
   sino
        x= fila - 2
        w = fila + 2
   fin si

   Si (columna <2)    // tiene 1 o 0 vecinos arriba
        y = 0
        h = columna + 2
   Si (columna > Columnas-3)  // tiene 1 ó 0 vecinos abajo
        y = columna - 2
        h = columnas -1
   sino
        y = columna - 2
        h = columna + 2
   fin si

   bucle para j desde y hasta h
       bucle para k desde x hasta w
           Si (mapa(j,k).estado = ESTADO_VIVA ) luego  vecinos +=1
       siguiente
   siguiente

   devolver vecinos
fin funcion


Luego otra función que actualice el estado en base a sus vecinos:

Código [Seleccionar] Expandir


funcion UpdateMapa
   int j, k, vivas

   bucle para j desde 0 a filas -1
       bucle para k desde 0 hasta columnas -1
           si (Mapa(j,k).vecinos <= TR_MUERE_INANICION)
           o si (Mapa(j,k).vecinos <= TR_MUERE_SOBREPOBLACION)  // es una sola línea con la anterior, queda cortada en 2 por ser larga...
               mapa(j,k).estado = ESTADO_MUERTA
           si no  // hay que señalarla viva, porque antes podría estar muerta
               mapa(j,k).estado = ESTADO_VIVA
               vivas +=1
           fin si

           // char que representa el estado, fila, columna, color
           Dibujar(representa(mapa(j,k).estado ) ,j, k , color)
       siguiente
   siguiente

   Si (vivas <= MundoMuere) luego
       finpartida // no quedan células suficientes...
   fin si
fin funcion

Y una función dibujar para dibujar cada casilla (si no es muy complejo lo que deba hacer, puede subsumirse en la función anterior... (en 'dibujar...').

Básicamente eso es lo principal, generar las células al azar al comienzo de la partida, y algún otro detalle resulta ya nimio...

p.d.: Se me olvidada... al contar los vecinos, debe descontarse 1, si la célula en cuestión esta 'viva' (ella no debe contarse como su vecina). Es más fácil el doble bucle sin considerarla y luego descontarla que filtrarlo en el propio bucle (pués sucede 1 de las hasta 9 veces por cada casilla).

Interesante respuesta doc, vere si tengo un tiempo para mudarlo a Java  

[Serapis]

Está escrito al vuelo, así que hay que 'cocinarlo' un poquito... pero es un punto de partida adecuado si uno está en blanco...

...por ejemplo al comienzo falta un parámetro de 'ocupación' que determinaría cuanto debe rellenarse el tablero al comienzo. Aquí la función New, un poquito más desarrollada:

Código [Seleccionar] Expandir


int Filas, Columnas, MundoMuere

funcion New(int F, int C, int MM, ocupacion)
   int i, j, k, max

   filas = f
   columnas = C
   Si (MM < 0) luego MM=0)
   MundoMuere = MM

   si ocupacion < minocupacion  // por ejemplo 10 (en referencia al 10%)
ocupacion = minocupacion
   osi ocupacion > maxocupacion  // por ejemplo 40 (en referencia al 40%)
       ocupacion = maxocupacion
   fin si
   max = (((Filas * Columnas) / 100) * ocupacion)
   
   dimensionar Mapa(filas, columnas)

   bucle para i desde 1 hasta max
       j = aleatorio entre 0 y Filas-1
       k = aleatorio entre 0 y Columnas-1
       Mapa(j, k).Estado = ESTADO_VIVA
   siguiente
   
   DibujarMapa
fin funcion


...para la enumeración, es preferible que CELULA_VIVA sea 9 y la muerta, sea 0, porque al crear el array, por defecto (según el lenguaje usado, claro), es 0 para todo el array, así basta luego marcar las vivas...

...o por ejemplo la partida acaba no solo cuando queden menos células de las indicadas sino también si se diera el caso (mucho menos probable por supuesto), que el mundo estuviera repleto. (... O Si vidas = (filas * columnas) - maxSeres luego Finpartida) //maxSeres sería al igual que minSeres, un punto de inflexión determinado, por defecto debiera ser filas * columnas.

...o en la función ContarMisVecinos, detrás del bucle (al final) olvidé descontar a sí mismo como vecino:

Código [Seleccionar] Expandir


// ya fue contada en el bucle, ahora se descuenta así misma.
Si (mapa(fila,columna).estado = ESTADO_VIVA ) luego  vecinos -=1

...o alguna discrepancia/inconsistencia menor: e alguna parte declaro NumVecinos, pero luego uso Vecinos...

En fin, cosas de escribir al vuelo... pero fáciles de darse cuenta y corregir al pasarlo a código.

Y por supuesto, el ejemplo no sigue al pie de la letra las reglas del enunciado de quien pregunta, requiere adaptarlo a las reglas que uno desee... Lo cual es trivial cuando uno lo entiende bien.

p.d.:
...por cierto, la función de contar los vecinos, cuenta los 24 vecinos, no los 8...