 Autor
|
Tema: Juego de la vida - Simulacion en Java (Leído 5,335 veces)
|
LuisCardenas123
 Desconectado
Mensajes: 30
|
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
|
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... 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
ó: 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. 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) 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). 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. 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: 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: 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
Mensajes: 1.217
(e -> λ("live now")); tatuar -> λ("α");
|
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... 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
ó: 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. 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) 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). 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. 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: 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: 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: 1 Abril 2019, 10:55 am por rub'n »
|
En línea
|
If you don't have time to read, you don't have the time (or the tools) to write, Simple as that. Stephen ki |
|
|
|
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: 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: // 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...   |
|
|
|
« Última modificación: 1 Abril 2019, 12:26 pm por NEBIRE »
|
En línea
|
|
|
|
|
| Mensajes similares |
|
Asunto |
Iniciado por |
Respuestas |
Vistas |
Último mensaje |
|
|
|
Juego de la vida en Python
Scripting
|
SirLanceCC
|
1
|
6,127
|
9 Diciembre 2006, 14:39 pm
por SirLanceCC
|
|
|
|
Necesito ayuda para hacer un juego de simulacion de hackeo...
Java
|
rober1985
|
2
|
3,116
|
23 Junio 2008, 22:54 pm
por rober1985
|
|
|
|
Juego de simulacion
Juegos y Consolas
|
gamer12
|
1
|
2,406
|
6 Noviembre 2010, 18:57 pm
por Castiblanco
|
|
|
|
Trend Micro lanza juego de simulación: «Ataques dirigidos: The Fugle»
Noticias
|
wolfbcn
|
3
|
1,671
|
19 Junio 2015, 20:25 pm
por Vaagish
|
|
|
|
El juego de la vida
Programación C/C++
|
Kenji-chan
|
5
|
2,824
|
20 Noviembre 2016, 22:51 pm
por Kenji-chan
|
 |
