/* Chronic Stocks for the AMXX engine or fakemeta module.
*
* Made by GHW_Chronic
*
* Version 1.0
*
*/

//If your script uses fakemeta not engine,
//remove the "//" on the next line.
//#define use_fakemeta

#if defined _chr_engine_included
  #endinput
#endif
#define _chr_engine_included

#include <amxmodx>

#if defined use_fakemeta
#include <fakemeta>

#define EV_VEC_origin	1
#define EV_VEC_velocity	2
#define EV_VEC_angles	3
#define EV_VEC_v_angle	4

#define EV_INT_fixangle	1

#else
#include <engine>
#endif


/****************************************************
  ent1 aims at ent2 with Float:offset[3]

  Regions: If ent2 is a player or NPC, regions can be applied
    Note that regions are not 100% accurate but come pretty
    close to aiming at the specified body part.
  0 = Default / aim at origin (Crotch area)
  1 = head
  2 = chest
  3 = Right Arm
  4 = Left Arm
  5 = Right Leg
  6 = Left Leg
*****************************************************/

stock entity_set_aim(ent1,ent2,Float:offset2[3],region)
{
	if(!is_valid_ent(ent1) || !is_valid_ent(ent2) || ent1==ent2)
	{
		return 0;
	}

	static Float:offset[3]
	offset[0]=offset2[0], offset[1]=offset2[1], offset[2]=offset2[2]
	static Float:ent1origin[3]
	static Float:ent2origin[3]
	static Float:view_angles[3]

	entity_get_vector(ent2,EV_VEC_origin,ent2origin)

	if(ent1>32) entity_get_vector(ent1,EV_VEC_origin,ent1origin)
	else
	{
		static origin[3]
		get_user_origin(ent1,origin,1)
		IVecFVec(origin,ent1origin)
	}

	static bool:player
	static buttons

	if(ent2<=32)
	{
		player=true
		get_user_button(ent2)
	}
	else
	{
		player=false
		buttons=0
	}

	switch(region)
	{
		case 1:
		{
			if(player)
			{
				static origin2[3]
				get_user_origin(ent2,origin2,1)
				IVecFVec(origin2,ent2origin)
				offset[0] += 7.0
				//offset[1] += 7.0
				offset[2] += 5.0
			}
			else
			{
				offset[2] += 30.173410
			}
		}
		case 2:
		{
			if(player && (buttons & IN_DUCK))
			{
				offset[2] += (17.271676 / 2.0)
			}
			else
			{
				offset[2] += 17.271676
			}
		}
		case 3:
		{
			if(player && (buttons & IN_DUCK))
			{
				offset[0] += (12.000000 / 2.0)
				offset[2] += (11.028901 / 2.0)
			}
			else
			{
				offset[0] += 12.000000
				offset[2] += 11.028901
			}
		}
		case 4:
		{
			if(player && (buttons & IN_DUCK))
			{
				offset[0] += (-12.000000 / 2.0)
				offset[2] += (11.028901 / 2.0)
			}
			else
			{
				offset[0] += -12.000000
				offset[2] += 11.028901
			}
		}
		case 5:
		{
			if(player && (buttons & IN_DUCK))
			{
				offset[0] += (8.000000 / 2.0)
				offset[2] += (-19.768786 / 2.0)
			}
			else
			{
				offset[0] += 8.000000
				offset[2] += -19.768786
			}
		}
		case 6:
		{
			if(player && (buttons & IN_DUCK))
			{
				offset[0] += (-8.000000 / 2.0)
				offset[2] += (-19.768786 / 2.0)
			}
			else
			{
				offset[0] += -8.000000
				offset[2] += -19.768786
			}
		}
	}

	static Float:ent2_angles[3]
	entity_get_vector(ent2,EV_VEC_v_angle,ent2_angles)
	ent2origin[0] += offset[0] * (((floatabs(ent2_angles[1]) - 90) / 90) * -1)
	ent2origin[1] += offset[1] * (1 - (floatabs(90 - floatabs(ent2_angles[1])) / 90))
	ent2origin[2] += offset[2]

	ent2origin[0] -= ent1origin[0]
	ent2origin[1] -= ent1origin[1]
	ent2origin[2] -= ent1origin[2]

	static Float:hyp
	hyp = floatsqroot( (ent2origin[0] * ent2origin[0]) + (ent2origin[1] * ent2origin[1]))

	static x, y, z
	x=0, y=0, z=0

	if(ent2origin[0]>=0.0) x=1
	if(ent2origin[1]>=0.0) y=1
	if(ent2origin[2]>=0.0) z=1

	if(ent2origin[0]==0.0) ent2origin[0] = 0.000001
	if(ent2origin[1]==0.0) ent2origin[1] = 0.000001
	if(ent2origin[2]==0.0) ent2origin[2] = 0.000001

	ent2origin[0]=floatabs(ent2origin[0])
	ent2origin[1]=floatabs(ent2origin[1])
	ent2origin[2]=floatabs(ent2origin[2])

	view_angles[1] = floatatan2(ent2origin[1],ent2origin[0],degrees)

	//1=positive 0=negative
	if(x && !y) view_angles[1] = -1 * ( 180 - view_angles[1] )
	if(!x && !y) view_angles[1] = ( 180 - view_angles[1] )
	if(!x && y) view_angles[1] = view_angles[1] = 180 + floatabs(180 - view_angles[1])
	if(x && !y) view_angles[1] = view_angles[1] = 0 - floatabs(-180 - view_angles[1])
	if(!x && !y) view_angles[1] *= -1

	while(view_angles[1]>180.0) view_angles[1] -= 180
	while(view_angles[1]<-180.0) view_angles[1] += 180
	if(view_angles[1]==180.0 || view_angles[1]==-180.0) view_angles[1]=-179.999999

	view_angles[0] = floatasin(ent2origin[2] / hyp,degrees)

	if(z) view_angles[0] *= -1

	entity_set_int(ent1,EV_INT_fixangle,1)
	entity_set_vector(ent1,EV_VEC_v_angle,view_angles)
	entity_set_vector(ent1,EV_VEC_angles,view_angles)
	entity_set_int(ent1,EV_INT_fixangle,1)

	return 1;
}


