Me gustaría saber si alguien ha leído por algún lado o se le ocurre la manera de generar mapas tipo Worms. Me refiero a partiendo de un simple mapa de bits con un contorno (o pongamos otro caso, a partir de un polígono convexo de muchas caras por ejemplo) generar todo el terreno, dibujando las formas como cesped, tierra, base, donde corresponda. No es algo trivial, o a mi no me lo parece.
Gracias!
Una vez postearon por estos lares algo parecido, y hablaron de algo de mapas de booleanos creo recordar, aunq no estoy muy seguro...
De todas formas busque el post y no lo encontre, aunq seguro q alguien viene y te resuelve la duda.
Saludos! B)
Gracias, lo he encontrado
http://www.stratos-ad.com/forums/index.php...60&hl=booleanos poniendo "booleanos" en el buscador del foro. Voy a leer.
Pues no me ha servido de mucho la verdad. En ese post se discutían como generar el bmp aleatoriamente, esa silueta. Eso es trivial, dentro de lo que cabe. Lo que yo quiero es, partiendo de esa silueta, generar un terreno tipo Worms.
En realidad no partiría de una silueta de mapa de bits, sino de un polígono regular cóncavo (con posiblidad de entrantes y salientes, me refiero). Dicho poligono regular tendría sus píxeles ordenados "en el orden de las manecillas de un reloj", es decir, no sería una "sopa" o "bolsa" de píxeles.
De forma que así de buenas a primeras, para averiguar que terrenos serían cuestas y si quedarían hacia arriba o hacia abajo, podría ir sacando los vectores normales al plano. Luego entre cada uno de los vértices, y siguiendo la dirección del vector perperdicular al vector normal, ir colocando "hebras" de cesped sobre un mapa de bits. Y luego por supuesto transformar dicho mapa de bits en una textura.
Viendo los mapas del worms2, acojona el nivel de cosas que tienen en cuenta y el acabado "a mano" que se consigue. El problema principal son los contornos, porque el interior es una mera textura repetida.
Bueno, se me ocurren aproximaciones de esa guisa.
¿Ningún "paper" circulando por ahí con más información?
Un saludo!
(http://image.com.com/gamespot/images/screenshots/5/47995/worms2_screen002.jpg)
(http://image.com.com/gamespot/images/screenshots/5/47995/worms2_screen004.jpg)
Edit: estoy reeditando haber si termino en menos de 1/2 hora. Maldito tab!
Para la tierra es facil tienes una textura grande la cual se blendea con el borde, el problema es el cesped y el bajo tierra (cuando debajo de un bloque de tierra hay aire).
Esta es mi solucion:
Algoritmo Pogacha-Generador de pasto y bajo tierra.
bool MapaBooleano[MAX_Y][MAX_X]; // suponiendo que esta con el mapa
bool MascaraDePasto[MAX_Y][MAX_X]; // suponiendo que esta toda a false
for(j=0; j<MAX_Y; j++)
for(i=0; i<MAX_X; i++)
if(MapaBooleano[j][i] && !MapaBooleano[j-1][i]) MascaraDePasto[j][i]=true;
// con lo anterior tenemos una mascara de pasto delgada
De la misma forma se crea un bajo tierra
Y despues para pintarlo adecuadamente con pasto crecido
Color TexturaPasto[AltoPasto][MAX_X];
Color Pantalla[MAX_Y][MAX_X];
for(j=0; j<MAX_Y; j++)
for(i=0; i<MAX_X; i++)
if(MascaraDePasto[j][i] && !MascaraDePasto[j-1][i])
{
for(k=0; k< AltoPasto * 2; k++) if(!MapaBooleano[j+k][i]) break;
for(h=0; h< k; h++) Panatalla[j+k][i]=TexturaPasto[AltoPasto-k-1][i];
// o TexturaBajoTierra[k][i] pues empieza de arriba hacia abajo
}
Espero haber dado al clavo ;)
Obviamente estos dos, alto de pasto y alto de bajo tierra, deben ser tenidos en cuenta a la hora de poner la textura de la tierra.
Saludos
Perdon, he visto un error en mi post y es demasiado tarde para editar. Cuando digo "píxeles ordenados" quería decir "vértices ordenados" ;)
Ya veo pogacha, examinar píxeles encima de los cuales haya cielo y crear de esta guisa un máscara para el cesped que aplicar más tarde. Y luego sería plan de hacer lo mismo pero en dirección contraria para lo bordes de abajo. Bueno, es una idea. Gracias :)
Tendria algunos problemas. Cuando dices "fina"... y tan fina. Es de un pixel. Si la quisiera hacer de más con ese método directamente habría problemas. Imaina que me salgo del borde dibujando hacia abajo en un saliente el cesped. Pero bueno, como base, la idea es buena.
Más! quiero más opiniones :D
EDIT:
Arg! Que has editado tu también... a ver, sino entiendo mal el cesped, creo que lo dibujas"hacia arriba" por lo que se evita el error que he dicho de que se salga. De todos modos no me sirve hacia arriba, porque tendré presente el polígono para colisiones, por lo que necesito colisiones con el borde mismo. Aunque siempre se podría hacer un apaño, claro. Hice mal en decir que partía de una silueta de mapa de bits. Parto de un polígono cóncavo. Bueno, habría que pulir la idea pero como base puede servir.
Por ejemplo, dibujar hacia abajo, y luego aplicar al conjunto de la silueta una máscara para borrar los sobrantes. ¡Me gusta eso!
De todos modos, ¿te importaría explicar más y colocar menos código? Prefiero conceptos a código, gracias!
Lo unico que veo de incorrecto es que no controla los bordes pero se supone que esos detalles debes darselos tu ;).
Tengo la mala costumbre de apretar tab cuando estoy escribiendo codigo y automaticamente salta a Responder y si aprieto espacio me responde solo.
Saludos
Incluso se podría mirar también los píxeles adyacentes y mirar de esa forma cuan abrupto es el terreno. Si te fijas en el worms cuando las cuestas son muy pronunciadas coloca menos tierra de la de los bordes que están hacia abajo.
Sí me mola esta idea de hacerlo con máscaras y tal. Más lenta que usando vectores pero quedará mejor.
Gracias de nuevo.
La idea esta.
Primero hago una mascara donde digo en esta poscion hay aire y abajo pasto.
Despues digo cuanta tierra hay debajo de este lugar donde se cumple lo de arriba lo guardo en la variable k con tope Alto del Pasto * 2.
Dibujo pasto hacia abajo, pero empezando de la parte de arriba del pasto, el ancho de esta franja vertical de pasto lo dara k/2, de esta manera tendre en el caso que halla mucha tierra el tope del alto de pasto y sino el tope sera la mitad del alto de la franja de tierra, por que la mitad, para permitir el bajo tierra viniendo desde abajo.
En realidad se puede hacer sin la mascara.
Por cada punto de la pantalla:
Si hay tierra en este punto y en el punto de arriba hay aire
{
Cuento cuanta tierra hay hacia abajo.
Dibujo pasto desde el punto acual hacia abajo, la altura es la mitad del alto de la franja vertical de tierra o el tope de alto del pasto segun cual sea menor.
}
En realidad el alto de la franja es la misma, es un efecto de la inclinacion lo cual hace que parezca menos por ser mas delgada.
Sí? Pues menos trabajo. Va a ser muy divertido programar esto.
Más que máscara de cesped, lo que haré será empezar por el borde de arriba a abajo y dibujar píxeles sacados de un mapa de bits pequeñito con el dibujo del cesped. Para que se quede bien dibujado. Iré avanzando de izquierda a derecha ese bmp, y dibujando "tiras" hacia abajo :)
EDIT:
Arg!!! Te adelantaste otra vez! Y encima yo no había tenido en cuenta lo de la mitad del borde ;) que es mejor que aplicar al final una máscara para eliminar sobrante y encima permite que en ese punto haya tierra de la de abajo.
Muchas gracias Pogacha! En vez de cerebro parece que tienes una cpu! :D
(http://img84.exs.cx/img84/7162/pogacha1jl.png)
En este dibujo se ven claros como el pasto se dibuja desde arriba hacia abajo, hasta la mitad de la franja de tierra o hasta el tope ( en este caso 3 pixels ).
Saludos
I love you. Lo completaré con una textura tanto de cesped como de tierra hacia abajo no de un pixel de ancho, sino de varios más. Va a quedar de lujo. (uoh)
Por cierto esto no parecía un foro, parecía un chat :D
Ya estas obligado moralmente a mostrarlo en el foro!
Suerte!
Je, pues si te animas tu antes adelante, porque yo lo mismo no tengo tiempo hasta dentro de 2 meses, que estoy ahora con mil cosas. Pero mira, la idea, que es lo importante y lo que me interesaba por ahora, ya la tengo :)
Gracias de nuevo.
Coincido con Pogacha en la parte de asignar la textura pero no en la de generación de "bordes".
Su algoritmo es de fuerza bruta y requiere operaciones de CPU por cada pixel y uso de bloques de memoria (ancho*alto). A medida que aumentas la resolución y dimensiones, se hace más lento. Ojo, es válido, pero yo propongo esto:
Yo haria una rasterización vertical (conversión a scanlines) de los polígonos aprovechando que los vértices ya los tienes ordenados en el sentido de las agujas del reloj. El algoritmo es similar al de render por software de poligonos, solo procesas los bordes, no todos los pixeles.
Asumo 2 cosas:
1. Vertices ordenados en el sentido de las agujas del reloj
2. Las aristas no se cruzan, no es un polígono degenerado.
3. El polígono esta cerrado, ultimo vértice está conectado con el primero.
Algoritmo para cada poligono:
1. Preparas un span buffer (s-buffer) por cada columa de pantalla. sbuffer[ancho_pantalla]. Lo inicializas vacío.
2. Selecciono vertice con la coordenada Y más elevada (importante).
Para todo vertice del poligono:
3. Calculo deltaX respecto a siguiente vertice (vertices_x[2]-vertices_x[1]).
4. Si deltaX>0 es un borde superior (pasto/hierba), si es <0 es inferior (fin roca, debajo hay aire) y si es 0, es el mismo tipo que el segmento anterior.
5. Interpolar la coordenada Y a lo largo de X e insertar en el sbuffer
- (ordenado, una simple lista enlazada vale, que habrá pocos scanlines por cada columna, normalmente 1 o 2).
5. volver a .3 mientras quedan segmentos.
Ahora tienes para cada columna de pantalla (X) una lista de posiciones Y donde empiezan y acaban los pixeles del terreno, primer valor es un inicio, siguiente un final, siguiente otro inicio, etc...
Los dibujas como ha dicho pogacha.
Complejidad del algoritmo: lineal, O(ancho_mapa+numero_vertices) en lugar de O(ancho_mapa*alto_mapa), y uso de memoria muy inferior. Además no necesitas calcular primero la mascara de bits.
Aclaro lo de deltaX=0, consideras que el segemento es del mismo tipo que el anterior de cara a texturar bordes (lo guardas aparte como caso especial si quieres borde por todo el contorno) , pero no insertas sus bordes en el sbuffer.
Como regla general puedes simplemente ignorar los segmentos totalmente verticales si quieres.
Bueno, me da vueltas la cabeza pero despues de 3 horas programando y preparando grafiquillos ya tengo un resultado más o menos decente. Faltan por pulir detalles y tal, pero bueno.
La verdad, es que el uso de la libreria gráfica que tengo (a ver si algún día de estos la cuelgo en algún lao) me ha ayudado mucho en cuanto a cosas de bajo nivel. Porque ya tenía hecha toda la parte de crear una imagen procedural, cortar y pegar bloques, sets, gets, cargar y salvar a disco, transformar la imagen en una textura cortando los bloques automáticamente, etc.
El mapa se genera muy rápido, no he mirado cuanto, pero menos de un segundo.
Senior Wapo, gracias por la recomendación, pero creo que sobra velocidad, dado que el mapa se va a generar en tiempo de carga en el editor.
Gracias Pogacha de nuevo por los consejos, el código no lo miré porque suelo liarme con el código ajeno, pero las ideas fueron muy acertadas y ataste todos los cabos. Y gracias también a ti Matriax por prestarme los gráficos.
(http://www.pixelartgames.com/temporal.png)
(genial)
Eyyy que bueno (ole)
Mas imágenes, un poco tochas (sorry).
(http://www.pixelartgames.com/source2.png)
===>
(http://www.pixelartgames.com/temporal2.png)
Quedo mejor de lo que crei.
Pero noto un error.
Se ve claro en la letra L de lover, el pasto tiene que llegar a la mitad (o un porcentaje arbitrario, quizas 2/3 sea mas adecuado) del alto de la franja de tierra y aqui crece hasta el fondo.
Sobre lo que dice el senior Wapo es todo cierto, mi algortimo hace varias pasadas por pixel y si usas span buffers la redundancia sera 0.
En realidad unos de los tipos del team 17 (que hacen el worms) paso por aca y dejo spam de sus sitio.
http://www.sortgames.comSaludos
Deberías poner el source, mas de uno te o agradecería (uoh) .
@Offtopic
Sacrifai:
Que es ese numero que solo 1/20 programador conoce?
Las siglas tag del formato PNG ?
Mola como ha quedado (ole)
Subsanado el error, gracias Pogacha.
Bueno, mi código no es muy elegante. Además necesitarás mi libreria gráfica (LooverLib, xD) para compilarlo. Si quieres puedo empaquetarla y subilar también, aunque la documentación está al 95%. Aunque las funciones que he usado si están documentadas.
Bueno, ahí va el código, que se podrá mejorar mil veces (por ejemplo colocar el cesped y la arena es prácticamente el mismo procedimiento y se podría hacer en una sola función cambiando parámetros) pero me vale así, xD:
/*
==================
Genera un mapa del juego a partir de un mapa de bits en blanco y negro
==================
*/
void GenerateMap (LOV_Image *pSource,
LOV_Image *pTexBase,
LOV_Image *pTexUp,
LOV_Image *pTexDown)
{
int x, y, k, alt;
int mCes = 0;
// Colocamos la textura base
for (x = 0; x < pSource->GetWidth(); x ++)
{
for (y = 0; y < pSource->GetHeight(); y ++)
{
byte R1, G1, B1, A1;
mGame.ImageManager->GetPixel (pSource, x, y, &R1, &G1, &B1, &A1);
if (!R1)
{
mGame.ImageManager->GetPixel (pTexBase, x, y, &R1, &G1, &B1, &A1);
mGame.ImageManager->PutPixel (pSource, x, y, R1, G1, B1, A1);
}
}
}
// Colocamos la "arena" (abajo)
for (x = 0; x < pSource->GetWidth(); x ++)
{
for (y = 0; y < pSource->GetHeight(); y ++)
{
byte R1, G1, B1, A1;
mGame.ImageManager->GetPixel (pSource, x, y, &R1, &G1, &B1, &A1);
// Si es tierra
if (R1 != 255 || G1 != 255 || B1 != 255)
{
mGame.ImageManager->GetPixel (pSource, x, y + 1, &R1, &G1, &B1, &A1);
// Si es aire el pixel de encima dibujamos "arena"
if (R1 == 255 && G1 == 255 && B1 == 255)
{
// Miramos la altura
alt = 0;
R1 = 0;
while (R1 != 255 || G1 != 255 || B1 != 255)
{
mGame.ImageManager->GetPixel (pSource, x, y - alt, &R1, &G1, &B1, &A1);
alt++;
}
int mUntil;
if (alt < pTexDown->GetHeight())
mUntil = alt / 2;
else
mUntil = pTexDown->GetHeight();
// Dibujamos una tira de cesped hacia abajo
for (k = 0; k < mUntil; k++)
{
if (mCes > pTexDown->GetWidth () - 1) mCes = 0;
mGame.ImageManager->GetPixel (pTexDown, mCes, k, &R1, &G1, &B1, &A1);
if (R1 != 255 && G1 != 0 && B1 != 255)
mGame.ImageManager->PutPixel (pSource, x, y - k, R1, G1, B1, 0);
}
mCes++;
}
}
}
}
// Colocamos el "cesped"
for (x = 0; x < pSource->GetWidth(); x ++)
{
for (y = 0; y < pSource->GetHeight(); y ++)
{
byte R1, G1, B1, A1;
mGame.ImageManager->GetPixel (pSource, x, y, &R1, &G1, &B1, &A1);
// Si es tierra
if (R1 != 255 || G1 != 255 || B1 != 255)
{
mGame.ImageManager->GetPixel (pSource, x, y - 1, &R1, &G1, &B1, &A1);
// Si es aire el pixel de encima dibujamos "cesped"
if (R1 == 255 && G1 == 255 && B1 == 255)
{
// Miramos la altura
alt = 0;
R1 = 0;
while (R1 != 255 || G1 != 255 || B1 != 255)
{
mGame.ImageManager->GetPixel (pSource, x, y + alt, &R1, &G1, &B1, &A1);
alt++;
}
int mUntil;
if (alt / 2 < pTexUp->GetHeight())
mUntil = alt / 1.4;
else
mUntil = pTexUp->GetHeight();
if (mUntil > pTexUp->GetHeight()) mUntil = pTexUp->GetHeight();
// Dibujamos una tira de cesped hacia abajo
for (k = 0; k < mUntil; k++)
{
if (mCes > pTexUp->GetWidth () - 1) mCes = 0;
mGame.ImageManager->GetPixel (pTexUp, mCes, k, &R1, &G1, &B1, &A1);
if (R1 != 255 && G1 != 0 && B1 != 255)
mGame.ImageManager->PutPixel (pSource, x, y + k, R1, G1, B1, 0);
}
mCes++;
}
}
}
}
mGame.ImageManager->Save (pSource, "temporal.png");
}
Hola, muy interesante el post, pero viendo las imágenes hay ciertos puntos de la roca donde hay discontinuidad (se nota mucho la linea de cambio). Está hecho adrede imitanto un estrato (minipunto) ? Por lo demás me parece un resultado muy bueno.
saludos
Esta bastante curioso (ole)
La roca esta mal porque la textura la recorte yo mal ayer aprisa y corriendo :) Con una textura bien escogida, que al pegarla una detrás de otra no se vea el corte se vería bien. Es decir, no es fallo del algoritmo. Matriax a ver si me pasas unas buenas texturas :)
Podes actualizar las imagenes con los cambios utlimos cambios del algoritmo?
Ya lo hice Pogacha, ¿no te fijaste?. Mira la segunda imagen, donde pone LOOVER. Le he puesto alt / 1.4, no hasta la mitad. Ya queda bien :)
Venga va, voy a actualizar la primera tb.
OK, tuve que borrar el cache, y si ahí salio.
Saludos y suerte.
Bueno, y aquí va uno algo más elaborado. Con una textura que tilea mejor y tal. De todos modos, me gustan las texturas más alegres del worms.
Hay que ver que sencillo es el algoritmo y que bien queda.
(http://www.pixelartgames.com/nuevo.png)
Jeje, pues a ver si vemos un COTW pronto !! (twist)
CitarJeje, pues a ver si vemos un COTW pronto !!
Uf! Con lo vago que soy! :P
He vuelto a actualizar la última imagen. He retocado la textura de tierra de los contornos de abajo para que no cantara tanto con la piedra, y el cesped lo he retocado para que se vean los tallos.
Solo faltan los gusanos ...
(ole)
Nuevo cambio, y es curioso.
Antes recorrian con dos fores anidados (for (x) { for (y)}) es decir, por columnas. Pero claro así daba problemas al dibujarse debido a que a veces se machaban ciertas partes. Esto se apreciaba en el dibujo del cesped, que en vez de verse la forma que tiene en el png se veia como a rachas. Usando for (y) { for (x) } se soluciona.
(genial)
Jejejeje esta quedando chulo, solo faltaria una textura de roca menos cargada y mas vistosa :P y un cesped mas verde.
Y es to mmmm. No se podria hacer que debajo del cesped puesiera una textura pequeña de 10/20 pixels y luego lo demas ya todo textura tipo la de las rocas de ahora?
Me refiero para hacer transiciones entre cesped y roca para que quedara mucho mas realista.
Bueno hay queda eso, ya puedes postear un mensaje diciendo ya llego el que siempre esta comlicando las cosas jejeje.
Hombre Matrix, tu por aquí :)
Claro que se puede hacer lo que pides. Ya te pasé el generador con los .png, simplemente añade lo que quieras al cesped por debajo. Ya sabes, puedes modificar su tamaño o lo que quieras.
Un saludo!
Loover, nos podrias colgar el exe para hacer pruebas con el??? me parece muy interesante la generacion de este tipo de mapas :)
Estoy al 95% de terminar de documentar la libreria 2d (LooverLib xD) cuando acabe, pondré ese generador como prueba de la clase LOV_ImageManager ;)
Una semanica o dos.
Bueno, lo prometido es deuda. En la sección proyectos ya he puesto la noticia de la LooverLib. El primero ejemplo, el de imágenes, contiene el código completo del generador de mapas tipo worms.
¡Un saludo!