Bennu Game Development

Foros en Español => Otros DIV-likes => PixTudio => Mensaje iniciado por: carles en Febrero 25, 2016, 03:54:30 pm

Título: Generador de explosiones de gráficos
Publicado por: carles en Febrero 25, 2016, 03:54:30 pm
Tal y como hice con mi algoritmo de ondular gráficos: http://forum.bennugd.org/index.php?topic=4177.0 (http://forum.bennugd.org/index.php?topic=4177.0) ahora he hecho lo mismo para el argoritmo de explosión de gráficos, solo que esta vez lo he hecho directamente en PiXtudio, por lo que podréis ejecutarlo directamente en un proyecto nuevo.

¡Del creador del Ondulartron lega el Explotatron!

Instrucciones:
A diferencia del Ondulatron esta vez tendréis que picar código. He puesto todos los parámetros configurables en las Constantes para que sean fáciles de localizar.
Archivo: Ruta del archivo a explotar.
Destino: Ruta donde se guardarán los gráficos generados.
Frames: frames que durará la explosión.
V_inicial: modificador a la velocidad inicial.
Gravedad: añade gravedad a las partículas.
Reductor: reduce el numero de partículas, mínimo 1.
Size_particula: tamaño de las partículas(sólo circulares y lineales).
Tipo: define el tipo de partícula 0: pixel, 1: circulo, 2: línea.
Tecla Intro para generar los gráficos.
Tecla Esc para salir.

Código: [Seleccionar]

Program explotatron;


import "mod_draw";
import "mod_map";
import "mod_proc";
import "mod_say";
import "mod_text";
import "mod_video";
import "mod_math";
import "mod_key";


const
   archivo="fpg-sources/general/1.png";
   destino="fpg-sources/";
   frames=60;         //tiempo que durará la explosión
   v_inicial=5.0;      //modificador a la velocidad inicial
   gravedad=0.00;      //añadimos gravedad a las partículas
   reductor=1;         //reduce el numero de partículas, mínimo 1
   size_particula=1;   //tamaño de las partículas
   tipo=1;            //define el tipo de partícula 0: pixel, 1: circulo, 2: línea
   pixel=0;         //partícula tamaño pixel
   circulo=1;         //partícula circular
   linea=2;         //partícula lineal
end


process main();


Private
   grafico;      //grafico original
   ancho;         //anchura del gráfico
   alto;         //altura del gráfico
   a;            //variable auxiliar
   b;            //variable auxiliar
   c;            //variable auxiliar
   tiempo;         //variable auxiliar controla la duración de la explosión
   graficos[255];   //id de los gráficos
   exportar;      //indica si esta exportando
   struct particula[100000];   //estructura de la partícula
      color;               //color de la partícula
      angulo;               //angulo de la partícula respecto al centro
      float posicion_x;      //coordenada x de la partícula
      float posicion_y;      //coordenada y de la partícula
      float velocidad_x;      //velocidad de desplazamiento horizontal de la partícula
      float velocidad_y;      //velocidad de desplazamiento vertical de la partícula
   end