/***********************************************
  Set the amount of recoil for ent's next shot.
  0.0 = No Recoil.
***********************************************/

stock set_recoil(ent,Float:amount)
{
	if(!is_valid_ent(ent))
	{
		return 0;
	}

	static origin[3]
	static Float:endpos[3]
	get_user_origin(ent,origin,1)
	IVecFVec(origin,endpos)

	endpos[0] += random_float(amount * -1,amount)
	endpos[1] += random_float(amount * -1,amount)
	endpos[2] += random_float(amount * -1,amount)

	entity_set_vector(ent,EV_VEC_punchangle,Float:{ 0.0, 0.0, 0.0 })
	entity_set_vector(ent,EV_VEC_endpos,endpos)

	return 1;
}


/*************************************************
  Set's ent1's origin and angle so that ent1
  reflects ent2's origin and angles with supplied
  offsets.
*************************************************/

stock reflect(ent1,ent2,Float:offset2[3],Float:angleoffset2[3])
{
	if(!is_valid_ent(ent1) || !is_valid_ent(ent2) || ent1==ent2)
	{
		return 0;
	}

	static Float:offset[3]
	static Float:angleoffset[3]

	offset[0] = offset2[0], offset[1] = offset2[1], offset[2] = offset2[2]
	angleoffset[0] = angleoffset2[0], angleoffset[1] = angleoffset2[1]

	static Float:ent2origin[3]
	static Float:ent2angles[3]

	entity_get_vector(ent2,EV_VEC_origin,ent2origin)
	entity_get_vector(ent2,EV_VEC_angles,ent2angles)

	ent2origin[0] += offset[0] * (((floatabs(ent2angles[1]) - 90) / 90) * -1)
	ent2origin[1] += offset[1] * (1 - (floatabs(90 - floatabs(ent2angles[1])) / 90))
	ent2origin[2] += offset[2]

	ent2angles[0] += angleoffset[0]
	ent2angles[1] += angleoffset[1]

	entity_set_vector(ent1,EV_VEC_origin,ent2origin)
	entity_set_int(ent1,EV_INT_fixangle,1)
	entity_set_vector(ent1,EV_VEC_angles,ent2angles)
	entity_set_vector(ent1,EV_VEC_v_angle,ent2angles)
	entity_set_int(ent1,EV_INT_fixangle,1)

	return 1;
}


/*************************************************
  Finds the location on ent1's hud that ent2 with
  defined offset is located. Returns the location
  into the Float:hudpos[2] varaible.
  ent1 must be a player. (1-32)
    Note: locations may be off by small amounts.
    Around 90% accurate results.
*************************************************/

