[GAME] Duck Hunt Remake [NES]

[shao]

Puedes ponerle un scroll, que no rebote en la pantalla el pato, tambien puedes meterle otros cazadores que te roben el pato si tardas mucho en acertar (aunque ya necesitarias sprite), tambien se podria poner un lago que el perro no cruza si no le lanzas un hueso al otro extremo, se podrian añadir muchas cosas.

[erkosone]

@NightWolf: El Wiimote funciona en cualquier PC con los diferentes drivers que hay.. ni se instalan ni nada, ejecutas el programa que te manipula el mouse y lee desde el wiimote..

De entre los mejores softwares que existen para esto están:

GlovePIE, se puede configurar para cualquier caso por raro que sea lo que quieras hacer..
WiiMouse, tiene varios modos de funcionar, de entre los cuales está el modo mouse.
WiiRemote, uno de los primeros que apareció, muestra el estado de los acelerometros y se deja configurar como un mouse.

Yo me quedo con el GlovePIE.

[SimulatorOne]

bieeeenn!! otro juego que puedo utilizar mi Wiimoteee

Gracias erkos, gran aporte por el ejemplo practico juego de pipas con el mando de la wii.

En mi juego de Rosie tiene tambien opcional jugar con el wiimote, y el globepie preconfigurado

[SimulatorOne]

¿pero como usar la pistola de la wii que funcione bien en gemix?

ademas de uno de los programas que dice Erkos...

antes debes linkear/relacionar tu mando Wiimote a traves de Bluethood, con un soft de blouethood para windows.
como el BlueSolei ese...
es el mas seguro y estable.

despues de relacionarlo, ejecuta el GlobePie + el Scrip que hace acctivar el mando de la Wii.
Depues ya puedes ejecutar el juego de gemix.

[BigHead]

@BigHead: Ya que conoces bien el juego, he pensado el programar el modo B y para el C... quiero hacer algo mas actual, cualquier tipo de sugerencia para el tipo de juego C será bien recibida.
Si se te ocurre algo no dudes en postearlo, estoy pensando en montar un modo C totalmente nuevo.

Por cierto.. anoche me pegué 3 horas seguidas con la pistola de wii matando patos XD.. que vicio tiene el juego jeje..

para el modo B

Se me ocurre un modo de dos player simultáneo, en el que aparezcan los patos por color (azul y rojo) segun si eres el player uno o dos, es una competición (cuando tengamos módulo de red partidas online también) la barra de patos de abajo llena y segun pierdes pato vas perdiendo patos abajo(en el panel), si el rojo mata al azul o biceversa pierde dos, se trata de ver quien aguanta más.

Para el modo C: cuatro posibles opciones se me ocurren;

Opción A: Pues un poco loco lo que se me ocurre de buenas a primera, que al disparar lances uno de los discos para cargarte el pato, esto tendria el retardo desde la salida del disco hasta llegar al pato, por lo cual tendrías que calcular ese timing.También se le podria añadir viento para complicarlo más.

Opcion B: Bandadas de patos pasando a distintas profundidades (en forma de V como vuelan cuando emigran o sueltos o ambos) y poco a poco más velocidad y alguna nuve por medio donde desaparecen por un instante o cosas así, pierdes cuando se escapan tantos como patos blancos tienes en el panel.Estos van mas rápido en función del nivel de dificultad.

Opción C: añadir conejos u otros animales

Opcion D: mapa scroll lateral relativamente largo, salen de un lado uno o dos, tres o más patos en función del nivel de dificultad, que van ocultandose detrás de arbustos u otras cosas donde no puedes dispararles, ellos tratan de llegar al otro lado y tu no puedes dejar escapar ni uno (Esta es la opción que más me gusta quizá)

Eso se me ocurre así derrepente, basámdme en que no tengás que tirar de muchos graficos que no tenga ya el juego (sólo conejos o nuves),no sé si quieres un modo que no sea de caza exclusivamente? espero que alguna idea te valga, sobre todo la del dos player online eso podria ser la bomba, haríamos un torneillo con todos los del foro jeje

