Bichitos jerarquicos

[Danielo515]

¿se le puede llamar a esto proyecto? quizá proyecto de salvapantallas, eso sí. Bueno, como ya he declarado mi desaforada afición por programar cosas estúpidas, puedo colgar esta enorme estupidez. Estaba yo empollando el sistema de arhcivos de linux, y tras leer una y otra y otra vez que tiene forma de árbol invertido (por qué tienen que decirlo tantas veces) pues me rallé y pensé que sería divertido un programa que hiciera uno de esos árboles pero con un poco de aleatoriedad.  Pero ese es el problema de lo aleatorio, que nunca hace lo que esperas, así que me ví obligado a inspirarme en un sistema de rejilla que ví por este foro para que no se quedaran todos los ibchitos en el medio de la pantalla, limitando la población por cada parcela. Y como que cada pixel fuera de un color aleatorio distinto, decidí incluirle algunas features:

• cada "hijo" ereda la escala cromática del padre con un factor de mutación
• La primera iteración del programa es en forma de árbol, las siguientes son mucho más aleatorias
• si se juntan más de 5 que quieren hacer una casa en una misma parcela, sale una casita, aunque esta fucnión viene desactivada y debereis cambiar el modo a 32 bits si quereis que fucione
• se pueden tomar screenshots con la S
• puedes ver la regilla manteniendo space, y la ocupación de cada parcela con la v
• Se limpia la pantalla con la c, full screen f
• cuando termina al ratito vuelve a empezar
• futura implementación de salvapantallas

Va dedicado a todos los que disfrutais programando, sobre todo chorradillas XD. Seguro que me dejo algo, pero, ya lo diré
[code language="bennu"]
import "mod_wm"
import "mod_timers";
import "mod_say";
import "mod_video";
import "mod_screen";
import "mod_time";
import "mod_map";
import "mod_rand";
import "mod_draw";
import "mod_text";
import "mod_key";
import "mod_proc";
//

const
reg=50;//tamaño de la parcela
screen_x=1280;
screen_y=800;
reg_x=screen_x/reg;
reg_y=screen_y/reg;
max_proc=500;

/*variables para configurar la longitud del camino*/
c1=10;

global
population=25;//cantidad máxima de procesos por parcela
c2=20;//camino máximo, la primera vez siempre 20
v=1;//minimo recorrido direccion vertical
takingscreenshot;
procesos;
mapa;
rejilla;
home;
int pasadas[reg_x][reg_y];
//int casas[reg_x][reg_y];
local
i,j;

begin
//home=load_png("casita.png");

centrar_escritorio();
padre();
rand_seed(time());

write(0,0,10,3,"procesos:");
write_var(0,60,10,3,procesos);

write(0,100,10,3,"camino:");
write_var(0,150,10,3,c2);



mapa=new_map(2,2,16);
map_clear(0,mapa,156);
rejilla=new_map(screen_x,screen_y,16);

rejilleitor();

repeat
if(key(_c) or procesos<=0 && timer>500)
   let_me_alone();
   clear_screen(); //limpiamos la pantalla
   delete_text(0);
    write(0,0,10,3,"procesos:");
     write_var(0,60,10,3,procesos);

     write(0,100,10,3,"camino:");
     write_var(0,150,10,3,c2);
     
     write(0,200,10,3,"poblacion por parcela:");
     write_var(0,400,10,3,population);
     population=rand(25,100);

   procesos=1;
   /*vaciamos los datos de la regilla*/
   for(i=0;i<reg_x;i++)
        for(j=0;j<reg_y;j++)
            pasadas[j]=0;
           // casas[j]=0;
        end
   end
   c2=rand(20,60); //en las ejecuciones conscutivas, el camino máximo puede variar
   v=rand(-2,1); //idem para el camino mínimo
   padre();    //volvemos a empezar
   rejilleitor();
   
end//if

if (key(_s))
            if (takingscreenshot==0)
                takingscreenshot=1;
                graph=screen_get(); // grabs the screen and sets it as the program graphic
                png_save(0,graph,"shot"+rand(0,9999)+".png"); // saves the graphic as a png with a
                                                              // random number in the filename to
                                                              // prevent overwriting
                map_unload(0,graph);  //frees the graphic
            else
                takingscreenshot=0;
            end
            while(key(_s)) frame; end
            end

