elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Rompecabezas de Bitcoin, Medio millón USD en premios


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  Java
| | | |-+  Juego de la vida - Simulacion en Java
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Juego de la vida - Simulacion en Java  (Leído 5,636 veces)
LuisCardenas123

Desconectado Desconectado

Mensajes: 30


Ver Perfil
Juego de la vida - Simulacion en Java
« en: 31 Marzo 2019, 16:53 pm »

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.

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


En línea

Serapis
Colaborador
***
Desconectado Desconectado

Mensajes: 3.391


Ver Perfil
Re: Juego de la vida - Simulacion en Java
« Respuesta #1 en: 31 Marzo 2019, 20:57 pm »

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:
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:
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:
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:
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:
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:
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:
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:
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).


« Última modificación: 31 Marzo 2019, 21:12 pm por NEBIRE » En línea

rub'n


Desconectado Desconectado

Mensajes: 1.217


(e -> λ("live now")); tatuar -> λ("α");


Ver Perfil WWW
Re: Juego de la vida - Simulacion en Java
« Respuesta #2 en: 1 Abril 2019, 01:10 am »

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:
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:
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:
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:
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:
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:
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:
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:
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  >:D
« Última modificación: 1 Abril 2019, 10:55 am por rub'n » En línea

rubn0x52.com KNOWLEDGE  SHOULD BE FREE.
If you don't have time to read, you don't have the time (or the tools) to write, Simple as that. Stephen king
Serapis
Colaborador
***
Desconectado Desconectado

Mensajes: 3.391


Ver Perfil
Re: Juego de la vida - Simulacion en Java
« Respuesta #3 en: 1 Abril 2019, 10:50 am »

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:
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:
// 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...  :silbar: :silbar: :silbar:  :laugh: :laugh: :laugh:
« Última modificación: 1 Abril 2019, 12:26 pm por NEBIRE » En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Juego de la vida en Python
Scripting
SirLanceCC 1 6,332 Último mensaje 9 Diciembre 2006, 14:39 pm
por SirLanceCC
Necesito ayuda para hacer un juego de simulacion de hackeo...
Java
rober1985 2 3,269 Último mensaje 23 Junio 2008, 22:54 pm
por rober1985
Juego de simulacion
Juegos y Consolas
gamer12 1 2,681 Último mensaje 6 Noviembre 2010, 18:57 pm
por Castiblanco
Trend Micro lanza juego de simulación: «Ataques dirigidos: The Fugle»
Noticias
wolfbcn 3 1,906 Último mensaje 19 Junio 2015, 20:25 pm
por Vaagish
El juego de la vida
Programación C/C++
Kenji-chan 5 3,087 Último mensaje 20 Noviembre 2016, 22:51 pm
por Kenji-chan
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines