Efectos visuales

[FreeYourMind]

Code Select Expand

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

[SplinterGU]

gracias Free no lo encontraba... y eso que lo hice yo... :P

[Yawin]

Le echaré un vistazo, pero ahora mismo estoy más embarcado en hacer nuevos efectos.

[SplinterGU]

ya lo viste cuando lo publique... salvo que no entendiste para que servia.

[Yawin]

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.

[SplinterGU]

no digo que lo uses, ya que es otro efecto, sino que veas como es lo que digo de los bloques.

[gecko]

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 :) )

[SplinterGU]

si, son efectos simples... el que esta impecable es uno de arena que hizo DCelso o Fede... no me acuerdo

[FreeYourMind]

Pues buscalo y enseñanoslo xD

[SplinterGU]

esta en el foro.

[Fede]

Era el hilo de la demo. Aquí esta el enlace:

http://forum.bennugd.org/index.php?topic=1993.15

[FreeYourMind]

ya lo habia visto, muy chulo

[Yawin]

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.)

Code Select Expand

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

[Yawin]

Aquí os traigo otro efecto: Starfield

Demonstruación: https://www.youtube.com/watch?v=3owISlHoD6U

Código:

Code Select Expand

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


[JaViS]

muy bueno :)