[Contribution] Resident Evil Camera

/*
'RESIDENT EVIL' STYLE CAMERA by <tesanders & Orange Brat>
HOW TO USE THIS CODE:
//
Each 'camera' has a 'camera entity' and its corresponding trigger entity. You assin the "set_cam" and "set_cam_trigger" actions and set each entities skill1 to an equal value. 
Both entities must have the same skill1 value and you can use up to 200 cameras, by default, but you can use any total you want by changing the array value. Do not assin "0"
as a skill1 value or it will return without switching cameras. You can also use more than one trigger entity for each camera. This is useful when you need to extend the influence 
of a specfic camera. You can insert an "island"of influence inside the zone of another camera's hotzone, too.

The 3rd object is a look at entity. It is used for an offset(if desired) based on the "cam_factor" variable. If you set it to 0, the camera will always look directly at the player. 
If you set it to 1 if will always look at the look at entity and will ever move... a perfectly still camera. If you set it to any value between 0 and 1, it will always match the "lerped" 
spot bewteen the player and the look at entity and will move when the player moves. The downside to this setup is, as is, you can only have one look at object per level. It can 
easily be adapted so that the camera has its own look at object, but if you don't require and offset, you can comment out the camera_move function and uncomment the other. Using the 
alternate function, you can still achieve a perfectly still camera by setting the camera entities flag1 to on. If you want it to follow the player set it to off.
*/

ENTITY* cam_look_at;//the look at object pointer
ENTITY* cam_ptr;// the camera object pointer
var cam_array[200]; // max 200 cameras
var cam_closest_distance;
var cam_active = 1;//0 = not active 1 = active
VECTOR temp, cam_target;

// 0 = always follows player 
// 1 = always look at cam_look_at
// between 0-1 looks at offset between player and cam_look_at
var cam_factor = 1;


function get_cam(cam_number){//retrieve fixed view
	proc_kill(4);
	if(cam_array[cam_number] == 0){return;}//no cameras available
	cam_ptr = ptr_for_handle(cam_array[cam_number]);//Store cam_number in cam_ptr, for next function
}

function init_cameras(){ //gets first camera
	get_cam(1);
}

function cam_poller(){ //controls the camera trigger array
	proc_kill(4);
	while(1){wait(1);
		cam_closest_distance = 100000;
	}
}

action set_cam(){//store fixed view - This is where the look at pointer is looking 
	set(me,INVISIBLE+PASSABLE);
	cam_array[my.skill1] = handle(me);	
}

action set_cam_trigger(){//trigger for fixed view
	while(player == NULL) {wait(1);}
	set(my,INVISIBLE + PASSABLE);
	while(1){wait(1);
		if(vec_dist(my.x,player.x) < cam_closest_distance){
			cam_closest_distance = vec_dist(my.x,player.x);
			get_cam(my.skill1);	
		}
	}
}

action set_cam_look_at(){//assign as look at object - This looks for the set_cam with equal skill1 value.
	set(my,PASSABLE+INVISIBLE);
	cam_look_at = me;	
}

function camera_move(){
	while(cam_ptr == NULL){wait(1);}
	while(cam_active == 1){wait(1);
		if(!cam_look_at){
			vec_set(camera.x,cam_ptr.x);
			vec_lerp(cam_target.x, player.x, cam_look_at.x, cam_factor);//Get the offset based on cam_factor
			vec_set(temp,cam_target.x);
			vec_sub(temp,camera.x);
			vec_to_angle(camera.pan,temp);//camera looks at cam_target	
		}
	}	
}

/*
function camera_move(){
	while(cam_ptr == NULL){wait(1);}
	while(cam_active == 1){wait(1);
		if(is(cam_ptr,FLAG1)){
			vec_set(camera.x, cam_ptr.x);
			vec_set(camera.pan,cam_ptr.pan);
		}
		else{
			vec_set(camera.x,cam_ptr.x);
			vec_set(temp,player.x);//assign to temp
			vec_sub(temp,camera.x);//get players sidtance from camera
			vec_to_angle(camera.pan,temp);//camera looks at player
		}
	}	
}
*/

action re_player(){
	
	player = me;	
	
	set(me,NARROW);//+FAT+SHADOW+CAST);
	//other functions here
	
	wait(2);
	
	cam_active = 1;
	camera_move();
	init_cameras();
	while(1){wait(1);
		
    c_move(me, vector((key_w - key_s)*time_step*8,0,0), nullvector, IGNORE_PASSABLE | GLIDE);
		
	}
}

ENTITY* cam_pointer;
var dist = 500;
VECTOR temp;
action camera_place ()
{
	set(me,INVISIBLE);

	while(1)
	{
		if(player)
		{
			var result_trace = c_trace(player.x,my.x,IGNORE_ME|IGNORE_PASSABLE);	
			if(!result_trace)
			{						
				if(vec_dist(my.x, player.x) < dist)
				{
					cam_pointer = me;					
				}
			}			
		}
		wait(1);
	}
}

function camera_fun() // in loop
{
	if (cam_pointer)	
	{
		vec_set(camera.x,cam_pointer.x);
		vec_set(temp,player.x); 
		vec_sub(temp,camera.x);
		vec_to_angle(camera.pan,temp); 
	}
}