[GAME]: Worms Gemix Edition (Open Source)

[Dluk]

Bueno, acabo de empezar el Worms que dije que iba a hacer y en un ratito completé ya gran parte del sistema de durezas. En si, mi idea es hacer este juego a código abierto para que sirva de ejemplo para el resto de la comunidad

Acá les subo una Beta muy temprana, les dejo los controles:

A: Mover al Worm a la izquierda.
B: Mover al Worm a la derecha.

Teclas de movimiento: Mover el círculo gigante.

Tecla +: Agrandar el círculo.
Tecla -: Achicar el círculo.
Teclas Avpág, repág, Inicio y Fin: Modificar los valores size_x y size_y del círculo.

Tecla Backspace: Borrar el escenario donde está posado el círculo.
Tecla Enter: Crear escenario donde está posado el círculo.

Muy buena la función map_xxput que me permitió manejar muy bien la creación del mapa

Saludos ^^

LA ÚLTIMA VERSIÓN DISPONIBLE SE ENCUENTRA EN http://www.gemixstudio.com/forums/viewt ... 595#p14342

[shao]

Muy bueno eso de las durezas, se le puede sacar mucho partido en este juego y en muchisimos otros.
Un saludo!.

[TYCO]

Me encanta ese gusano, yo creo que de donde has sacado al gusano (será del Worms o del Worms 2) son los mejores juegos en 2D del worms, cuando pasaron al 3D no me gustaba nada.

Dos cosas del código, al ser open no he podido evitar mirarlo XD:
define_region(1,0,0,MODE_INFO(mode_width),MODE_INFO(mode_height)); eso ya es la región 0 por defecto, por qué creas otra región del mismo tamaño???

En PROCESS worm(x,y,equipo); haces: fichero_local=load_fpg("FPG/Worms.fpg");, si es un sólo gusano podría valer, pero conociendo el juego, sabemos que habrá varios gusanos y cargarías el mismo FPG una varias veces en memoria, por qué no cargas ese FPG en el MAIN??? incluso si cada gusano tuviera distinto FPG... yo lo cargaría en el MAIN los que me hicieran falta en el nivel 1, luego en el nivel 2 los que necesitara, en el nivel 3... etc.

Aunque yo creo que buscas ambas cosas en ese PRG, que ponga durezas (poner rampas, etc) y luego quitar durezas que es cuando hace agujeros como ese circulo con las explosiones.

Me encanta la idea de ese juego en Gemix, gracias por traerlo a Gemix.

[SimulatorOne]

el gusano es del worms world party yo lo tengo para PC

E probado el test.

esta muy bien programado.

El circulo verde esta muy bien
pero hay una cosa que no me queda claro, como pintas el fondo de pantalla como color "negro" ?? si el grafico del circulo es de color blanco!

que yo sepa, NO es posible pintar con color transparente, solo se pueden pintar colores rigidos.

has probado de poner un fondo de pantalla,un scroll.

es decir, tenemos un grafico opaco, y queremos usar ese grafico opaco para pintar esa forma de color transparente.
es como la goma del photoshop, que eliges el grosor/forma y pintas el dibujo, borrando con esa forma.
es el efecto invertido de pintar.

[CicTec]

Hola Dluk,

Te felicito por el tipo de juego y por la iniciativa de dejarlo open source para la comunidad, yo lamentablemente no he podido probarlo aun, ya sabeis el porque, aunque cuanto antes lo probare.

[Dluk]

Buenas, me alegra que les halla gustado esta hipertemprana beta.

Me encanta ese gusano, yo creo que de donde has sacado al gusano (será del Worms o del Worms 2) son los mejores juegos en 2D del worms, cuando pasaron al 3D no me gustaba nada.

Worms2, Armaggedon y World Party son los que usaron estos gráficos. Coincido conque Worms+3D = EPIC FAIL.