EDITO: MODO LOCO: mata al perro que corre y se oculta rápidamente, o lanzarle discos, que los coja o que te lo tengas que tumbar a discos!

Saludetes y animo con esos modos B y C !

[erkosone]

Me ha gustado la idea del modo online, voy a estudiarlo.

[OskarG]

Hola erkos,me ha gustado el remake,mas queria pedirte no el codigo fuente,no pretendo tal cosa,mas como se que te agrada hacer tutoriales y me resultan muy utiles ,a mi y creo que a bastantes mas les seria interesante un tutorial de las funciones draw que incluye gemix,ya que por ejemplo me gustaria saber como evitar miles de procesos con esta funcion.

[erkosone]

Hola Oscar, pues somentarte que este juego utiliza 2 procesos, 1 que controla el flujo del juego y otro que son los patos.. por no liar en exceso el código lo he hecho así.. pero vaya.. que creo que ha quedado como uno de mis mejores códigos, a un buen nivel.

Pues por mi deacuerdo, montaré algún tutorial sobre esto por que es algo importante, rompe con las limitaciones que tienen todos los demás div_like en cuanto a procesos..

Pero el principal tema que hay que plantearse es el de programar por máquinas de estados como se suele hacer en otros lenguajes, mira este es el proceso de un pato.. verás que poco o nada se parece a un proceso DIV , y esta técnica de maquina de estados cuando le cojes el punto y la dominas te permite hacer con 1 solo proceso cosas muy muy grandes.

El source del proceso de un pato:
[Codebox=gemix file=Untitled.gemix]process Duck(num_duck_);
private
int counter_ = 0;
int seconds_ = 0;
int estado = 0;
int delay_flags_ = 0;
int delay_fly_sound = 0;
int delay_cuak_sound = 0;
int fly_away_state = 0;
int delay_dog_risa_ = 0;
int anima = 0;
int anima_away[8] = 7,7,7,8,8,8,9,9,9;
int anima_low_angle[11] = 1,1,1,2,2,2,3,3,3,2,2,2;
int anima_high_angle[11] = 4,4,4,5,5,5,6,6,6,5,5,5;
int this_score = 0;
int x_this_score;
int y_this_score;

int angle_ = 0;
begin
resolution = 100;
ducks[num_duck_].active_ = 1; // activate this duck in panel..
file = rand(1,3); // randomize duck color..
switch (file)
case 1:
file = f_blue_duck;
end
case 2:
file = f_green_duck;
end
case 3:
file = f_red_duck;
end
end
graph = 1;
x = rand(2000,30000);
y = 17100;
z = 512;
angle_ = rand(40000,140000); // initial angle at start..
loop
//-----------------------------initial state-----------------------------------------
if(estado == 0) // Initial state el this duck..
counter_ = ( counter_ + 1 ) % 30; // counter of 30 frames = 1 second..
if(counter_ == 29) // if 1 second passed..
seconds_++; // increase seconds counter..
if(seconds_ == 5) // if 5 seconds are passed..
estado = -1; // change state..
end
if(seconds_ == 4)
fly_away_state = 1;
put_screen(f_main, 26);
end
end
if(collision(id_mouse))
if(shot_event == true) // if collision with shot..
estado = 1; // change state..
end
end

delay_fly_sound = ( delay_fly_sound + 1 ) % 4;
if(delay_fly_sound == 1)
play_sound(sfx_19);
end

delay_cuak_sound = ( delay_cuak_sound + 1 ) % 25;
if(delay_cuak_sound == 1)
play_sound(sfx_10);
end

// Code for move This Duck..
if( (angle_ < 90000) && (angle_ > -90000) )
flags = 0;
end
if( (angle_ > 90000) && (angle_ < 280000) )
flags = 1;
end

if( (angle_ > 280000) && (angle_ < 360000) )
flags = 0;
end


if(y < 0)
y = 0;
angle_ = rand(220000, 320000);
end
if(y > 17000)
y = 17000;
angle_ = rand(40000,140000);
end
if(x < 0)
x = 0;
angle_ = rand(50000,-50000);
flags = 0;
end
if(x > 32000)
x = 32000;
angle_ = rand(130000,240000);
flags = 1;
end