stock get_hudmessage_locs(ent1,ent2,Float:offset2[3],Float:hudpos[2])
{
	if(!is_user_connected(ent1) || !is_valid_ent(ent2) || ent1==ent2)
	{
		return 0;
	}

	static Float:offset[3]
	offset[0] = offset2[0], offset[1] = offset2[1], offset[2] = offset2[2]

	static Float:ent1origin[3]
	static Float:ent2origin[3]
	static Float:view_angles[3]

	entity_get_vector(ent2,EV_VEC_origin,ent2origin)

	static origin[3]
	get_user_origin(ent1,origin,1)
	IVecFVec(origin,ent1origin)

	static Float:ent1_angles[3]
	static Float:ent2_angles[3]

	entity_get_vector(ent1,EV_VEC_v_angle,ent1_angles)
	entity_get_vector(ent2,EV_VEC_v_angle,ent2_angles)

	ent2origin[0] += offset[0] * (((floatabs(ent2_angles[1]) - 90) / 90) * -1)
	ent2origin[1] += offset[1] * (1 - (floatabs(90 - floatabs(ent2_angles[1])) / 90))
	ent2origin[2] += offset[2]

	ent2origin[0] -= ent1origin[0]
	ent2origin[1] -= ent1origin[1]
	ent2origin[2] -= ent1origin[2]

	static Float:hyp
	hyp = floatsqroot( (ent2origin[0] * ent2origin[0]) + (ent2origin[1] * ent2origin[1]))

	static x, y, z
	x=0, y=0, z=0

	if(ent2origin[0]>=0.0) x=1
	if(ent2origin[1]>=0.0) y=1
	if(ent2origin[2]>=0.0) z=1

	if(ent2origin[0]==0.0) ent2origin[0] = 0.000001
	if(ent2origin[1]==0.0) ent2origin[1] = 0.000001
	if(ent2origin[2]==0.0) ent2origin[2] = 0.000001

	ent2origin[0]=floatabs(ent2origin[0])
	ent2origin[1]=floatabs(ent2origin[1])
	ent2origin[2]=floatabs(ent2origin[2])

	view_angles[1] = floatatan2(ent2origin[1],ent2origin[0],degrees)

	//1=positive 0=negative
	if(x && !y) view_angles[1] = -1 * ( 180 - view_angles[1] )
	if(!x && !y) view_angles[1] = ( 180 - view_angles[1] )
	if(!x && y) view_angles[1] = view_angles[1] = 180 + floatabs(180 - view_angles[1])
	if(x && !y) view_angles[1] = view_angles[1] = 0 - floatabs(-180 - view_angles[1])
	if(!x && !y) view_angles[1] *= -1

	while(view_angles[1]>180.0) view_angles[1] -= 180
	while(view_angles[1]<-180.0) view_angles[1] += 180
	if(view_angles[1]==180.0 || view_angles[1]==-180.0) view_angles[1]=-179.999999

	view_angles[0] = floatasin(ent2origin[2] / hyp,degrees)

	if(z) view_angles[0] *= -1

	if(floatabs(ent1_angles[0] - view_angles[0]) <= 45.0 && floatabs(ent1_angles[1] - view_angles[1]) <= 45.0)
	{
		hudpos[1] = 1 - ( ( (ent1_angles[0] - view_angles[0]) + 46.4 ) / 90.0 )
		hudpos[0] = ( (ent1_angles[1] - view_angles[1]) + 43.65 ) / 90.0
	}
	else
	{
		return 0;
	}
	return 1;
}


/**********************************************
  Finds "num" amount of players according to
  team and/or alive and stores them into
  closest[33] (1=closest 31=farthest) and
  stores the distance of the player from id
  into Float:distances[33]

  team varaible:
  -2 = same team as id
  -1 = not same team as id
  0 = anyone
  1 = must be on team 1 (in CS would be T)
  2 = must be on team 2 (in CS would be CT)
  3 = must be on team 3 (in CS would be SPEC)
  4 = must be on team 4 (not in CS)
  ...

  alive variable:
  -1 = alive or dead
  0 = must be dead
  1 = must be alive

  returns number of players found that match
  specified team + alive status.

**********************************************/