Dos cosas del código, al ser open no he podido evitar mirarlo XD:
define_region(1,0,0,MODE_INFO(mode_width),MODE_INFO(mode_height)); eso ya es la región 0 por defecto, por qué creas otra región del mismo tamaño???

En un principio tenía pensado hacer una pantalla partida para mover la cámara en una de las dos, pero creo que voy a desechar la idea porque me parece incómodo. Por eso defini la región, porque más adelante iba a usar dos regiones.

En PROCESS worm(x,y,equipo); haces: fichero_local=load_fpg("FPG/Worms.fpg");, si es un sólo gusano podría valer, pero conociendo el juego, sabemos que habrá varios gusanos y cargarías el mismo FPG una varias veces en memoria, por qué no cargas ese FPG en el MAIN??? incluso si cada gusano tuviera distinto FPG... yo lo cargaría en el MAIN los que me hicieran falta en el nivel 1, luego en el nivel 2 los que necesitara, en el nivel 3... etc.

Jeje, esto lo hice por otro motivo. Cada gusano va a usar 6 FPGs distintos, uno para cuando se camina en terreno recto, dos para cuando se camina en rampas y otros tres de la misma forma para cuando el gusano está enfermo. Por eso los cargué en el proceso del gusano, porque son 6 FPG y posiblemente halla más. De todas formas, se pueden pasar al MAIN, tengo que ver que conviene. Gracias por el comentario ^^

Aunque yo creo que buscas ambas cosas en ese PRG, que ponga durezas (poner rampas, etc) y luego quitar durezas que es cuando hace agujeros como ese circulo con las explosiones.

No entendí esta parte... ¿a que te referís?

Me encanta la idea de ese juego en Gemix, gracias por traerlo a Gemix.

Gracias a vos por probarlo y ayudar con las opiniones

el gusano es del worms world party yo lo tengo para PC

E probado el test.

esta muy bien programado.

Gracias, simulatorone

El circulo verde esta muy bien
pero hay una cosa que no me queda claro, como pintas el fondo de pantalla como color "negro" ?? si el grafico del circulo es de color blanco!

que yo sepa, NO es posible pintar con color transparente, solo se pueden pintar colores rigidos.

has probado de poner un fondo de pantalla,un scroll.

es decir, tenemos un grafico opaco, y queremos usar ese grafico opaco para pintar esa forma de color transparente.
es como la goma del photoshop, que eliges el grosor/forma y pintas el dibujo, borrando con esa forma.
es el efecto invertido de pintar.

Es que no pinto de color transparente. El círculo se pinta de color blanco (es el mismo círculo que se ve en el cursor), la diferencia es que luego reemplazo el color blanco con el negro absoluto (RGB(0,0,0)) utilizando la función map_set_color:

[Codebox=gemix file=Untitled.gemix]map_set_color(fichero_durezas,mapa_durezas,map_get_pixel(fichero_sistema,1,50,50),0,0,0);[/Codebox]

De esta forma, el lugar que ocupaba el color blanco lo reemplazo con negro absoluto y de esa forma se logra la transparencia en el borrado.

Hola Dluk,

Te felicito por el tipo de juego y por la iniciativa de dejarlo open source para la comunidad, yo lamentablemente no he podido probarlo aun, ya sabeis el porque, aunque cuanto antes lo probare.

Gracias, CicTec, la idea es que sirva de ejemplo, elegí justamente un juego que use durezas para aplicar lo que aprendí con el Megaman y compartirlo con todos

Saludos ^^

[SimulatorOne]

El circulo verde esta muy bien
pero hay una cosa que no me queda claro, como pintas el fondo de pantalla como color "negro" ?? si el grafico del circulo es de color blanco!

que yo sepa, NO es posible pintar con color transparente, solo se pueden pintar colores rigidos.

has probado de poner un fondo de pantalla,un scroll.

es decir, tenemos un grafico opaco, y queremos usar ese grafico opaco para pintar esa forma de color transparente.
es como la goma del photoshop, que eliges el grosor/forma y pintas el dibujo, borrando con esa forma.
es el efecto invertido de pintar.

