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.
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
estaria bueno ver un video del efecto :D
lo compilas, ejecutas y grabas el video para nosotros xD
Todavia no estoy usando pixtudio D:
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
Qué guapo, Carles.
¡Felicidades!
Me sumo a la felicitación. No había dicho nada, pero el efecto mola ¿Habeis hecho un test de rendimiento?
Karma++
Quote¿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
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