stock find_closest_players(id,num,team,alive,closest[33],Float:distances[33])
{
	if(!is_user_connected(id))
	{
		return 0;
	}
	static i2, i3, num2
	num2=0
	for(i2=1;i2<=get_maxplayers();i2++)
	{
		static bool:contin
		contin=true
		if(!is_user_connected(i2) || i2==id) contin=false
		if(contin)
		{
			switch(alive)
			{
				case 0: if(is_user_alive(i2)) contin=false
				case 1: if(!is_user_alive(i2)) contin=false
			}
		}
		if(contin)
		{
			switch(team)
			{
				case -2: if(get_user_team(i2) != get_user_team(id)) contin=false
				case -1: if(get_user_team(i2) == get_user_team(id)) contin=false
				default: if(team && get_user_team(i2) != team) contin=false
			}
		}
		if(contin) num2++
	}
	if(num2>num) num2 = num
	for(i2=1;i2<=num;i2++)
	{
		closest[i2]=0
		distances[i2] = 999999.0
		for(i3=1;i3<=get_maxplayers();i3++)
		{
			if(is_user_alive(i3) && get_user_team(i3) != get_user_team(id) && i3!=closest[i2-1] && i3!=id)
			{
				static Float:distance2
				distance2 = float(get_entity_distance(id,i3))
				if(distance2<distances[i2])
				{
					closest[i2] = i3
					distances[i2] = distance2
				}
			}
		}
	}
	return num2;
}


/*******************************************
  Sets ent1's velocity to an average of
  Float:speed and into the direction of
  ent2's origin with offset Float:offset[3]
*******************************************/

stock set_velocity2(ent1,ent2,Float:speed,Float:offset[3])
{
	if(!is_valid_ent(ent1) || !is_valid_ent(ent2))
	{
		return 0;
	}

	static Float:ent1origin[3]
	static Float:ent2origin[3]

	entity_get_vector(ent1,EV_VEC_origin,ent1origin)
	entity_get_vector(ent2,EV_VEC_origin,ent2origin)

	static Float:ent2_angles[3]
	entity_get_vector(ent2,EV_VEC_v_angle,ent2_angles)
	ent2origin[0] += offset[0] * (((floatabs(ent2_angles[1]) - 90) / 90) * -1)
	ent2origin[1] += offset[1] * (1 - (floatabs(90 - floatabs(ent2_angles[1])) / 90))
	ent2origin[2] += offset[2]

	ent2origin[0] -= ent1origin[0]
	ent2origin[1] -= ent1origin[1]
	ent2origin[2] -= ent1origin[2]

	static x, y, z

	x=1, y=1, z=1

	if(ent2origin[0]<0) x=-1, ent2origin[0] *= -1
	if(ent2origin[1]<0) y=-1, ent2origin[1] *= -1
	if(ent2origin[2]<0) z=-1, ent2origin[2] *= -1

	static Float:total

	total = ent2origin[0] + ent2origin[1] + ent2origin[2]

	static Float:newspeed[3]

	newspeed[0] = (ent2origin[0] / total) * speed * x
	newspeed[1] = (ent2origin[1] / total) * speed * y
	newspeed[2] = (ent2origin[2] / total) * speed * z

	set_user_velocity(ent1,newspeed)

	return 1;
}


/*********************************************
  Sets ent's speed in the direction specified
  by the mode variable

  Modes:
   0  = In direction ent is currently moving
  -1  = In direction ent is currently looking
  -2  = In direction ent is currently looking
        but not including the z axis
  ent = In the direction of an entity


  Use a negative speed to go in the opposite
  direction of the specified mode.

*********************************************/