Es que no pinto de color transparente. El círculo se pinta de color blanco (es el mismo círculo que se ve en el cursor), la diferencia es que luego reemplazo el color blanco con el negro absoluto (RGB(0,0,0)) utilizando la función map_set_color:

[Codebox=gemix file=Untitled.gemix]map_set_color(fichero_durezas,mapa_durezas,map_get_pixel(fichero_sistema,1,50,50),0,0,0);[/Codebox]

De esta forma, el lugar que ocupaba el color blanco lo reemplazo con negro absoluto y de esa forma se logra la transparencia en el borrado.

Lo digo, por que al ser 100% en modo 32bits se considera opaco, no es transparente, y no podras poner una imagen de fondo/o un scroll.
Lo ideal es pintarlo al 100% transparente, no negro.

para el mapa de durezas pasa, pero como decorado para el nivel... lo tendras dificil...
En el juego de worms parece super facil.


Yo logre pintar pixeles transparentes,en sprites del juego del PUSH, usando un grafico opaco, y pintarlo pixel por pixel.... algo muy forzoso para la CPU.
lo usan los bloques que se destrullen.

Poder se puede, pero yo de momento pude hacerlo pintando pixel a pixel los sprites con transparencias.

[Dluk]

No, me parece que estás equivocado, yo pinto las partes blancas con el color que se ignora en Gemix, que es el RGB(0,0,0). Fijate sino, probá esta versión nueva:

[Codebox=gemix file=Untitled.gemix]//==============================================================================
// WORMS GEMIX EDITION
// JUEGO (OPEN SOURCE)
// AUTOR: EZEQUIEL DELUCA
// GEMIX STUDIO BETA 5.7
//==============================================================================

PROGRAM gemix_worms;

CONST

//CONSTANTES QUE DEFINEN LOS ESTADOS

normal=0;
camina=1;
salto=2;
caida=3;
salto_adelante=4;
salto_en_lugar=5;
salto_backflip=6;

//CONSTANTES QUE DEFINEN EL TIPO DE SUELO QUE ESTA PISANDO EL WORM

RAMPA_ARRIBA=1;
RAMPA_ABAJO=2;
SUELO_LLANO=3;
PARED=4;

//CONSTANTE QUE MANEJA LA RESOLUTION GLOBAL

resolucion_global=100;

//CONSTANTE DE AVANCE EN EL SUELO

avance_suelo=50;

//CONSTANTE DE MAXIMA VELOCIDAD DE CAIDA

descenso_maximo=1000;

//CONSTANTE DE CANTIDAD DE PIXELES QUE CAE EL WORM

avance_caida_y=8;

GLOBAL

//VARIABLES PARA GUARDAR LOS IDs DE LOS FPGs

fichero_mapas;
fichero_durezas;
fichero_sistema;

//VARIABLE PARA GUARDAR EL NUMERO DE MAPA DENTRO DEL FPG DE DUREZAS

mapa_durezas;

//VARIABLE QUE GUARDA EL COLOR VERDE QUE SE USA PARA DETECTAR LAS DUREZAS

color_dureza_verde;

//TEMPORAL: ESTAS ANIMACIONES SERAN CAMBIADAS POR UNA UNICA TABLA

anim_worm_normal[]=1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,0;
anim_worm_caida[]=31,32,0;
anim_worm_camina[]=33,34,35,36,37,38,39,40,41,42,43,44,45,46,0;


LOCAL

//VARIABLE PARA CANTIDAD DE PIXELES DE DIFERENCIA ENTRE EL SUELO EN UNA RAMPA

conteo_rampa;

//VARIABLE DE ESTADO

estado;

//VARIABLE QUE CONTROLA EL Y DEL SUELO

suelo=-40000;

BEGIN

//SETEO MODO DE VIDEO (640X480 A 32 BITS A 60 FPS CON VSYNC)