if(key(_v) and !exists(type verbose)) verbose(); end
if(key(_f)) full_screen=true; set_mode(screen_x,screen_y,16);end

/*for(i=0;i<reg_x;i++)
        for(j=0;j<reg_y;j++)
            if(casas[j]>=5)
               casa(i*reg,j*reg);
               casas[j]=0;
            end
         end
   end*/

frame;
until(key(_esc));

exit();

end




process padre()
private
begin
x=screen_x/2;
y=10;

z=rand(2,20);
graph=mapa;

for (i=1; i<z; i++)
   hijo(x,y,rand(100,1658137));
end
procesos--;
end

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
process hijo(x,y,color);
private
xx;
yy;
camino;
//want_casa;
int x_a,y_a;
int antx,anty;
begin
procesos++;
if((x_a=x/reg)<0 or x_a>reg_x)x_a=0;end
if((y_a=y/reg)<0 or y_a>reg_y)y_a=0;end
say(y_a);
say(y_a);
pasadas[x_a][y_a]++;

if(pasadas[x_a][y_a]>population)procesos--;signal(id,s_kill);end

yy=rand(v,2);
xx=rand(-2,2);
camino=rand(c1,c2);
graph=mapa;
z=rand(1,5);
//want_casa=rand(0,1);

i=1;
     if((antx=x/reg)<0 or antx>reg_x)antx=0;end
     if((anty=y/reg)<0 or anty>reg_y)anty=0;end
while(i<camino )

/*if(want_casa==1)   
   if(antx<>(x/reg_x) and anty<>(y/reg_y)) //si se ha movido a otra casilla
     if(casas[antx][anty]>0)casas[antx][anty]--;end//resta las ganas de casa de la anteriore
     if((antx=x/reg)<0 or antx>reg_x)antx=0;end
     if((anty=y/reg)<0 or anty>reg_y)anty=0;end //actualiza a la nueva casilla
     casas[antx][anty]++;//y expresa sus ganas de casa en la nueva
    end
end*/
   
   x+=xx;
   y+=yy;
   map_put_pixel(0,0,x,y,color);
   i++;
      frame;
end

color+=rand(-10,100);
if(x>0 and x<screen_x and y<screen_y and y >0)
   for (i=1; i<=z and procesos<max_proc;i++)
         hijo(x,y,color);
   end
end

procesos--;


timer=0;
end




process rejilleitor()
private
sw=0;
begin
/*dibujamos la rejilla, simbolica y visual*/
map_clear(0,rejilla,0);
drawing_color(rgb(255,19,10));
drawing_map(0,rejilla);

for(i=0;i<reg_x;i++)
    draw_line(i*reg,0,i*reg,screen_y);
    for(j=0;j<reg_y;j++)
       pasadas[j]=0;
    end
end

for(j=0;j<reg_y;j++) draw_line(0,j*reg,screen_x,j*reg); end
    /*---------------------*/
set_center(0,rejilla,0,0);
x=0;y=0;
graph=rejilla;
repeat
frame;

if(key(_space))graph=rejilla; else graph=0; end

until(key(_esc));   

end

/**********************************************************************************************************************************
*****                              verbose mode                                           ***************/
process verbose()
private
textos[reg_x][reg_y];
begin
/* verbose mode*/
    timer[1]=0;
    for(i=0;i<reg_x;i++)
            for(j=0;j<reg_y;j++)
               if(pasadas[j]>population)set_text_color(rgb(0,250,5));end
                textos[j]=write_var(0,i*reg,j*reg,3,pasadas[j]);
                write_var(0,i*reg,(j*reg)+15,3,casas[j]);
                set_text_color(rgb(255,255,255));
            end
    end

   while(timer[1]<500)
       frame;
   end

   for(i=0;i<reg_x;i++)
        for(j=0;j<reg_y;j++)
           delete_text(textos[j]);
        end
   end

end