XADVANCE(angle_, (round * 10) + 300);

anima = ( anima + 1) % 11;
graph = anima_low_angle[anima];

switch (angle_)
case 45000..135000:
graph = anima_high_angle[anima];
end

case 225000..325000:
graph = anima_high_angle[anima];
end
end

end
//-----------------------------------------------------------------------------------


//--------------------------duck scape from player-----------------------------------
if(fly_away_state == 1) // if duck scape..
draw_text( fnt_white, "FLY AWAY", 4, 160, 45, 255 );
draw_graphic( f_main, 27, 160, 45, 256, 0,0, 100, 100 );
end

if(estado == -1)
ducks[num_duck_].active_ = 0; // deactivate this duck in panel..
ducks[num_duck_].escape_ = 1; // duck scaped..
estado = -2;
end

if(estado == -2)
anima = ( anima + 1 ) % 8;
graph = anima_away[anima];
if(y > -2000)
y-=300;
else
fly_away_state = 0;
estado = -3;
end
end

if(estado == -3)
put_screen(f_main, 4);
x = 16000;
y = 17000;
file = f_main;
graph = 18;
estado = -4;
play_sound(sfx_22);
end

if(estado == -4)
delay_dog_risa_ = ( delay_dog_risa_ + 1 ) % 6;
if(delay_dog_risa_ < 3)
graph = 18;
else
graph = 19;
end
if(y > 14500)
y-=100;
else
estado = -5;
end
end

if(estado == -5)
frame(1000);
estado = -6;
end

if(estado == -6)
delay_dog_risa_ = ( delay_dog_risa_ + 1 ) % 6;
if(delay_dog_risa_ < 3)
graph = 18;
else
graph = 19;
end
if(y < 18000)
y+=100;
else
estado = -7;
end
end

if(estado == -7)
put_screen(f_main, 4);
break;
end
//-----------------------------------------------------------------------------------


//----------------------------player kill duck---------------------------------------
if(estado == 1) // if player kill this duck..
fly_away_state = 0;
ducks[num_duck_].active_ = 0;
ducks[num_duck_].dead_ = 1;
switch (seconds_)
case 0:
this_score = 1500;
end
case 1:
this_score = 1000;
end
case 2:
this_score = 800;
end
case 3:
this_score = 600;
end
case 4:
this_score = 400;
end
end
score += this_score;
estado = 2;
end

if(estado == 2) // wait a moment in shock..
graph = 10;
frame(2000);
graph = 11;
play_sound(sfx_20);
x_this_score = x;
y_this_score = y;
estado = 3;
end

if(estado == 3) // downs with flags animation..
delay_flags_ = ( delay_flags_ + 1 ) % 3;
if(delay_flags_ == 1)
flags = flags xor 1;
end
if(y < 17000)
draw_text( 0, itoa(this_score), 4, x_this_score/resolution, y_this_score/resolution, 0 );
y += 300;
else
stop_sound(all_sound);
play_sound(sfx_18);
frame(2000);
estado = 4;
end
end

if(estado == 4) // change graphic to dog with duck in hand..
file = f_main;
graph = 20;
if(x > 23000) // correction for z preference..
x = 23000;
end
if(x < 9000) // correction for z preference..
x = 9000;
end
estado = 5;
end

if(estado == 5) // dog ups for sowh duck..
if(y > 14000)
y-=200;
else
play_sound(sfx_4);
frame(1500);
estado = 6;
end
end

if(estado == 6) // dog downs..
if( y < 18000 )
y += 200;
else
break;
end
end
//-----------------------------------------------------------------------------------



// Exception for no enought shots left..
if(shots_left == 0) // if no shots left..
if(estado == 0) // if duck are in normal state "flying"..
put_screen(f_main,26);
fly_away_state = 1; // now this duck scape..
estado = -1; // now this duck scape..
end
end

frame;
end
end[/Codebox]



