Bueno, gracias a que estoy haciendo una demo, estoy empezando a cojerle práctica a todo lo que son efectos visuales, cosenos, senos (ojalá que fuesen físicos), etc...
Por eso, abro este post para ir poniendoos animaciones y efectos que haga. Si vosotros habéis hecho alguna ponedla.
Empiezo enseñándoos lo último que he hecho. Espirales.
Mover el proceso en una trayectoria espiral:
process espiral()
private
float fi,ro;
float py=3.1416; //Número Pi
int eq=0; //La X alrededor de la cual quieres que trace la espiral.
int yi=0; //La Y alrededor quieres que trace la espiral.
int tipo; //Tipo 0 hace que la espiral se vaya haciendo más grande y tipo 1 hace que la espiral se vaya haciendo más pequeña. Si no se pone límite, cuando fi sea negativo irá haciendose más grande.
end
begin
file=fpgs[0];
graph=1;
fi=1000000; //Este es el ángulo. Cuanto más alejado de 0 (tanto por arriba como por abajo), más lejos del centro.
loop
ro=(fi*py)/180000; //Calculamos Ro (Que es la distancia entre el centro de la espiral y el punto)
x=ro*cos(fi)+eq; //Como ro*cos(fi) saca la x teniendo el centro de la espiral en el origen de coordenadas, sumamos eq al resultado para que se pinte según el centro de espiral que hemos decidido
y=ro*sin(fi)+yi; //Lo mismo que el anterior
if(x<-10 || x>650 || y<-1 || y>650)
break;
end
frame(10);
if(tipo==0)
fi+=incre;
else
fi-=incre;
end
end
end
Pintar una espiral con Map_put_pixel:
process espiral()
private
float fi,ro;
float py=3.1416;
int eq=0;
int yi=0;
int map;
end
begin
map = new_map(640,480,16);
map_clear(0,map,rgb(0,0,0));
fi=1000000; //Este es el ángulo. Cuanto más alejado de 0 (tanto por arriba como por abajo), más lejos del centro.
loop
ro=(fi*py)/180000; //Calculamos Ro (Que es la distancia entre el centro de la espiral y el punto)
x=ro*cos(fi)+eq; //Como ro*cos(fi) saca la x teniendo el centro de la espiral en el origen de coordenadas, sumamos eq al resultado para que se pinte según el centro de espiral que hemos decidido
y=ro*sin(fi)+yi; //Lo mismo que el anterior
pixels(x,y,map,rgb(255,0,0));
if(x<-10 || x>650 || y<-1 || y>650 || fi==0)
break;
end
// Puts the map in the center of the screen
put(0,map,320,240);
frame(10);
if(tipo==0)
fi+=incre;
else
fi-=incre;
end
end
end
process pixels(x,y,int map,int color)
private
int i;
end
begin
map_put_pixel(0,map,x,y,color);
for(i=0;i<120;i++)
frame;
end
map_put_pixel(0,map,x,y,rgb(0,0,0));
end
Espero que os resulten útiles o, al menos, interesantes.
Je, je. Karma.
Me los quedo para la colección. ;D
Me rio porque me da la impresión de que bennu no estaba pensado para esto. Así que no sé como andará de potencia matemática.
Y porque la nueva hornada utilizamos bennu para cualquier cosa. :D
¡Al ataqueeeeerrrrrrr! (Famoso humorista español, Chiquito de la calzada). ;D
Pues debería, al fin y al cabo, mítico videojuego en el que el texto de inicio entra con un efecto de espiral...
jajaja
Jua, jua. Si es el que pienso, si, pero despacito. ;D
Nah, el efecto de la trayectoria va rapido, el de pintar es el que igual no va tan rapido como gustaría
xD
Yawin, ¿por qué no subes alguno de estos ejemplos a la página de map_put_pixel de la wiki? Me imagino que será útil.
Porque no se escribir en wikis. Prefiero dejaros a vosotros ese trabajo xD
¡Juer, tengo esto más abandonao que yo que se!
Bueno, os traigo un nuevo efecto recien salido de mi horno. Lo más posible es que se le puedan mejorar los fps, pero lo hice ayer a las 3 de la mañana y no estaba el horno para bollos xDD
Demonstruación:
http://www.youtube.com/watch?v=6u4Isy86ZMI (http://www.youtube.com/watch?v=6u4Isy86ZMI)
Códigos, códigos, códigos:
function presentacion()
public
int i,j,iy,eq,aux;
end
begin
fade(0,0,0,100);
while(fading)
frame;
end
screen_put(fpgs,1);
fade(100,100,100,1);
while(fading)
frame;
end
for(i=0;i<120;i++)
frame;
end
fade(0,0,0,1);
while(fading)
frame;
end
clear_screen();
fade(100,100,100,64);
eq=100;
iy=195;
set_fps(120,1);
mostrar=true;
for(i=0;i<81;i++)
for(j=0;j<487;j++)
if(map_get_pixel(fpgs,2,j,i)==map_get_pixel(fpgs,3,0,0))
switch(rand(1,4))
case 1:
aux=rand(0,480);
punto(-1,aux,eq,iy);
end
case 2:
aux=rand(0,640);
punto(aux,-1,eq,iy);
end
case 3:
aux=rand(0,480);
punto(641,aux,eq,iy);
end
case 4:
aux=rand(0,640);
punto(aux,481,eq,iy);
end
end
end
eq++;
end
eq=100;
iy++;
end
for(i=0;i<340;i++)
frame;
end
mostrar=false;
set_fps(60,1);
end
process punto(int x, int y, int eq, int iy)
private
int aux,i;
end
begin
graph=new_map(1,1,32);
map_put_pixel(0,graph,0,0,map_get_pixel(fpgs,3,0,0));
repeat
if(x<eq)
x++;
end
if(eq<x)
x--;
end
if(y<iy)
y++;
end
if(iy<y)
y--;
end
frame;
for(i=0;i<rand(1,3);i++)
if(x<eq)
x++;
end
if(eq<x)
x--;
end
end
for(i=0;i<rand(0,3);i++)
if(y<iy)
y++;
end
if(iy<y)
y--;
end
end
until(mostrar!=true)
end
La idea es, nuestro juego llama a la función "presentación". Cuando esta acaba, hace un let_me_alone() y a otra cosa mariposa.
Muy guapo, pero un pelin lento, que PC tienes ?
Mi ordenador es una mierda así de grande: <-------------------------------------------------------------------->
xDD Ya he dichoq ue se podría mejorar. En cuanto pueda os pondré un nuevo efecto. Forma parte de una dmeo que estoy haciendo. Esta:
http://www.youtube.com/watch?v=3m4Z-CBNgWs (http://www.youtube.com/watch?v=3m4Z-CBNgWs)
hace las particulas mas grandes... 2x2 o 4x4.
Esque entonces el logo no queda tan nítido. Ya lo había pensado
vi el video de youtube. Me encantó. Cuando tenga un poco de tiempo libre me estudiaré el efecto. Saludos y karma++
Quote from: Yawin on November 13, 2011, 05:04:04 PM
Esque entonces el logo no queda tan nítido. Ya lo había pensado
si puede quedar nitido, fijate que yo puse un efecto que componia una pantalla completa moviendo bloques de pixels por toda la pantalla, o sea, 4x4, pero no 1 pixel, sino 4x4 pixels de la imagen...
es mas, lo puse como libreria .dcl... busca dcl en el foro, no hay mucho de eso.
pues no lo encuentro ni yo... pero la idea es que cada pixel sea en realidad un bloque de pixels
import "mod_key" ;
import "mod_map" ;
import "mod_proc" ;
import "mod_grproc" ;
import "mod_math" ;
import "mod_rand" ;
import "mod_screen";
import "mod_mem";
#define BB_BLOCK_SIZE 4
global
struct BB_CONFIG
int bfondo;
int fondo;
int _SCR_W;
int _SCR_H;
int SCR_DEPTH;
int * items_order;
int nitems;
int citem;
int cols, rows;
end
end
process BB_particle()
private
xt, yt;
begin
// alpha=0;
if ( BB_CONFIG.citem >= BB_CONFIG.nitems ) return; end
y = ( BB_CONFIG.items_order[BB_CONFIG.citem] / BB_CONFIG.cols );
x = ( BB_CONFIG.items_order[BB_CONFIG.citem] - y * BB_CONFIG.cols );
BB_CONFIG.citem++;
xt = x *= BB_BLOCK_SIZE;
yt = y *= BB_BLOCK_SIZE;
z = father.z - 1;
graph=map_new(BB_BLOCK_SIZE,BB_BLOCK_SIZE,BB_CONFIG.SCR_DEPTH);
map_block_copy(0,graph,0,0,BB_CONFIG.bfondo,xt,yt,BB_BLOCK_SIZE,BB_BLOCK_SIZE,B_NOCOLORKEY);
flags=b_nocolorkey;
switch ( rand( 0, 3 ) )
case 0:
x = rand( 0, BB_CONFIG._SCR_W );
y = 0;
end
case 1:
x = 0;
y = rand( 0, BB_CONFIG._SCR_H );
end
case 2:
x = rand( 0, BB_CONFIG._SCR_W );
y = BB_CONFIG._SCR_H;
end
case 3:
x = BB_CONFIG._SCR_W;
y = rand( 0, BB_CONFIG._SCR_H );
end
end
repeat
// alpha+=3;
angle = near_angle( angle, fget_angle( x, y, xt, yt), 45000/*rand(1000,10000)*/ ) ;
advance( rand( 3, 5 ) ) ;
if ( fget_dist( x, y, xt, yt ) < BB_BLOCK_SIZE )
map_block_copy(0,BB_CONFIG.fondo,xt,yt,BB_CONFIG.bfondo,xt,yt,BB_BLOCK_SIZE,BB_BLOCK_SIZE,B_NOCOLORKEY);
break;
end
frame ;
until( key( _esc ) )
map_del(0, graph);
if ( !key( _esc ) ) BB_particle(); end
end
function BuildBackground(int _file, int graph_bg, int particles, int mode )
private
i;
pid;
int n1, n2, n3;
begin
if ( _file )
BB_CONFIG.bfondo = map_clone( _file, graph_bg );
else
BB_CONFIG.bfondo = graph_bg;
end
BB_CONFIG._SCR_W = map_info( 0, 0, G_WIDTH );
BB_CONFIG._SCR_H = map_info( 0, 0, G_HEIGHT );
BB_CONFIG.SCR_DEPTH = map_info( 0, 0, G_DEPTH );
BB_CONFIG.fondo = graph = map_new( BB_CONFIG._SCR_W, BB_CONFIG._SCR_H, BB_CONFIG.SCR_DEPTH );
x = BB_CONFIG._SCR_W/2;
y = BB_CONFIG._SCR_H/2;
BB_CONFIG.cols = BB_CONFIG._SCR_W / BB_BLOCK_SIZE;
BB_CONFIG.rows = BB_CONFIG._SCR_H / BB_BLOCK_SIZE;
BB_CONFIG.nitems = BB_CONFIG.cols * BB_CONFIG.rows;
BB_CONFIG.items_order = alloc( sizeof( *BB_CONFIG.items_order ) * BB_CONFIG.nitems );
switch ( mode )
case 0:
for ( i = 0; i < BB_CONFIG.nitems; i++ )
BB_CONFIG.items_order[i] = i;
end
end
case 1:
for ( i = 0; i < BB_CONFIG.nitems; i++ )
BB_CONFIG.items_order[BB_CONFIG.nitems-1-i] = i;
end
end
case 2:
for ( i = 0; i < BB_CONFIG.nitems; i++ )
BB_CONFIG.items_order[i] = i;
end
for( i = 0; i < BB_CONFIG.nitems; i++ )
n1 = rand(0,BB_CONFIG.nitems-1);
n2 = rand(0,BB_CONFIG.nitems-1);
n3 = BB_CONFIG.items_order[n1];
BB_CONFIG.items_order[n1] = BB_CONFIG.items_order[n2];
BB_CONFIG.items_order[n2] = n3;
end
end
end
BB_CONFIG.citem = 0;
for ( i = 0; i < particles; i++ )
BB_particle();
end
while( exists( type BB_particle ) )
frame;
end
put_screen( _file, graph_bg );
if ( _file )
map_del( 0, BB_CONFIG.bfondo );
end
map_del( 0, graph );
free( BB_CONFIG.items_order );
end
http://forum.bennugd.org/index.php?action=dlattach;topic=1993.0;attach=1743 (http://forum.bennugd.org/index.php?action=dlattach;topic=1993.0;attach=1743)
gracias Free no lo encontraba... y eso que lo hice yo... :P
Le echaré un vistazo, pero ahora mismo estoy más embarcado en hacer nuevos efectos.
ya lo viste cuando lo publique... salvo que no entendiste para que servia.
Entenderlo, lo entendí. Pero en ese entonces no lo necesité. Y ahora, no se, en algunas cosas es diferente a mi sistema. No se, ya veré que hago. Mañana parto para México y voy a estar hasta arriba de trabajo xDD
A la vuelta igual trasteo un poco.
no digo que lo uses, ya que es otro efecto, sino que veas como es lo que digo de los bloques.
vi algo parecido en otro foro y me hizo acordar:
http://forums.tigsource.com/index.php?topic=632.msg646485#msg646485
(capas sirve como "inspiracion", no se :) )
si, son efectos simples... el que esta impecable es uno de arena que hizo DCelso o Fede... no me acuerdo
Pues buscalo y enseñanoslo xD
esta en el foro.
Era el hilo de la demo. Aquí esta el enlace:
http://forum.bennugd.org/index.php?topic=1993.15 (http://forum.bennugd.org/index.php?topic=1993.15)
ya lo habia visto, muy chulo
Refloto este tema para presentaros un nuevo efecto. llevaba tiempo sin meterme en estos berenjenales:
El efecto se llama "Metabolas". busca simular una dinámica de fluídos o, más bien, el comportamiento de una serie de bolas líquidas entre ellas. Aquí la demonstruación:
https://www.youtube.com/watch?v=arMcPC30UOU (Advertencia: El código abajo expuesto no se corresponde con este vídeo. Es una versión superior.)
import "mod_video";
import "mod_scroll";
import "mod_key";
import "mod_map";
import "mod_screen";
import "mod_proc";
import "mod_draw";
import "mod_math";
import "mod_say";
type metaball
int x,y,m;
end
process main()
private
int i=0,j;
end
begin
control();
set_fps(120,0);
set_mode(640,480,16,MODE_WINDOW);
loop
metaballs(i++);
frame;
end
end
function metaballs(int cont)
private
metaball bola1, bola2, bola3;
int i,j,r,g,b;
float goo=0.95;
float radio,metang;
end
begin
cont*=1500;
metang=3.14*cont/5;
delete_draw(0);
bola1.x=300+cos(metang*2.5)*150; bola1.y=300+sin(metang*2)*150; bola1.m=15;
bola2.x=300+sin(metang*1.8)*150; bola2.y=300+cos(metang*2.0)*150; bola2.m=20;
bola3.x=300+sin(metang+100)*150; bola3.y=300+cos(metang+50)*150; bola3.m=25;
r=128+abs(cos(cont)*127);
g=128+abs(sin(cont)*127);
b=128+abs(sin(cont)*127);
drawing_color(rgb(r,g,b));
radio=0.9;
for(i=0;i<640;i+=4)
for(j=0;j<480;j+=4)
if((bola1.m/(pow(sqrt(pow(bola1.x-i,2)+pow(bola1.y-j,2)),goo)) + bola2.m/(pow(sqrt(pow(bola2.x-i,2)+pow(bola2.y-j,2)),goo)) + bola3.m/(pow(sqrt(pow(bola3.x-i,2)+pow(bola3.y-j,2)),goo)))>radio)
draw_circle(i,j,5);
end
end
end
end
process control()
begin
loop if(key(_esc)) exit(0); end frame; end
end
Aquí os traigo otro efecto: Starfield
Demonstruación: https://www.youtube.com/watch?v=3owISlHoD6U
Código:
import "mod_video";
import "mod_scroll";
import "mod_key";
import "mod_map";
import "mod_screen";
import "mod_proc";
import "mod_draw";
import "mod_math";
import "mod_say";
import "mod_rand";
import "mod_grproc";
import "mod_timers";
process main()
private
int i=0,j=20,k=0,l=0;
end
begin
control();
set_fps(120,0);
set_mode(640,480,32,MODE_WINDOW);
starfield(1200);
end
function starfield(int st)
private
int i,lim=2,cont=0;
bool pulsado=false;
end
begin
angle=0;
repeat
angle++;
if(angle%lim==0)
star(cont++);
if(cont>4) cont=0; end
end
frame;
until(angle>st);
end
process star(int n)
private
int v_x,v_y,divisor=40;
end
begin
graph=map_new(1,1,32);
map_clear(0,graph,rgb(255,255,255));
switch(n)
case 0:
x=320+rand(1,50);
y=240+rand(-1,-50);
end
case 1:
x=320+rand(-1,-50);
y=240+rand(-1,-50);
end
case 2:
x=320+rand(-1,-50);
y=240+rand(1,50);
end
case 3:
x=320+rand(1,50);
y=240+rand(1,50);
end
end
loop
v_x=-(320-x)/10; v_y=-(240-y)/10;
if(v_x==0 && v_y==0) break; end
size+=fget_dist(x,y,320,240)/10;
x+=v_x; y+=v_y;
frame(400);
if(x>640 || x<0 || y>480 || y<0) break; end
end
end
process control()
begin
loop if(key(_esc)) exit(0); end frame; end
end
muy bueno :)
¿Os imagináis un prisma pentagonal que no sea tal?
1º Ponemos cinco puntos a dar vueltas alrededor de una elipse.
2º Las duplicamos varios píxeles más abajo.
3º Conectamos todo por líneas.
¿Resultado?
https://www.youtube.com/watch?v=t1URE5YD4ag
Pero podemos mejorarlo. al pintar las líneas podemos calcular cuales se tienen que ver y cuales no.
https://www.youtube.com/watch?v=20NBLW5vsqU
import "mod_video";
import "mod_scroll";
import "mod_key";
import "mod_map";
import "mod_screen";
import "mod_proc";
import "mod_draw";
import "mod_math";
import "mod_say";
import "mod_rand";
import "mod_grproc";
import "mod_timers";
process main()
private
int i=0,j=80,k=0,l=0;
end
begin
control();
set_fps(120,0);
set_mode(640,480,32,MODE_WINDOW);
loop
i+=cos(timer[0]*1000)*4;
if(k==0)
if(j++>90)k=1; end
else
if(j--<50)k=0; end
end
cubo(i,j,j);
frame;
end
end
function cubo(int stepe, int _wi, int _hi)
private
int i,j,vertices[5][4],ci;
int ly,ly2,v=5;
end
begin
clear_screen();
delete_draw(0);
stepe*=1000;
ly=210-_hi;
ly2=220+_hi*2;
for(i=0;i<v;i++)
vertices[i][0]=320+cos(stepe+(i*70000))*2*_wi;
vertices[i][1]=(240-_hi)+sin(stepe+(i*70000))*_wi;
vertices[i][2]=320+cos(stepe+(i*70000))*2*_wi;
vertices[i][3]=(240+_hi)+sin(stepe+(i*70000))*_wi;
end
drawing_color(rgb(255,255,255));
j=0;
for(i=0;i<v;i++)
if(vertices[i][1]>ly)
if(i>0)
if(vertices[i][3]>ly2 || vertices[j][3]>ly2)
if(j==i+1 || j==i-1)
draw_line(vertices[i][2],vertices[i][3],vertices[j][2],vertices[j][3]);
end
end
else
ci=i;
end
draw_line(vertices[i][0],vertices[i][1],vertices[i][2],vertices[i][3]);
j=i;
end
if(i<v-1)
draw_line(vertices[i][0],vertices[i][1],vertices[i+1][0],vertices[i+1][1]);
else
draw_line(vertices[0][0],vertices[0][1],vertices[i][0],vertices[i][1]);
end
end
if(vertices[ci][3]>ly2+10 || vertices[j][3]>ly2+5)
draw_line(vertices[ci][2],vertices[ci][3],vertices[j][2],vertices[j][3]);
end
end
process control()
begin
loop if(key(_esc)) exit(0); end frame; end
end