rendered paste body/* 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