Como puedes ver.. en 1 único bucle se encuentra todo el código del proceso, y esta técnica es la que hay que aprender antes de usar al 100% draw graphic.. cuando la dominas puedes hacer cosas como este otro proceso, esto es el proceso de la pantalla de inicio del juego, todo a base de draw_text y draw_graphic
[Codebox=gemix file=Untitled.gemix]process Inicio();
private
int music_timer = 0; // delay for play sound..
int pos_ = 1; // cursor starts on position 1..
int pos_1_ = 133; // set position 1..
int pos_2_ = 150; // set position 2..
int pos_3_ = 165; // set position 3..
int y_pos_ = 0; // value of Y cord position on screen for draw the cursor..
int estado = 0; // for control of diferent state process..
int flash_counter_ = 0;
begin

if(file_exists(getwpath()+"DATA.dat")) // SI EL ARCHIVO EXISTE LO CARGO..
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
FILE_=FOPEN(getwpath()+"DATA.dat","r"); // CARGO EN MEMORIA EL FILE DEL ESTADO DEL JUEGO..
fread(offset score, sizeof(score), FILE_);
fclose(FILE_);
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
ELSE // SI EL ARCHIVO NO EXISTE LO CREO VACIO..
score=0;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
FILE_=FOPEN(getwpath()+"DATA.dat","w"); // GUARDO EL FILE Preparado..
fwrite(offset score, sizeof(score), FILE_);
fclose(FILE_);
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
end


ducks[0].panel_x_ = 128;
ducks[1].panel_x_ = 137;
ducks[2].panel_x_ = 146;
ducks[3].panel_x_ = 155;
ducks[4].panel_x_ = 164;
ducks[5].panel_x_ = 173;
ducks[6].panel_x_ = 182;
ducks[7].panel_x_ = 191;
ducks[8].panel_x_ = 200;
ducks[9].panel_x_ = 209;

ducks[0].panel_y_ = 217;
ducks[1].panel_y_ = 217;
ducks[2].panel_y_ = 217;
ducks[3].panel_y_ = 217;
ducks[4].panel_y_ = 217;
ducks[5].panel_y_ = 217;
ducks[6].panel_y_ = 217;
ducks[7].panel_y_ = 217;
ducks[8].panel_y_ = 217;
ducks[9].panel_y_ = 217;

let_me_alone();
clear_screen();
frame;

put_screen(f_main, 1);
y_pos_ = pos_1_;


loop

flash_counter_ = ( flash_counter_ + 1 ) % 20;
if(flash_counter_ > 10)
draw_text(fnt_white, "Remaked by: Luis Lopez Martinez on 48 hours", 4, 160, 10, z);
end


music_timer = ( music_timer + 1 ) % 600; // counter from 1 to 600 = 30 frames per second = 30 second delay..
if(music_timer == 1) // after 30 seconds..
play_sound(sfx_2); // play sound..
end

if(estado == 0) // initial state process..
if(key(_up)) // if key up pushed..
if(pos_ > 1) // if cursor pos > 1
pos_--; // cursor pos decrease 1 position..
estado = 1; // change proces state to 1..
end
end

if(key(_down)) // if key down pushed..
if(pos_ < 3) // if cursor pos < 3..
pos_++; // cursor pos increases 1 position..
estado = 1; // change proces state to 1..
end
end

if(key(_enter)) // if key enter pushed..
switch (pos_) // select cursor pos with variable pos_ value..
case 1: GAME_A();end // select 1 duck game mode..
case 2: exit("Only A mode implemented. Powered by GemixStudio.",0);end // select 2 duck game mode..
case 3: exit("Only A mode implemented. Powered by GemixStudio.",0);end // select 3 clay shooting game mode..
end
break; // break this treath..
end

end

if(estado == 1) // state 1.. when up or down key are pushed..
switch (pos_) // select cursor pos with variable pos_ value..
case 1: y_pos_ = pos_1_; end // select position 1..
case 2: y_pos_ = pos_2_; end // select position 2..
case 3: y_pos_ = pos_3_; end // select position 3..
end
estado = 2; // change proces state to 2..
end

if(estado == 2) // when decide the position of cursor...
if(scan_code == 0) // when no key pushed..
estado = 0; // restart proces state machine..
end
end