set_mode(640,480,32,mode_waitvsync,mode_rate_60); //mode_bufferflip |
set_fps(0,0);
change_mode(mode_fullscreen);

//CARGO FPGS

fichero_sistema=load_fpg("FPG/Sistema.fpg");
fichero_durezas=load_fpg("FPG/Durezas.fpg");
fichero_mapas=load_fpg("FPG/Mapas.fpg");

//OBTENGO EL COLOR DE LA DUREZA (EL VERDE) DEL MAPA 1 DEL FPG DE DUREZAS

color_dureza_verde=map_get_pixel(fichero_durezas,1,1,0);

//ESTABLEZCO EL NUMERO DEL MAPA DE DUREZAS A USAR

mapa_durezas=2;

//DEFINO REGION Y CREO EL SCROLL

//define_region(1,0,0,MODE_INFO(mode_width),MODE_INFO(mode_height));
start_scroll(0,fichero_mapas,mapa_durezas,mapa_durezas+1,0,0);

//LLAMO AL PROCESO WORM

worm(60,0,1);

//LLAMO AL PROCESO CIRCULO_LOCO (TEMPORAL)

circulo_loco(320,900);

LOOP

FRAME;

END

END

//*********************************************//
// //
// //
// PROCESO WORM //
// //
// //
//*********************************************//

PROCESS worm(x,y,equipo);

PRIVATE

//VARIABLE PARA CONTROLAR LAS ANIMACIONES

inc_anim;

//VARIABLE QUE GUARDA EL ID DEL FICHERO DEL WORM (EN FUTURAS VERSIONES SERÁ IMPORTANTE)

fichero_local;

//VARIABLE QUE GUARDA LA DISTANCIA DESDE EL CENTRO HACIA LOS PIES

distancia_pies=10*resolucion_global;

//VARIABLE QUE GUARDA EL ESTADO DEL FRAME ANTERIOR

estado_anterior;

//VARIABLE QUE ESTABLECE LA FUERZA DE GRAVEDAD

descenso;

//VARIABLE PARA INCREMENTOS EN Y

inc_y;

BEGIN

//MULTIPLICO EL X E Y INICIALES POR LA RESOLUTION GLOBAL

x*=resolucion_global;
y*=resolucion_global;

//ESTABLEZCO LA RESOLUTION

resolution=resolucion_global;

//METO AL PROCESO EN EL SCROLL

ctype=c_scroll;

//PONGO LA CAMARA DEL SCROLL PARA QUE SIGA AL PROCESO

scroll[0].camera=ID;

//CARGO EL FICHERO CON LOS GRAFICOS DEL WORM

fichero_local=load_fpg("FPG/Worms.fpg");
file=fichero_local;

graph=1;

//EL SIGUIENTE IF - REPEAT BAJA AL WORM HASTA QUE ENCUENTRA EL SUELO (PARA POSICIONARLO MAS FACIL)

IF(control_dureza_suelo(x,y+distancia_pies)<>TRUE)
REPEAT
y+=1;
UNTIL(control_dureza_suelo(x,y+distancia_pies)==TRUE)
END

//ESTABLEZCO EL SUELO DONDE SE ESTA PISANDO

suelo=y;


LOOP

//SIEMPRE PONGO EL ESTADO A NORMAL AL PRINCIPIO DE CADA FRAME

estado=normal;

//MOVIMIENTO A LA IZQUIERDA

IF(key(_a) AND suelo==y)

flags=0;

SWITCH(control_rampa(x,y+distancia_pies,-avance_suelo))

CASE RAMPA_ABAJO;
x-=avance_suelo;
y+=conteo_rampa;
suelo=y;
estado=camina;
END

CASE RAMPA_ARRIBA;
x-=avance_suelo;
y-=conteo_rampa;
suelo=y;
estado=camina;
END

CASE SUELO_LLANO;
x-=avance_suelo;
estado=camina;
END