begin
   set_mode(640,480);
   set_fps(60,0);
   write_var(0,0,0,0,fps);
   x=320;
   y=240;
   grafico=png_load(archivo);
   ancho=graphic_info(file,grafico,g_width);
   alto=graphic_info(file,grafico,g_height);
   from b=0 to alto-1;
      from a=0 to ancho-1;
         if(map_get_pixel(file,grafico,a,b)!=0)   //ignoramos los píxeles transparentes para ahorrar
            particula[c].color=map_get_pixel(file,grafico,a,b);
            particula[c].angulo=fget_angle(ancho/2,alto/2,a,b);
            particula[c].posicion_x=a-(ancho/2);
            particula[c].posicion_y=b-(alto/2);
            particula[c].velocidad_x=cos(particula[c].angulo)*fget_dist(ancho/2,alto/2,a,b)/(ancho/2)*v_inicial;
            particula[c].velocidad_y=-sin(particula[c].angulo)*fget_dist(ancho/2,alto/2,a,b)/(alto/2)*v_inicial;
            c++;
         end
      end
   end
   a=c;
   b=0;
   while(tiempo<=frames)
      graficos[b]=map_new(ancho+(frames*v_inicial*2),alto+(frames*v_inicial*2),32);
      from c=0 to a step reductor;
         if(particula[c].color!=0)
            switch(tipo)
               case pixel:
                  map_put_pixel(
                     0,
                     graficos[b],
                     particula[c].posicion_x+((ancho+frames*v_inicial*2)/2),
                     particula[c].posicion_y+((alto+frames*v_inicial*2)/2),
                     particula[c].color
                  );
               end
               case circulo:
                  drawing_map(0,graficos[b]);
                  drawing_color(particula[c].color);
                  draw_fcircle(
                     particula[c].posicion_x+((ancho+frames*v_inicial*2)/2),
                     particula[c].posicion_y+((alto+frames*v_inicial*2)/2),
                     size_particula
                  );
               end
               case linea:
                  drawing_map(0,graficos[b]);
                  drawing_color(particula[c].color);
                  draw_line(
                     particula[c].posicion_x+((ancho+frames*v_inicial*2)/2),
                     particula[c].posicion_y+((alto+frames*v_inicial*2)/2),
                     particula[c].posicion_x+(particula[c].velocidad_x*size_particula)+((ancho+frames*v_inicial*2)/2),
                     particula[c].posicion_y+(particula[c].velocidad_y*size_particula)+((alto+frames*v_inicial*2)/2)
                  );
               end
            end
         end
         particula[c].posicion_x+=particula[c].velocidad_x;
         particula[c].posicion_y+=particula[c].velocidad_y;
         particula[c].velocidad_y+=gravedad;
      end
      tiempo++;
      b++;
   end
   a=1;
   b=0;
   loop   //empieza la demo
      graph=graficos[a];
      if(b==0)
         if(a >= frames)
            b=1;
            frame(1000);
            if(exportar==true) exit(); end
         else
            if(exportar==true)
               png_save(0,graph,destino+a+".png");
            end
            a++;
         end
      else
         if(a <= 0)
            b=0;
            frame(1000);
         else
            a--;
         end
      end
      if(exportar==false)
         if(key(_esc)) exit(); end
         if(key(_enter))
            exportar=true;
            write(0,0,20,0,"Exportando");
            say("Exportando");
            a=1;
            b=0;
         end
      end
      frame;
   end
end
Título: Re:Generador de explosiones de gráficos
Publicado por: JaViS en Febrero 25, 2016, 04:52:31 pm
estaria bueno ver un video del efecto :D
Título: Re:Generador de explosiones de gráficos
Publicado por: FreeYourMind en Febrero 25, 2016, 07:35:23 pm
lo compilas, ejecutas y grabas el video para nosotros xD
Título: Re:Generador de explosiones de gráficos
Publicado por: JaViS en Febrero 25, 2016, 07:43:06 pm
Todavia no estoy usando pixtudio D:
Título: Re:Generador de explosiones de gráficos
Publicado por: panreyes en Febrero 25, 2016, 07:51:04 pm
No me había enterado de que Carles lo había preparado sobre la plantilla. El gráfico está incluído en "elCompilador" al crear un proyecto nuevo y pastear el código :)

Lo he grabado en un vídeo aquí:
https://youtu.be/5K0gv2bIK7U
Título: Re:Generador de explosiones de gráficos
Publicado por: josebita en Febrero 29, 2016, 03:19:40 pm
Qué guapo, Carles.

¡Felicidades!
Título: Re:Generador de explosiones de gráficos
Publicado por: Drumpi en Febrero 29, 2016, 08:41:53 pm
Me sumo a la felicitación. No había dicho nada, pero el efecto mola ¿Habeis hecho un test de rendimiento?
Karma++
Título: Re:Generador de explosiones de gráficos
Publicado por: carles en Marzo 03, 2016, 11:23:31 am

Citar
¿Habeis hecho un test de rendimiento?
El objetivo de este programa es generar los gráficos para que puedas añadirlos a tu FPG, para no tener problemas de rendimiento a la hora de ponerlos en tu juego.
Originalmente el código generaba la animación frame a frame, puedes verlo en mi post de presentación:
http://forum.bennugd.org/index.php?topic=1307.msg21101#msg21101
Título: Re:Generador de explosiones de gráficos
Publicado por: Drumpi en Marzo 03, 2016, 12:52:26 pm
Ya, yo era por curiosidad. Lo mismo habeis hecho la prueba y el rendimiento es tan bueno que se puede usar en tiempo real :D
Hombre, con tantas "partículas" lo dudo, pero oye, ordenadores de 8bits han hecho virguerías en ese aspecto con 10 pixels :P