draw_text(fnt_orange, "GAME A 1 DUCK", 3, 89, 135, z);
draw_text(fnt_orange, "GAME B 2 DUCK", 3, 89, 151, z);
draw_text(fnt_orange, "GAME C CLAY SHOOTING", 3, 89, 167, z);
draw_text(fnt_green, "TOP SCORE = " + itoa(score), 3, 80, 190, z);
draw_graphic( f_main, 2, 76, y_pos_, 512, 0 ); // draws cursor graphic..
frame;
end
end[/Codebox]




Y uniendo las dos técnicas obtienes un código como este, que es el control del juego desde un solo proceso, el tipo de código no es apto para alguien con poca experiencia.. es creo una de las mejores técnicas para programar con pocos recursos.. pero requiere de bastante experiencia y un conocimiento muy preciso de lo que se está haciendo

[Codebox=gemix file=Untitled.gemix]process GAME_A();
private
int intro_ = true; // if true.. intro plays..
int estado = 0; // for control states..
int fade_delay = 0; // delay for shot fade..
int game_state = 0; // intro state machine..
int anima_; // for dog animation..
int anima_walk[14] = 12,12,12,12,12,11,11,11,11,11,10,10,10,10,10; // dog walk animation..
int anima_snif[11] = 13,13,13,13,13,13,14,14,14,14,14,14; // dog snif animation..
int x_dog, y_dog; // the position of dog..
int delay_x_dog = 0; // the position of dog..
int counter_ = 0; // counter for intro control steeps..
int flash_counter_ = 0; // for flashing ducks in panel..
int i; // for duck draw active/killed bucle..
int ID_Duck;
int Counter_ducks = 0;
int Round_State = 0;
int Delay_new_duck_ = 0;
int total_kills = 0;
int delay_dog_risa_ = 0;
int counter_game_over_ = 0;
int id_wait_for_reallocate_ducks;
begin
fade(0,0,0,64);
stop_sound(all_sound);
frame(300);
Raton();
score = 0;
shots_left = 3;
shot_posible = 0;
clear_screen();
put_screen(f_main, 4);
fade(100,100,100,63);
play_sound(sfx_5);
loop
//--------------------------------- I N T R O B L O C K C O D E --------------------------------
IF(intro_ == true)
if(game_state <= 4)
draw_text( fnt_white, itoa(round), 4, 160, 55, 199 ); // draw round num..
draw_text( fnt_white, "ROUND", 4, 160, 43, 199 ); // draw round title..
draw_graphic( f_main, 25, 160, 50, 200, 0,0, 100, 100 ); // draw round panel..
end

if(game_state == 0) // start dog position..
x_dog = 30;
y_dog = 200;
game_state = 1;
end

if(game_state == 1) // dog walks forward..
anima_ = ( anima_ + 1 ) % 14;
delay_x_dog = ( delay_x_dog + 1 ) % 2;
if(delay_x_dog == 1)
x_dog++;
end
if(x_dog == 60)
anima_ = 0;
game_state = 2;
end
draw_graphic( f_main, anima_walk[anima_ + 1], x_dog, y_dog, 200, 0,0, 115, 110 );
end

if(game_state == 2) // dog snnifing..
anima_ = ( anima_ + 1 ) % 11;
if(anima_ == 1)
counter_++;
end
if(counter_ == 3)
counter_ = 0;
anima_ = 0;
game_state = 3;
end
draw_graphic( f_main, anima_snif[anima_ + 1], x_dog, y_dog, 200, 0,0, 115, 110 );
end

if(game_state == 3) // dog walks forward..
anima_ = ( anima_ + 1 ) % 14;
delay_x_dog = ( delay_x_dog + 1 ) % 2;
if(delay_x_dog == 1)
x_dog++;
end
if(x_dog == 100)
anima_ = 0;
game_state = 4;
end
draw_graphic( f_main, anima_walk[anima_ + 1], x_dog, y_dog, 200, 0,0, 115, 110 );
end

if(game_state == 4) // dog snnifing..
anima_ = ( anima_ + 1 ) % 11;
if(anima_ == 1)
counter_++;
end
if(counter_ == 3)
counter_ = 0;
anima_ = 0;
game_state = 5;
end
draw_graphic( f_main, anima_snif[anima_ + 1], x_dog, y_dog, 200, 0,0, 115, 110 );
end