END

END

//MOVIMIENTO A LA DERECHA

IF(key(_d) AND suelo==y)
flags=1;

SWITCH(control_rampa(x,y+distancia_pies,avance_suelo))

CASE RAMPA_ABAJO;
x+=avance_suelo;
y+=conteo_rampa;
suelo=y;
estado=camina;
END

CASE RAMPA_ARRIBA;
x+=avance_suelo;
y-=conteo_rampa;
suelo=y;
estado=camina;
END

CASE SUELO_LLANO;
x+=avance_suelo;
estado=camina;
END

END
END

//CAIDA

IF(control_dureza_suelo(x,y+distancia_pies)==FALSE)

IF(suelo==y)
descenso=100;
END

suelo=-40000;
estado=caida;

inc_y=0;

REPEAT
y+=avance_caida_y;
inc_y+=avance_caida_y;
UNTIL(inc_y=>descenso OR control_dureza_suelo(x,y+distancia_pies)==TRUE)

IF(descenso<descenso_maximo)
descenso+=avance_caida_y;
END

ELSE
IF(suelo<>y)
suelo=y;
estado=normal;
END
END


IF(estado<>estado_anterior)
inc_anim=0;
END

estado_anterior=estado;

//ESTADO NORMAL

IF(estado==normal)

graph=anim_worm_normal[inc_anim];

inc_anim++;

IF(anim_worm_normal[inc_anim]==0)
inc_anim=0;
END

END

//ESTADO CAMINA

IF(estado==camina)

graph=anim_worm_camina[inc_anim];

inc_anim++;

IF(anim_worm_camina[inc_anim]==0)
inc_anim=0;
END

END

//ESTADO CAIDA

IF(estado==caida)

graph=anim_worm_caida[inc_anim];

inc_anim++;

IF(anim_worm_caida[inc_anim]==0)
inc_anim=0;
END

END

FRAME;

END

END

//*********************************************//
// //
// //
// PROCESO CIRCULO LOCO //
// //
// //
//*********************************************//

PROCESS circulo_loco(x,y);

PRIVATE

grafico_temp;

BEGIN

file=fichero_sistema;

graph=1;

ctype=c_scroll;

LOOP

IF(key(_c_minus) OR mouse.wheeldown)
size_x-=3;
size_y-=3;
END

IF(key(_c_plus) OR mouse.wheelup)
size_x+=3;
size_y+=3;
END

IF(key(_pgdn))
size_y-=3;
END

IF(key(_pgup))
size_y+=3;
END

IF(key(_home))
size_x+=3;
END

IF(key(_end))
size_x-=3;
END

IF(key(_left))
x-=3;
END

IF(key(_right))
x+=3;
END

IF(key(_up))
y-=3;
END

IF(key(_down))
y+=3;
END

x = scroll.x0 + mouse.x;
y = scroll.y0 + mouse.y;


IF(key(_backspace) OR mouse.right)

graph=1;

map_xxput(fichero_durezas,mapa_durezas,fichero_sistema,graph,x,y,0,size_x,size_y,0,0,0,0,255,0);
map_xxput(fichero_mapas,mapa_durezas,fichero_sistema,graph,x,y,0,size_x,size_y,0,0,0,0,255,0);

map_set_color(fichero_durezas,mapa_durezas,map_get_pixel(fichero_sistema,1,50,50),0,0,0);
map_set_color(fichero_mapas,mapa_durezas,map_get_pixel(fichero_sistema,1,50,50),0,0,0);

refresh_scroll(0);

END

IF(key(_enter) OR mouse.left)

graph=2;

map_xxput(fichero_durezas,mapa_durezas,fichero_sistema,graph,x,y,0,size_x,size_y,0,0,0,0,255,0);
map_xxput(fichero_mapas,mapa_durezas,fichero_sistema,graph,x,y,0,size_x,size_y,0,0,0,0,255,0);

refresh_scroll(0);

