¿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]
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.
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.
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