if(game_state == 5) // happy dog..
counter_++;
if(counter_ == 20)
counter_ = 0;
game_state = 6;
end
draw_graphic( f_main, 15, x_dog, y_dog, 200, 0,0, 115, 110 );
end

if(game_state == 6) // dog jumps..
if(x_dog < 130)
counter_++;
x_dog+=3;
y_dog-=4;
else
game_state = 7;
end
draw_graphic( f_main, 16, x_dog, y_dog, 200, 0,0, 115, 110 );
end

if(game_state == 7) // dog walls..
counter_++;
x_dog+=2;
y_dog+=4;
if(y_dog > 190)
game_state = -1;
intro_ = false;
end
draw_graphic( f_main, 17, x_dog, y_dog, 200, 0,0, 115, 110 ); // draw dog..
draw_graphic( f_main, 22, 160, 176, 128, 0,0, 100, 100 ); // draw grass mask on top..
end

if(game_state == 6 or game_state == 7)
if(counter_ == 1)
play_sound(sfx_9);
end
if(counter_ == 10)
play_sound(sfx_9);
end
if(counter_ == 19)
play_sound(sfx_9);
end
end
END
//----------------------------------------------------------------------------------------------



//-------------------------------- DUCKS PANEL B L O C K C O D E --------------------------------
flash_counter_ = ( flash_counter_ + 1 ) % 30; // flasing ducks counter..
for(i=0; i<=9; i++) // flashing active ducks in panel..
// draw ducks active or not active in panel..
if(ducks.active_ == 1)
if(flash_counter_ < 15)
draw_graphic( f_main, 9, ducks.panel_x_, ducks.panel_y_, 128, 0,0, 100, 100 );
end
else
draw_graphic( f_main, 9, ducks.panel_x_, ducks.panel_y_, 128, 0,0, 100, 100 );
end

// draw duck killed in panel..
if(flash_ducks_in_red == 0)
if(ducks.dead_ == 1)
draw_graphic( f_main, 24, ducks.panel_x_, ducks.panel_y_, 127, 0,0, 100, 100 );
end
else
if(flash_counter_ < 15)
if(ducks.dead_ == 1)
draw_graphic( f_main, 24, ducks.panel_x_, ducks[i].panel_y_, 127, 0,0, 100, 100 );
end
end
end

end
//----------------------------------------------------------------------------------------------


//-------------------------- ROUND CONTROLLER B L O C K C O D E --------------------------------
if(game_state == -1) // if intro as finished..

if(round_state == 0) // Starts new round..
put_screen(f_main, 4); // restore initial background..
Shots_left = 3; // now you have 3 shots left..
ID_DUCK = Duck(Counter_Ducks); // launch duck..
Counter_Ducks++; // increase duck counter..
shot_posible = 1; // now has posible to shot..
round_state = 1; // change round state..
end

if(round_state == 1)
if(!exists(ID_DUCK)) // when NOT exists duck process..
shot_posible = 0; // no shot posible..
round_state = 2; // change round state..
end
end

if(round_state == 2)
delay_new_duck_ = ( delay_new_duck_ + 1 ) % 31; // counter for 1 second..
if(delay_new_duck_ == 30) // when 1 second are passed..
delay_new_duck_ = 0; // reset delay por 1 second counter..
if(Counter_Ducks < 10) // if ducks remaining..
round_state = 0; // lauch a new duck..
else // else..
game_state = -2; // finish round.. go to recount ducks..
end

end
end
end

if(game_state == -2)
total_kills += ducks[0].dead_;
total_kills += ducks[1].dead_;
total_kills += ducks[2].dead_;
total_kills += ducks[3].dead_;
total_kills += ducks[4].dead_;
total_kills += ducks[5].dead_;
total_kills += ducks[6].dead_;
total_kills += ducks[7].dead_;
total_kills += ducks[8].dead_;
total_kills += ducks[9].dead_;

if(total_kills > 5)
game_state = -10; // go to next round..
else
play_sound(sfx_16,sound_channel_game_over);
game_state = -3; // game_over..
end
end
//----------------------------------------------------------------------------------------------