END

FRAME;
END
END

//*********************************************//
// //
// //
// FUNCION CONTROL DUREZA //
// //
// //
//*********************************************//

FUNCTION control_dureza_suelo(x,y);

PRIVATE

color_dureza;

BEGIN

x/=resolucion_global;
y/=resolucion_global;

color_dureza=map_get_pixel(fichero_durezas,mapa_durezas,x,y);

IF(color_dureza==color_dureza_verde)
RETURN(TRUE);
ELSE
RETURN(FALSE);
END

END

//*********************************************//
// //
// //
// FUNCION CONTROL RAMPA //
// //
// //
//*********************************************//

FUNCTION control_rampa(x,y,direccion);

PRIVATE

//VARIABLE QUE DEVUELVE EL TIPO DE RAMPA (MAS BIEN DE SUELO) QUE SE ESTA PISANDO

tipo_rampa;

//CONTADOR DE PIXELES, PARA VER CUANTOS PIXELES CORRELATIVOS HAY EN UNA MISMA LINEA VERTICAL

contador=1*resolucion_global;

//VARIABLE QUE INDICA HASTA CUANTOS PIXELES SE CONSIDERA RAMPA DESCENDENTE Y NO ABISMO

maximo_soporte_rampa_abajo=10*resolucion_global;

//VARIABLE QUE INDICA HASTA CUANTOS PIXELES SE CONSIDERA RAMPA ASCENDENTE Y NO PARED

maximo_soporte_rampa_arriba=10*resolucion_global;

BEGIN

//CONTROL PARA RAMPAS QUE BAJAN

IF(control_dureza_suelo(x,y)==TRUE AND control_dureza_suelo(x+direccion,y)==FALSE)

WHILE(contador<=maximo_soporte_rampa_abajo)

IF(control_dureza_suelo(x+direccion,y+contador)==TRUE)
tipo_rampa=RAMPA_ABAJO;
father.conteo_rampa=contador;
contador=maximo_soporte_rampa_abajo;
END

contador+=100;

END

IF(tipo_rampa==0)
tipo_rampa=SUELO_LLANO;
END

END

//CONTROL PARA RAMPAS QUE SUBEN

IF(control_dureza_suelo(x,y)==TRUE AND control_dureza_suelo(x+direccion,y)==TRUE)

WHILE(contador<=maximo_soporte_rampa_abajo)

IF(control_dureza_suelo(x+direccion,y-contador)==TRUE)
tipo_rampa=RAMPA_ARRIBA;
father.conteo_rampa=contador;
END

contador+=100;

END

//SI SE EXCEDE EL MAXIMO DE ESCALADA PERMITIDO, INDICA QUE HAY PARED

IF(control_dureza_suelo(x+direccion,y-contador)==TRUE)
tipo_rampa=PARED;
END

//SI NO SE DAN NINGUNA DE LAS OTRAS CONDICIONES, EL SUELO ES LLANO

IF(tipo_rampa==0)
tipo_rampa=SUELO_LLANO;
END

END

RETURN(tipo_rampa);

END[/Codebox]

Necesitás descargar el FPG que te adjunto acá y pegarlo en la carpeta FPG. Probá después a borrar con el círculo parte del mapa y vas a ver como aparece el fondo.

[Dluk]

¿Está permitido morir de un ataque de emoción?

Tengo que compartir esto con ustedes (el adjunto), borren parte del mapa y luego creen suelo... después me dicen que les pareció

Larga vida a LOAD_FPG_MAP. Lástima que se ralentiza un poco, pero ya se me ocurrió como solucionarlo, jejeje.

[SimulatorOne]

has probado de usar 32bits en las durezas.FPG y en el sistema.FPG

yo e estado haciendo pruebas,

y se comporta de una manera algo rara.

reslta que el color RGB(0,0,0) es === a color transparente, tanto en 16bits como en 32bits.
y si usas canal alpha hace algo raro....