[contribution] Fog code Lite-C

function animate_for_fog()
{
	wait(-integer(random(3)));
	my.frame =0;
	while (1) 
	{ 
		my.frame += 0.6*time_step; 
		if (my.frame >= 32) { my.frame = 1; }
		wait(1); 
	} 
}
void autofog()
{
..........
animate_for_fog();
	if(integer(random(10))>5)
	{
		vec_scale(my.scale_x, 7.8);	
	}
	else
	{
		vec_scale(my.scale_x, random(4));	
	}
..........
}
void generate_fog()
{
..........
if(randint == 0){ ent_create("dust+32.tga", pos_place, autofog); }
if(randint == 1){ ent_create("dustdense+32.tga", pos_place, autofog); }
..........
}

DEFINE max_alpha, SKILL1;

var cam_fog = 1800;
var wind[3];

function set_alpha
{
	my.alpha=0;
	wait(1);
	my.max_alpha = INT(random(25));
	if(my.max_alpha < 10){ my.max_alpha = 15; }
	while(my.alpha < my.max_alpha)
	{
		my.alpha += 0.5*time;
		wait(1);
	}
	my.alpha = my.max_alpha;
}

function fog_wind
{
	while(1)
	{
		wind.x = (random(1) - .5)*1.5;//*.4;
		wind.y = (random(1) - .5)*1.5;//*.4;
		wind.z = random(1)*.4;//*.1;
		sleep(5+random(3));
	}
}

function move_fog
{
	var roll_speed;
	var fade_distance = 500;
	
	roll_speed = random(2)-1; 
	
	while(me)
	{
		my.roll += roll_speed*time; //roll this sprite
		
		my.x += random(20)*wind.x*time;
		my.y += random(20)*wind.y*time;
		
		if(vec_dist(my.x, camera.x) < fade_distance) 
		{
			my.alpha = min(my.max_alpha,  vec_dist(camera.x, my.x) *my.max_alpha / fade_distance);
		}
		
		wait(1);
	}
}

function autofog
{
	my.scale_x = 2.8;
	my.scale_y = my.scale_x;
	my.scale_z = my.scale_x;
	
	var cam_pos[3];
	var randint;
	
	my.passable = on;
	my.transparent = on;
	my.bright = on;
	
	//fade in slowly
	set_alpha();

   //set orientation style
	my.oriented = off;
	my.facing = on;
	
	move_fog();
	
	while(me)
	{
		if(my.alpha < my.max_alpha) { my.alpha += time; }
	//	my.invisible = off;
		vec_set(cam_pos, camera.x);
		cam_pos.z = my.z;
		
		if(vec_dist(my.x, cam_pos) >= cam_fog)
		{
		//	my.invisible = on;
			while(my.alpha > 0) { my.alpha -= time; wait(1); }
			
			my.x = cycle(my.x, camera.x - cam_fog, camera.x + cam_fog);
			my.y = cycle(my.y, camera.y - cam_fog, camera.y + cam_fog);
			my.z = camera.z - random(100) + random (200);
		}
		
		wait(5);
	}
}

function generate_fog
{
	var randint;
	var fogcount=0;
	
	var pos_place[3];
	fog_wind();
	
	while(fogcount < 250)
	{
		fogcount+=1;
		
		pos_place.x = (camera.x - random(2500)) + (camera.x + random (2500));
		pos_place.y = (camera.y - random(2500)) + (camera.y + random (2500));
		pos_place.z = camera.z - random(100) + random (200);
		
		randint = INT(Random(2));
		if(randint == 0){ ent_create("dust1.tga", pos_place, autofog); }
		if(randint == 1){ ent_create("dust2.tga", pos_place, autofog); }
	//	wait(1);
	}
}

define max_alpha, skill1;
define max_fog, 250;

var cam_fog = 500; // needs to be a variable so it can get closer and further away to the camera as needed
var wind[3];

function set_alpha() 
{
	var fade_speed = 0.5;
	// fade model in
	my.alpha=0;
	my.max_alpha = integer(random(30));
	if(my.max_alpha < 10){ my.max_alpha = 15; }
	
	while(my.alpha < my.max_alpha)
	{
		my.alpha += fade_speed*time_step;
		wait(1);
	}
	my.alpha = my.max_alpha;
}

function fog_wind()
{
	while(1)
	{
		// new wind direction...
		vec_set(wind.x, vector((random(0.5) - .25)*1.5, (random(0.5) - .25)*1.5, random(1)*.4));
		//wait(-1 + random(3));
		wait(1);
	}
}

function move_fog()
{
	var roll_speed;
	var fade_distance;
	fade_distance = cam_fog+(cam_fog/7);
	var fog_speed = 20;
	
	roll_speed = random(2)-1; 
	
	while(me)
	{
		my.roll += roll_speed*time_step; //roll this sprite
		
		// update position globally
		c_move(my, nullvector, vector(random(fog_speed)*wind.x*time_step, random(fog_speed)*wind.y*time_step, 0), IGNORE_PASSABLE);
		
		// fade sprite when close to camera
		if(vec_dist(my.x, camera.x) < fade_distance) 
		{
			my.alpha = minv(my.max_alpha, vec_dist(camera.x, my.x) * my.max_alpha / fade_distance);
		}
		
		wait(1);
	}
}

function autofog()
{
	var cam_pos[3];
	var randint;
	
	vec_scale(my.scale_x, 0.8);
	my.passable = on;
	my.transparent = on;
	//fade in slowly
	set_alpha();
	move_fog();
	
	while(me)
	{
		if(my.alpha < my.max_alpha) { my.alpha += time_step; }
		
		vec_set(cam_pos, camera.x);
		cam_pos.z = my.z;
		
		if(vec_dist(my.x, cam_pos) >= cam_fog)
		{
			// fade the fog out
			while(my.alpha > 0) { my.alpha -= time_step; wait(1); }
			
			// set on new position at edge of fog distance
			vec_set(my.x, vector(cycle(my.x, camera.x - cam_fog, camera.x + cam_fog), cycle(my.y, camera.y - cam_fog, camera.y + cam_fog), camera.z - random(100) + random (200)));
		}
		
		wait(5);
	}
}

var fogcount;
function generate_fog()
{
	var randint; // random fog sprite
	
	var pos_place[3];
	
	fog_wind(); // sets a random fog position every so often
	
	if(fogcount<250)
	{
		// set random position around camera
		vec_set(pos_place.x, vector(((camera.x - random(cam_fog)) + (camera.x + random(cam_fog))), ((camera.y - random(cam_fog)) + (camera.y + random(cam_fog))), ((camera.z - random(cam_fog/8)) + random(cam_fog/4))));
//		vec_set(pos_place.x, nullvector);
		
		// get a random number
		randint = integer(random(2));
		// create different fog, based on random number
		if(randint == 0){you=ent_create("Dust_1.tga", pos_place, autofog);you.passable = on;}
		if(randint == 1){you=ent_create("Dust_2.tga", pos_place, autofog);you.passable = on;}
		fogcount += 1;
	}
	else{return;}
}

function main(){
...
while(1){wait(1);
if(fogcount<250){generate_fog();}
}
}