//-------------------------- G A M E O V E R B L O C K C O D E --------------------------------
if(game_state == -3)
if(!is_playing_sound(sound_channel_game_over))
game_state = -4;
end
draw_text( fnt_white, "GAME OVER", 4, 160, 43, 199 ); // draw "game over" text..
draw_graphic( f_main, 28, 160, 50, 200, 0,0, 100, 100 ); // draw game over panel..
end

if(game_state == -4)
play_sound(sfx_3,sound_channel_game_over);
game_state = -5;
end

if(game_state == -5)
x = 160;
y = 170;
z = 512;
file = f_main;
graph = 18;
game_state = -6;
end

if(game_state == -6)
delay_dog_risa_ = ( delay_dog_risa_ + 1 ) % 6;
if(delay_dog_risa_ < 3)
graph = 18;
else
graph = 19;
end
if(y > 145)
y--;
else
game_state = -7;
end
draw_graphic( f_main, 22, 160, 176, 128, 0,0, 100, 100 ); // draw grass mask on top..
end

if(game_state == -7)
delay_dog_risa_ = ( delay_dog_risa_ + 1 ) % 6;
if(delay_dog_risa_ < 3)
graph = 18;
else
graph = 19;
end
if(!is_playing_sound(sound_channel_game_over))
round = 0;
estado = 0;
fade_delay = 0;
game_state = 3;
delay_x_dog = 0;
counter_ = 0;
flash_counter_ = 0;
Counter_ducks = 0;
Round_State = 0;
Delay_new_duck_ = 0;
total_kills = 0;
delay_dog_risa_ = 0;
counter_game_over_ = 0;
flash_ducks_in_red = 0;
for(i=0; i<=9; i++);
ducks[i].dead_ = 0;
ducks[i].escape_ = 0;
ducks[i].active_ = 0;
end
inicio();
end
draw_graphic( f_main, 22, 160, 176, 128, 0,0, 100, 100 ); // draw grass mask on top..
end
//----------------------------------------------------------------------------------------------



//------------------------------G O T O N E X T R O U N D--------------------------------------
if(game_state == -10) // round has passed in normal mode..
play_sound(sfx_7, sound_channel_game_over);
id_wait_for_reallocate_ducks = reallocate_ducks_on_panel();
game_state = -11;
end

if(game_state == -11)
if(!is_playing_sound(sound_channel_game_over))
game_state = -12;
end
end

if(game_state == -12)
game_state = -13;
end

if(game_state == -13)
if(!exists(id_wait_for_reallocate_ducks))
game_state = -14;
end
end

if(game_State == -14)
if(total_kills == 10) // round has passed in perfect mode..
play_sound(sfx_13, sound_channel_game_over);
draw_text( fnt_white, "PERFECT", 4, 160, 43, 199 ); // draw "perfect" text..
draw_text( fnt_white, "10000", 4, 160, 53, 199 ); // draw "1000" text..
draw_graphic( f_main, 29, 160, 50, 200, 0,0, 100, 100 ); // draw perfect panel..
score += 10000; // extra bonus score for prefect round..
game_state = -15;
else
game_state = -16;
end
end

if(game_state == -15) // End of round with perfect..
draw_text( fnt_white, "PERFECT", 4, 160, 43, 199 ); // draw "perfect" text..
draw_text( fnt_white, "10000", 4, 160, 53, 199 ); // draw "1000" text..
draw_graphic( f_main, 29, 160, 50, 200, 0,0, 100, 100 ); // draw perfect panel..
if(!is_playing_sound(sound_channel_game_over))
round ++;
intro_ = true;
estado = 0;
fade_delay = 0;
game_state = 3;
x_dog = 60;
y_dog = 200;
delay_x_dog = 0;
counter_ = 0;
flash_counter_ = 0;
Counter_ducks = 0;
Round_State = 0;
Delay_new_duck_ = 0;
total_kills = 0;
delay_dog_risa_ = 0;
counter_game_over_ = 0;
flash_ducks_in_red = 0;
for(i=0; i<=9; i++);
ducks[i].dead_ = 0;
ducks[i].escape_ = 0;
ducks[i].active_ = 0;
end
end
end