/**********************************************************************************************************************************
*****                              centrar escritorio                                              ***************
***** se le pueden pasar una imagen como parametro(tomara los valores de la imagen) o ninguna (0) y tomara los que haya   ***********
**********************************************************************************************************************************/
function centrar_escritorio();
   private
      desk_x;
      desk_y;
      a
      alto_desk;
      escritorio_x,escritorio_y;
   int   tam_max;
   int porcentaje=100; //por defecto es el 100%
   begin
      get_desktop_size(&desk_x,&desk_y);
      escritorio_x=desk_x;
      escritorio_y=desk_y;
      desk_x/=2;// y en esta calculamos la posicion centrada x
      desk_y/=2;//en esta calculamos la posicion centrada y*/
        set_mode(screen_x,screen_y,16 | mode_frameless);// y seteamos la pantalla
        set_window_pos(desk_x-screen_x/2,desk_y-screen_y/2);
   end


process casa(x,y)
begin
graph=home;
repeat
frame;
until(key(_esc))
end[/code]

[SplinterGU]

splinter@splinter:~/Bennu/sources/users$ bgdc arbol.prg
BGDC 1.0.0 (Jun 14 2009 12:35:08)
Copyright � 2006-2009 SplinterGU (Fenix/BennuGD)
Copyright � 2002-2006 Fenix Team (Fenix)
Copyright � 1999-2002 Jos� Luis Cebri�n Pag�e (Fenix)
Bennu Game Development comes with ABSOLUTELY NO WARRANTY;
see COPYING for details

/home/splinter/Bennu/sources/users/librender:0: warning: Variable redeclared ("ALPHA_STEPS")
/home/splinter/Bennu/sources/users/arbol.prg:248: error: Unknown identifier ("CASAS")

[Danielo515]

Simplemente comenta esa línea o descomenta las demas, aunque recomiendo más comentarla. No obstante, intentaré subirlo con la funcionalidad de las casas quitada por completo.
Un saludo.

[Windgate]

Maravilloso Danielo!!!

Una aplicación sin sentido donde las haya, pero es bonito de ver, estupendo, me ha gustado mucho el efecto de los colores y el árbol generándose.

¿Por qué no nos acostumbramos a subir versiones con un .sh y un .bat que se ocupe de la ejecución en Windows/Ubuntu? Así resulta mucho más fácil y rápido probar y compartir las aplicaciones que hacemos, por sencillas que sean.

Te dejo un link de una aplicación estúpida e incompleta donde hago uso de un .sh y un .bat, por si quieres guardarlo como plantilla para próximos proyectos que quieras compartir. La carpeta DLL está ahí para quienes no tienen Bennu instalado en XP, pero requiere tocar un poco el código, así que puedes ignorarla.

http://www.mediafire.com/?nwzmhjhyu2t

Enhorabuena nuevamente, también es bueno usar Bennu para propósitos generales además de hacer videojuegos "jugables" xD

[MephistoII666]

Vaya vaya vaya... que divertida implementación de la inutilidad xD

Bonito efecto.

Ese código se podría reutilizar con no muchos cambios para dibujar "rayos y truenos", simplemente haciendo que el padre también descienda, con una probabilidad más baja de "parir" hijos con una esperanza de vida más corta y trazando lineas en vez de píxels (o incluso eventualmente reemplazando todas las primitivas de dibujado por imágenes de rayos pre-cortadas). Sería un efecto bastante más agradable que gráficos de rayos pre-dibujados porque nunca serían igual :P

Que puedo decir, buen trabajo, me gusta.

[Danielo515]

Ja ja ja, si no hubiera hablado yo mismo de la inmensa inutilidad del programa hasta me habría ofendido con algún comentario  ;D
Me ha hecho gracia lo de windows/ubuntu, como si fuera el único linux  ;) pero entiendo lo que has querido decir, y le hecharé un vistazo a tu aportación muchas gracias. De todos modos, en linux habría que añadirle permisos de ejecución al script, e incluso revisarlo por si acaso, así que no se si realmente sería más cómodo que compilar el código. Y lo de windows, pues sí, lo único que adjuntar una descarga con las dlls solo para un ejemplo tan tonto....

Esto es lo bonito de compartir, que surjan nuevas ideas como la de Mephisto, y que insulten a tu inutil proyecto  :D

Muchas gracias por probarlo