stock set_speed(ent,Float:speed,mode=0)
{
	if(!is_valid_ent(ent))
	{
		return 0;
	}
	if(mode==0)
	{
		static Float:cur_velo[3]

		entity_get_vector(ent,EV_VEC_velocity,cur_velo)

		static Float:y
		y = cur_velo[0]*cur_velo[0] + cur_velo[1]*cur_velo[1] + cur_velo[2]*cur_velo[2]

		static Float:x
		x = floatsqroot(speed*speed / y)

		cur_velo[0] *= x
		cur_velo[1] *= x
		cur_velo[2] *= x

		if(speed<0.0)
		{
			cur_velo[0] *= -1
			cur_velo[1] *= -1
			cur_velo[2] *= -1
		}

		entity_set_vector(ent,EV_VEC_velocity,cur_velo)
	}
	else if(mode==-1)
	{
		static Float:vangle[3]
		if(ent<=get_maxplayers()) entity_get_vector(ent,EV_VEC_v_angle,vangle)
		else entity_get_vector(ent,EV_VEC_angles,vangle)

		static Float:new_velo[3]

		angle_vector(vangle,1,new_velo)

		static Float:y
		y = new_velo[0]*new_velo[0] + new_velo[1]*new_velo[1] + new_velo[2]*new_velo[2]

		static Float:x
		x = floatsqroot(speed*speed / y)

		new_velo[0] *= x
		new_velo[1] *= x
		new_velo[2] *= x

		if(speed<0.0)
		{
			new_velo[0] *= -1
			new_velo[1] *= -1
			new_velo[2] *= -1
		}

		entity_set_vector(ent,EV_VEC_velocity,new_velo)
	}
	else if(mode==-2)
	{
		static Float:vangle[3]
		if(ent<=get_maxplayers()) entity_get_vector(ent,EV_VEC_v_angle,vangle)
		else entity_get_vector(ent,EV_VEC_angles,vangle)

		static Float:new_velo[3]

		entity_get_vector(ent,EV_VEC_velocity,new_velo)

		angle_vector(vangle,1,new_velo)

		static Float:y
		y = new_velo[0]*new_velo[0] + new_velo[1]*new_velo[1]

		static Float:x
		x = floatsqroot(speed*speed / y)

		new_velo[0] *= x
		new_velo[1] *= x

		if(speed<0.0)
		{
			new_velo[0] *= -1
			new_velo[1] *= -1
		}

		entity_set_vector(ent,EV_VEC_velocity,new_velo)
	}
	else
	{
		if(!is_valid_ent(mode) || ent==mode)
		{
			return 0;
		}
		static Float:origin1[3]
		entity_get_vector(ent,EV_VEC_origin,origin1)

		static Float:origin2[3]
		entity_get_vector(mode,EV_VEC_origin,origin1)

		static Float:new_velo[3]

		new_velo[0] = origin2[0] - origin1[0]
		new_velo[1] = origin2[1] - origin1[1]
		new_velo[2] = origin2[2] - origin1[2]

		static Float:y
		y = new_velo[0]*new_velo[0] + new_velo[1]*new_velo[1] + new_velo[2]*new_velo[2]

		static Float:x
		x = floatsqroot(speed*speed / y)

		new_velo[0] *= x
		new_velo[1] *= x
		new_velo[2] *= x

		if(speed<0.0)
		{
			new_velo[0] *= -1
			new_velo[1] *= -1
			new_velo[2] *= -1
		}

		entity_set_vector(ent,EV_VEC_velocity,new_velo)
	}
	return 1;
}


#if defined use_fakemeta
stock entity_get_vector(ent,key,Float:vector[3])
{
	if(key==EV_VEC_origin) return pev(ent,pev_origin,vector);
	if(key==EV_VEC_velocity) return pev(ent,pev_velocity,vector);
	if(key==EV_VEC_angles) return pev(ent,pev_angles,vector);
	if(key==EV_VEC_v_angle) return pev(ent,pev_v_angle,vector);
}

stock entity_set_vector(ent,key,Float:vector[3])
{
	if(key==EV_VEC_origin) return set_pev(ent,pev_origin,vector);
	if(key==EV_VEC_velocity) return set_pev(ent,pev_velocity,vector);
	if(key==EV_VEC_angles) return set_pev(ent,pev_angles,vector);
	if(key==EV_VEC_v_angle) return set_pev(ent,pev_v_angle,vector);
}

stock IVecFVec(ivec[3],Float:fvec[3])
{
	fvec[0] = float(ivec[0])
	fvec[1] = float(ivec[1])
	fvec[2] = float(ivec[2])
}

stock FVecIVec(Float:fvec[3],ivec[3])
{
	ivec[0] = floatround(fvec[0])
	ivec[1] = floatround(fvec[1])
	ivec[2] = floatround(fvec[2])
}

stock get_entity_distance(ent1,ent2)
{
	static Float:origin1[3]
	static Float:origin2[3]
	pev(ent1,pev_origin,origin1)
	pev(ent2,pev_origin,origin2)

	return floatround( floatsqroot( (origin1[0]-origin2[0])*(origin1[0]-origin2[0]) +  (origin1[1]-origin2[1])*(origin1[1]-origin2[1]) +  (origin1[2]-origin2[2])*(origin1[2]-origin2[2]) ) );
}

stock entity_set_int(ent,key,value)
{
	if(key==EV_INT_fixangle) return set_pev(ent,pev_fixangle,value);
}

stock angle_vector(Float:vangle[3],FRU,Float:velo[3])
{
	return engfunc(EngFunc_AngleVectors,vangle,velo[0],velo[1],velo[2]);
}
#endif