if(game_state == -16) // End of round without perfect..
round ++;
intro_ = true;
estado = 0;
fade_delay = 0;
game_state = 3;
x_dog = 60;
y_dog = 200;
delay_x_dog = 0;
counter_ = 0;
flash_counter_ = 0;
Counter_ducks = 0;
Round_State = 0;
Delay_new_duck_ = 0;
total_kills = 0;
delay_dog_risa_ = 0;
counter_game_over_ = 0;
flash_ducks_in_red = 0;
for(i=0; i<=9; i++);
ducks[i].dead_ = 0;
ducks[i].escape_ = 0;
ducks[i].active_ = 0;
end
end
//----------------------------------------------------------------------------------------------








//----------------------------------------------------------------------------------------------
// masc of grass and tree..
if(game_state == -1) // after intro animation..
draw_graphic( f_main, 23, 60, 92, 128, 0,0, 110, 110 ); // draw tree on top..
draw_graphic( f_main, 22, 160, 176, 128, 0,0, 100, 100 ); // draw grass mask on top..
else // before intro animation..
draw_graphic( f_main, 23, 60, 92, 512, 0,0, 110, 110 ); // draw tree on background..
end
//----------------------------------------------------------------------------------------------

//--------------------------------- S H O O T B L O C K C O D E --------------------------------
if(shot_posible == 1) // if a shots posible..
if(shots_left > 0) // if shots availables..
if(estado == 0)
if(mouse.left) // if mouse.left..
stop_sound(sound_channel_shot); // stop/clear sound channel of shot..
play_sound(sfx_17, sound_channel_shot); // play sound of shot..
shot_event = true; // enable shot event.. for duck proces..
fade(200,200,200,64); // instant fade to white screen..
shots_left--; // decrease shot counter..
estado = 1; // change state machine..
end
end
end
end
if(estado == 1) // if shot has begun..
fade_Delay = ( fade_Delay + 1 ) % 5; // start delay for fade to normal color screen..
if(fade_delay == 4) // if delay finished..
estado = 2; // change state machine..
end
end
if(estado == 2)
fade_delay = 0; // reset delay var..
shot_event = false; // disable shot event.. for duck proces..
fade(100,100,100,64); // and instant screen fade to normal color..
estado =3; // change state machine..
end
if(estado == 3)
if(!mouse.left) // when release fire button..
estado = 0; // reset state machine..
end
end
//----------------------------------------------------------------------------------------------

//--------------------------------- P A N E L B L O C K C O D E --------------------------------
if(shots_left == 1) // 1 shot available..
draw_graphic( f_main, 5, 26, 216, 200, 0,0, 115, 110 );
end
if(shots_left == 2) // 2 shots availables..
draw_graphic( f_main, 5, 26, 216, 200, 0,0, 115, 110 );
draw_graphic( f_main, 5, 35, 216, 200, 0,0, 115, 110 );
end
if(shots_left == 3) // 3 shots availables..
draw_graphic( f_main, 5, 26, 216, 200, 0,0, 115, 110 );
draw_graphic( f_main, 5, 35, 216, 200, 0,0, 115, 110 );
draw_graphic( f_main, 5, 44, 216, 200, 0,0, 115, 110 );
end

// draw panels and score..
draw_text( fnt_white, itoa(score), 5, 296, 217, 255 ); // draw score..
draw_graphic( f_main, 6, 35, 220, 256, 0,0, 100, 100 ); // shots panel..
draw_graphic( f_main, 7, 150, 220, 256, 0,0, 100, 100 ); // hit panel..
draw_graphic( f_main, 8, 270, 220, 256, 0, 0, 100, 100 ); // score panel..
//----------------------------------------------------------------------------------------------
frame;
end
end[/Codebox]

[OskarG]

Genial erkos,te lo agradezco ya que entiendo que debes estar ocupado en mil cosas,a ver si aprendo este sistema nuevo de programar y exprimo gemix al maximo.

[erkosone]

Animo con ello Oscar, verás que poco a poco el cuerpo te pide mas y mas.. y esto se aprende solo a base de pegarte horas y horas codeando jeje..