[inchis] Mici Modificari La Niste Pluginuri

Categoria cu cereri de pluginuri si nu numai.

Moderators: Moderatori ajutatori, Moderatori, Echipa eXtreamCS.com

Forum rules
Accesează link-ul pentru a putea vedea regulile forumului

Daca doriti sa vi se modifice un plugin, va rugam postati aici .
Locked
johnny96iv
Membru, skill 0
Membru, skill 0
Posts: 34
Joined: 16 Aug 2012, 23:55
Detinator Steam: Nu
CS Status: Bantui!
Detinator server CS: BB.CSLR.RO
Has thanked: 5 times
Contact:

04 Dec 2013, 02:56

dupa cum scrie si in titlu am nevoie de un mic ajutor la modificat niste pluginuri:
1.
sma. | Afiseaza codul
#include <amxmodx>
#include <engine>
#include <fakemeta>
#include <fakemeta_util>
#include <hamsandwich>
#include <cstrike>
#include <xs>

#define PLUGIN "[CSO] LightSaber"
#define VERSION "1.0"
#define AUTHOR "Dias Leon"

/* ===============================
------------ Configs -------------
=================================*/
#define DAMAGE_LIGHTSABER 62
#define DAMAGE_ATTACK 31

#define RADIUS_ON 96
#define RADIUS_OFF 72

#define DRAW_TIME 0.75
#define TURN_TIME 0.5
#define RESET_TIME 1.5

#define ANIMEXT1 "onehanded"
#define ANIMEXT2 "knife"

#define V_MODEL "models/v_sfsword.mdl"
#define P_MODEL_ON "models/p_sfsword_on.mdl"
#define P_MODEL_OFF "models/p_sfsword_off.mdl"

new const LightSaber_Sounds[14][] =
{
	"weapons/sfsword_draw.wav",
	"weapons/sfsword_hit1.wav",
	"weapons/sfsword_hit2.wav",
	"weapons/sfsword_idle.wav",
	"weapons/sfsword_midslash1.wav",
	"weapons/sfsword_midslash2.wav",
	"weapons/sfsword_midslash3.wav",
	"weapons/sfsword_off.wav",
	"weapons/sfsword_off_hit.wav",
	"weapons/sfsword_off_slash1.wav",
	"weapons/sfsword_on.wav", // 10
	"weapons/sfsword_stab.wav",
	"weapons/sfsword_wall1.wav",
	"weapons/sfsword_wall2.wav"
}

enum
{
	LS_ANIM_IDLE_ON = 0,
	LS_ANIM_ON,
	LS_ANIM_OFF,
	LS_ANIM_DRAW,
	LS_ANIM_STAB,
	LS_ANIM_STAB_MISS,
	LS_ANIM_MIDSLASH1,
	LS_ANIM_MIDSLASH2,
	LS_ANIM_MIDSLASH3,
	LS_ANIM_IDLE_OFF,
	LS_ANIM_SLASH_OFF
}

/* ===============================
--------- End of Config ----------
=================================*/

#define CSW_LIGHTSABER CSW_KNIFE
#define weapon_lightsaber "weapon_knife"

#define TASK_TURN 4234234
#define TASK_SLASH 6948638
#define TASK_RESET 54893534

// MACROS
#define Get_BitVar(%1,%2) (%1 & (1 << (%2 & 31)))
#define Set_BitVar(%1,%2) %1 |= (1 << (%2 & 31))
#define UnSet_BitVar(%1,%2) %1 &= ~(1 << (%2 & 31))

enum
{
	HIT_NOTHING = 0,
	HIT_ENEMY,
	HIT_WALL
}

enum
{
	ATTACK_SLASH1 = 0,
	ATTACK_SLASH2,
	ATTACK_SLASH3
}

// Vars
new g_Had_LightSaber, g_IsOnMode, g_TempingAttack, g_InSpecialAttack
new g_OldWeapon[33], g_WillBeHit[33], g_AttackingMode[33]
new g_MaxPlayers, g_Ham_Bot

public plugin_init() 
{
	register_plugin(PLUGIN, VERSION, AUTHOR)
	
	register_event("CurWeapon", "Event_CurWeapon", "be", "1=1")
	
	register_forward(FM_CmdStart, "fw_CmdStart")
	register_forward(FM_EmitSound, "fw_EmitSound")
	register_forward(FM_TraceLine, "fw_TraceLine")
	register_forward(FM_TraceHull, "fw_TraceHull")			
	
	RegisterHam(Ham_TraceAttack, "player", "fw_TraceAttack")
	RegisterHam(Ham_Weapon_WeaponIdle, weapon_lightsaber, "fw_Weapon_WeaponIdle_Post", 1)
	g_MaxPlayers = get_maxplayers()
	
	register_clcmd("admin_get_lightsaber", "Get_LightSaber", ADMIN_BAN)
}

public plugin_precache()
{
	engfunc(EngFunc_PrecacheModel, V_MODEL)
	engfunc(EngFunc_PrecacheModel, P_MODEL_ON)
	engfunc(EngFunc_PrecacheModel, P_MODEL_OFF)
	
	for(new i = 0; i < sizeof(LightSaber_Sounds); i++)
		engfunc(EngFunc_PrecacheSound, LightSaber_Sounds)
}

public client_putinserver(id)
{
	Remove_LightSaber(id)

	if(!g_Ham_Bot && is_user_bot(id))
	{
		g_Ham_Bot = 1
		set_task(0.1, "Do_RegisterHam_Bot", id)
	}
}

public Do_RegisterHam_Bot(id)
{
	RegisterHamFromEntity(Ham_TraceAttack, id, "fw_TraceAttack")
}

public Get_LightSaber(id)
{
	if(!is_user_alive(id))
		return
		
	Set_BitVar(g_Had_LightSaber, id)
	Set_BitVar(g_IsOnMode, id)
	UnSet_BitVar(g_TempingAttack, id)
	UnSet_BitVar(g_InSpecialAttack, id)
	g_WillBeHit[id] = HIT_NOTHING
	g_AttackingMode[id] = 0
	
	remove_task(id+TASK_TURN)
	remove_task(id+TASK_SLASH)
	remove_task(id+TASK_RESET)
	
	fm_give_item(id, weapon_lightsaber)
	if(get_user_weapon(id) == CSW_LIGHTSABER)
	{
		set_pev(id, pev_viewmodel2, V_MODEL)
		set_pev(id, pev_weaponmodel2, Get_BitVar(g_IsOnMode, id) ? P_MODEL_ON : P_MODEL_OFF)	

		set_player_nextattack(id, DRAW_TIME)
		set_weapons_timeidle(id, CSW_LIGHTSABER, DRAW_TIME + 0.5)
		
		set_weapon_anim(id, LS_ANIM_DRAW)
	} else {
		engclient_cmd(id, weapon_lightsaber)
	}
}

public Remove_LightSaber(id)
{
	UnSet_BitVar(g_Had_LightSaber, id)
	UnSet_BitVar(g_IsOnMode, id)
	UnSet_BitVar(g_TempingAttack, id)
	UnSet_BitVar(g_InSpecialAttack, id)
	g_WillBeHit[id] = HIT_NOTHING
	g_AttackingMode[id] = 0
	
	remove_task(id+TASK_TURN)
	remove_task(id+TASK_SLASH)
	remove_task(id+TASK_RESET)
}

public Event_CurWeapon(id)
{
	if(!is_user_alive(id))
		return
	static CSWID; CSWID = read_data(2)
	
	if((CSWID == CSW_LIGHTSABER && g_OldWeapon[id] != CSW_LIGHTSABER) && Get_BitVar(g_Had_LightSaber, id))
	{
		set_pev(id, pev_viewmodel2, V_MODEL)
		set_pev(id, pev_weaponmodel2, Get_BitVar(g_IsOnMode, id) ? P_MODEL_ON : P_MODEL_OFF)
		
		set_player_nextattack(id, DRAW_TIME)
		set_weapons_timeidle(id, CSW_LIGHTSABER, DRAW_TIME + 0.5)
		
		set_weapon_anim(id, LS_ANIM_DRAW)
		set_pdata_string(id, (492) * 4, ANIMEXT1, -1 , 20)
	} else if(CSWID != CSW_LIGHTSABER && g_OldWeapon[id] == CSW_LIGHTSABER) {
		g_AttackingMode[id] = 0
		
		Set_BitVar(g_IsOnMode, id)
		UnSet_BitVar(g_InSpecialAttack, id)
		
		remove_task(id+TASK_TURN)
	}
	
	g_OldWeapon[id] = CSWID
}

public fw_EmitSound(id, channel, const sample[], Float:volume, Float:attn, flags, pitch)
{
	if(!is_user_connected(id))
		return FMRES_IGNORED
	if(get_user_weapon(id) != CSW_LIGHTSABER || !Get_BitVar(g_Had_LightSaber, id))
		return FMRES_IGNORED
		
	if(sample[8] == 'k' && sample[9] == 'n' && sample[10] == 'i')
	{
		if(sample[14] == 's' && sample[15] == 'l' && sample[16] == 'a')
		{
			g_WillBeHit[id] = HIT_NOTHING
			return FMRES_SUPERCEDE
		}
		if (sample[14] == 'h' && sample[15] == 'i' && sample[16] == 't')
		{
			if (sample[17] == 'w') // wall
			{
				g_WillBeHit[id] = HIT_WALL
				return FMRES_SUPERCEDE
			} else {
				g_WillBeHit[id] = HIT_ENEMY
				return FMRES_SUPERCEDE
			}
		}
		if (sample[14] == 's' && sample[15] == 't' && sample[16] == 'a')
			return FMRES_SUPERCEDE;
	}
	
	return FMRES_IGNORED
}

public fw_CmdStart(id, uc_handle, seed)
{
	if(!is_user_alive(id)) 
		return
	if(get_user_weapon(id) != CSW_LIGHTSABER || !Get_BitVar(g_Had_LightSaber, id))
		return
	
	static ent; ent = fm_get_user_weapon_entity(id, CSW_LIGHTSABER)
	if(!pev_valid(ent))
		return
	if(get_pdata_float(id, 83, 5) > 0.0) 
		return
	
	static CurButton; CurButton = get_uc(uc_handle, UC_Buttons)
	if(CurButton & IN_ATTACK)
	{
		CurButton &= ~IN_ATTACK
		set_uc(uc_handle, UC_Buttons, CurButton)
		
		if(Get_BitVar(g_IsOnMode, id))
		{
			if(!Get_BitVar(g_InSpecialAttack, id))
			{
				if(g_AttackingMode[id] == 0) g_AttackingMode[id] = 1
				
				g_AttackingMode[id]++
				if(g_AttackingMode[id] > ATTACK_SLASH3) g_AttackingMode[id] = 1
				
				set_pdata_string(id, (492) * 4, ANIMEXT2, -1 , 20)
					
				Set_BitVar(g_TempingAttack, id)
				ExecuteHamB(Ham_Weapon_PrimaryAttack, ent)
				UnSet_BitVar(g_TempingAttack, id)
				
				set_weapons_timeidle(id, CSW_LIGHTSABER, 1.0)
				set_player_nextattack(id, 1.0)
				
				if(g_AttackingMode[id] == 1) set_weapon_anim(id, LS_ANIM_MIDSLASH1)
				else if(g_AttackingMode[id] == 2) set_weapon_anim(id, LS_ANIM_MIDSLASH2)
				else if(g_AttackingMode[id] == 3) set_weapon_anim(id, LS_ANIM_MIDSLASH3)
				
				set_task(0.25, "Damage_Slash", id+TASK_SLASH)
				set_task(RESET_TIME, "Reset_Anim", id+TASK_RESET)
				Set_BitVar(g_InSpecialAttack, id)
			} else {
				set_pdata_string(id, (492) * 4, ANIMEXT2, -1 , 20)
					
				Set_BitVar(g_TempingAttack, id)
				ExecuteHamB(Ham_Weapon_PrimaryAttack, ent)
				UnSet_BitVar(g_TempingAttack, id)
				
				set_weapons_timeidle(id, CSW_LIGHTSABER, 1.0)
				set_player_nextattack(id, 1.0)
				
				set_weapon_anim(id, LS_ANIM_STAB)
				
				set_task(0.25, "Damage_Stab", id+TASK_SLASH)
				set_task(0.5, "Damage_Stab", id+TASK_SLASH)
				set_task(RESET_TIME, "Reset_Anim", id+TASK_RESET)
				UnSet_BitVar(g_InSpecialAttack, id)
			}
		} else {
			set_pdata_string(id, (492) * 4, ANIMEXT2, -1 , 20)
					
			Set_BitVar(g_TempingAttack, id)
			ExecuteHamB(Ham_Weapon_PrimaryAttack, ent)
			UnSet_BitVar(g_TempingAttack, id)
			
			set_weapons_timeidle(id, CSW_LIGHTSABER, 1.0)
			set_player_nextattack(id, 1.0)
			
			set_weapon_anim(id, LS_ANIM_SLASH_OFF)
			set_task(0.25, "Damage_OffStab", id+TASK_SLASH)
			set_task(RESET_TIME, "Reset_Anim", id+TASK_RESET)
			
			UnSet_BitVar(g_InSpecialAttack, id)
		}
	} else if(CurButton & IN_ATTACK2) {
		CurButton &= ~IN_ATTACK2
		set_uc(uc_handle, UC_Buttons, CurButton)
		
		set_weapon_anim(id, !Get_BitVar(g_IsOnMode, id) ? LS_ANIM_ON : LS_ANIM_OFF)
		
		set_player_nextattack(id, TURN_TIME)
		set_weapons_timeidle(id, CSW_LIGHTSABER, TURN_TIME)
		
		set_task(TURN_TIME - 0.1, "Turn_Complete", id+TASK_TURN)
	}
}

public Turn_Complete(id)
{
	id -= TASK_TURN
	if(!is_user_alive(id)) 
		return
	if(get_user_weapon(id) != CSW_LIGHTSABER || !Get_BitVar(g_Had_LightSaber, id))
		return
		
	if(Get_BitVar(g_IsOnMode, id)) UnSet_BitVar(g_IsOnMode, id)
	else Set_BitVar(g_IsOnMode, id)	
	
	set_pev(id, pev_weaponmodel2, Get_BitVar(g_IsOnMode, id) ? P_MODEL_ON : P_MODEL_OFF)
	set_pdata_string(id, (492) * 4, Get_BitVar(g_IsOnMode, id) ? ANIMEXT1 : ANIMEXT2, -1 , 20)
}

public Reset_Anim(id)
{
	id -= TASK_RESET
	if(!is_user_alive(id)) 
		return
	if(get_user_weapon(id) != CSW_LIGHTSABER || !Get_BitVar(g_Had_LightSaber, id))
		return
		
	set_pdata_string(id, (492) * 4, Get_BitVar(g_IsOnMode, id) ? ANIMEXT1 : ANIMEXT2, -1 , 20)
}

public Damage_Slash(id)
{
	id -= TASK_SLASH
	if(!is_user_alive(id)) 
		return
	if(get_user_weapon(id) != CSW_LIGHTSABER || !Get_BitVar(g_Had_LightSaber, id))
		return
		
	static Target; Target = CheckAttack(id, float(RADIUS_ON), 48.0, float(DAMAGE_LIGHTSABER))
	if(Target) emit_sound(id, CHAN_WEAPON, LightSaber_Sounds[random_num(1, 2)], 1.0, ATTN_NORM, 0, PITCH_NORM)
	else if(g_WillBeHit[id] == HIT_WALL) emit_sound(id, CHAN_WEAPON, LightSaber_Sounds[random_num(12, 13)], 1.0, ATTN_NORM, 0, PITCH_NORM)
}

public Damage_Stab(id)
{
	id -= TASK_SLASH
	if(!is_user_alive(id)) 
		return
	if(get_user_weapon(id) != CSW_LIGHTSABER || !Get_BitVar(g_Had_LightSaber, id))
		return
		
	static Target; Target = CheckAttack(id, float(RADIUS_ON), 48.0, float(DAMAGE_LIGHTSABER))
	if(Target) emit_sound(id, CHAN_WEAPON, LightSaber_Sounds[random_num(1, 2)], 1.0, ATTN_NORM, 0, PITCH_NORM)
	else if(g_WillBeHit[id] == HIT_WALL) emit_sound(id, CHAN_WEAPON, LightSaber_Sounds[random_num(12, 13)], 1.0, ATTN_NORM, 0, PITCH_NORM)
}

public Damage_OffStab(id)
{
	id -= TASK_SLASH
	if(!is_user_alive(id)) 
		return
	if(get_user_weapon(id) != CSW_LIGHTSABER || !Get_BitVar(g_Had_LightSaber, id))
		return
		
	static Ent; Ent = fm_get_user_weapon_entity(id, get_user_weapon(id))
	if(!pev_valid(Ent)) Ent = 0
	
	static Target; Target = CheckAttack(id, float(RADIUS_OFF), 24.0, float(DAMAGE_ATTACK))
	if(Target) emit_sound(id, CHAN_WEAPON, LightSaber_Sounds[8], 1.0, ATTN_NORM, 0, PITCH_NORM)
}

public CheckAttack(id, Float:Radius, Float:PointDis, Float:Damage)
{
	static Float:Max_Distance, Float:Point[4][3], Float:TB_Distance, Float:Point_Dis
	
	Point_Dis = PointDis
	Max_Distance = Radius
	TB_Distance = Max_Distance / 4.0
	
	static Float:VicOrigin[3], Float:MyOrigin[3]
	pev(id, pev_origin, MyOrigin)
	
	for(new i = 0; i < 4; i++) get_position(id, TB_Distance * (i + 1), 0.0, 0.0, Point)
		
	static Have_Victim; Have_Victim = 0
	static ent; ent = fm_get_user_weapon_entity(id, get_user_weapon(id))
		
	if(!pev_valid(ent))
		return 0
		
	for(new i = 0; i < g_MaxPlayers; i++)
	{
		if(!is_user_alive(i))
			continue
		if(id == i)
			continue
		if(entity_range(id, i) > Max_Distance)
			continue
	
		pev(i, pev_origin, VicOrigin)
		if(is_wall_between_points(MyOrigin, VicOrigin, id))
			continue
			
		if(get_distance_f(VicOrigin, Point[0]) <= Point_Dis
		|| get_distance_f(VicOrigin, Point[1]) <= Point_Dis
		|| get_distance_f(VicOrigin, Point[2]) <= Point_Dis
		|| get_distance_f(VicOrigin, Point[3]) <= Point_Dis)
		{
			if(!Have_Victim) Have_Victim = 1
			do_attack(id, i, ent, Damage)
		}
	}	
	
	if(Have_Victim) return 1
	return 0
}	

public fw_TraceLine(Float:vector_start[3], Float:vector_end[3], ignored_monster, id, handle)
{
	if(!is_user_alive(id))
		return FMRES_IGNORED	
	if(get_user_weapon(id) != CSW_LIGHTSABER || !Get_BitVar(g_Had_LightSaber, id))
		return FMRES_IGNORED
	
	static Float:vecStart[3], Float:vecEnd[3], Float:v_angle[3], Float:v_forward[3], Float:view_ofs[3], Float:fOrigin[3]
	
	pev(id, pev_origin, fOrigin)
	pev(id, pev_view_ofs, view_ofs)
	xs_vec_add(fOrigin, view_ofs, vecStart)
	pev(id, pev_v_angle, v_angle)
	
	engfunc(EngFunc_MakeVectors, v_angle)
	get_global_vector(GL_v_forward, v_forward)

	if(Get_BitVar(g_TempingAttack, id)) xs_vec_mul_scalar(v_forward, (Get_BitVar(g_IsOnMode, id) ? float(RADIUS_ON) : float(RADIUS_OFF)), v_forward)
	else xs_vec_mul_scalar(v_forward, 0.0, v_forward)
	xs_vec_add(vecStart, v_forward, vecEnd)
	
	engfunc(EngFunc_TraceLine, vecStart, vecEnd, ignored_monster, id, handle)
	
	return FMRES_SUPERCEDE
}

public fw_TraceHull(Float:vector_start[3], Float:vector_end[3], ignored_monster, hull, id, handle)
{
	if(!is_user_alive(id))
		return FMRES_IGNORED	
	if(get_user_weapon(id) != CSW_LIGHTSABER || !Get_BitVar(g_Had_LightSaber, id))
		return FMRES_IGNORED
	
	static Float:vecStart[3], Float:vecEnd[3], Float:v_angle[3], Float:v_forward[3], Float:view_ofs[3], Float:fOrigin[3]
	
	pev(id, pev_origin, fOrigin)
	pev(id, pev_view_ofs, view_ofs)
	xs_vec_add(fOrigin, view_ofs, vecStart)
	pev(id, pev_v_angle, v_angle)
	
	engfunc(EngFunc_MakeVectors, v_angle)
	get_global_vector(GL_v_forward, v_forward)
	
	if(Get_BitVar(g_TempingAttack, id)) xs_vec_mul_scalar(v_forward, (Get_BitVar(g_IsOnMode, id) ? float(RADIUS_ON) : float(RADIUS_OFF)), v_forward)
	else xs_vec_mul_scalar(v_forward, 0.0, v_forward)
	xs_vec_add(vecStart, v_forward, vecEnd)
	
	engfunc(EngFunc_TraceHull, vecStart, vecEnd, ignored_monster, hull, id, handle)
	
	return FMRES_SUPERCEDE
}

public fw_TraceAttack(Victim, Attacker, Float:Damage, Float:Direction[3], TraceResult, DamageBits) 
{
	if(!is_user_alive(Attacker))	
		return HAM_IGNORED
	if(!Get_BitVar(g_Had_LightSaber, Attacker) || !Get_BitVar(g_TempingAttack, Attacker))
		return HAM_IGNORED
		
	return HAM_SUPERCEDE
}

public fw_Weapon_WeaponIdle_Post(ent)
{
	static id; id = pev(ent, pev_owner)
	if(!is_user_alive(id))
		return HAM_IGNORED
	if(!Get_BitVar(g_Had_LightSaber, id))
		return HAM_IGNORED
		
	if(get_pdata_float(ent, 48, 4) <= 0.25) 
	{
		set_weapon_anim(id, Get_BitVar(g_IsOnMode, id) ? LS_ANIM_IDLE_ON : LS_ANIM_IDLE_OFF)
		set_pdata_float(ent, 48, 20.0, 4)
	}
	
	return HAM_IGNORED
}

stock is_wall_between_points(Float:start[3], Float:end[3], ignore_ent)
{
	static pentru
	pentru = create_tr2()

	engfunc(EngFunc_TraceLine, start, end, IGNORE_MONSTERS, ignore_ent, pentru)
	
	static Float:EndPos[3]
	get_tr2(pentru, TR_vecEndPos, EndPos)

	free_tr2(pentru)
	return floatround(get_distance_f(end, EndPos))
} 

do_attack(Attacker, Victim, Inflictor, Float:fDamage)
{
	fake_player_trace_attack(Attacker, Victim, fDamage)
	fake_take_damage(Attacker, Victim, fDamage, Inflictor)
}

fake_player_trace_attack(iAttacker, iVictim, &Float:fDamage)
{
	// get fDirection
	static Float:fAngles[3], Float:fDirection[3]
	pev(iAttacker, pev_angles, fAngles)
	angle_vector(fAngles, ANGLEVECTOR_FORWARD, fDirection)
	
	// get fStart
	static Float:fStart[3], Float:fViewOfs[3]
	pev(iAttacker, pev_origin, fStart)
	pev(iAttacker, pev_view_ofs, fViewOfs)
	xs_vec_add(fViewOfs, fStart, fStart)
	
	// get aimOrigin
	static iAimOrigin[3], Float:fAimOrigin[3]
	get_user_origin(iAttacker, iAimOrigin, 3)
	IVecFVec(iAimOrigin, fAimOrigin)
	
	// TraceLine from fStart to AimOrigin
	static pentru; pentru = create_tr2() 
	engfunc(EngFunc_TraceLine, fStart, fAimOrigin, DONT_IGNORE_MONSTERS, iAttacker, pentru)
	static pHit; pHit = get_tr2(pentru, TR_pHit)
	static iHitgroup; iHitgroup = get_tr2(pentru, TR_iHitgroup)
	static Float:fEndPos[3]; get_tr2(pentru, TR_vecEndPos, fEndPos)

	// get target & body at aiming
	static iTarget, iBody
	get_user_aiming(iAttacker, iTarget, iBody)
	
	// if aiming find target is iVictim then update iHitgroup
	if (iTarget == iVictim)
	{
		iHitgroup = iBody
	}
	
	// if pentru find target not is iVictim
	else if (pHit != iVictim)
	{
		// get AimOrigin in iVictim
		static Float:fVicOrigin[3], Float:fVicViewOfs[3], Float:fAimInVictim[3]
		pev(iVictim, pev_origin, fVicOrigin)
		pev(iVictim, pev_view_ofs, fVicViewOfs) 
		xs_vec_add(fVicViewOfs, fVicOrigin, fAimInVictim)
		fAimInVictim[2] = fStart[2]
		fAimInVictim[2] += get_distance_f(fStart, fAimInVictim) * floattan( fAngles[0] * 2.0, degrees )
		
		// check aim in size of iVictim
		static iAngleToVictim; iAngleToVictim = get_angle_to_target(iAttacker, fVicOrigin)
		iAngleToVictim = abs(iAngleToVictim)
		static Float:fDis; fDis = 2.0 * get_distance_f(fStart, fAimInVictim) * floatsin( float(iAngleToVictim) * 0.5, degrees )
		static Float:fVicSize[3]
		pev(iVictim, pev_size , fVicSize)
		if ( fDis <= fVicSize[0] * 0.5 )
		{
			// TraceLine from fStart to aimOrigin in iVictim
			static ptr2; ptr2 = create_tr2() 
			engfunc(EngFunc_TraceLine, fStart, fAimInVictim, DONT_IGNORE_MONSTERS, iAttacker, ptr2)
			static pHit2; pHit2 = get_tr2(ptr2, TR_pHit)
			static iHitgroup2; iHitgroup2 = get_tr2(ptr2, TR_iHitgroup)
			
			// if ptr2 find target is iVictim
			if ( pHit2 == iVictim && (iHitgroup2 != HIT_HEAD || fDis <= fVicSize[0] * 0.25) )
			{
				pHit = iVictim
				iHitgroup = iHitgroup2
				get_tr2(ptr2, TR_vecEndPos, fEndPos)
			}
			
			free_tr2(ptr2)
		}
		
		// if pHit still not is iVictim then set default HitGroup
		if (pHit != iVictim)
		{
			// set default iHitgroup
			iHitgroup = HIT_GENERIC
			
			static ptr3; ptr3 = create_tr2() 
			engfunc(EngFunc_TraceLine, fStart, fVicOrigin, DONT_IGNORE_MONSTERS, iAttacker, ptr3)
			get_tr2(ptr3, TR_vecEndPos, fEndPos)
			
			// free ptr3
			free_tr2(ptr3)
		}
	}
	
	// set new Hit & Hitgroup & EndPos
	set_tr2(pentru, TR_pHit, iVictim)
	set_tr2(pentru, TR_iHitgroup, iHitgroup)
	set_tr2(pentru, TR_vecEndPos, fEndPos)

	// hitgroup multi fDamage
	static Float:fMultifDamage 
	switch(iHitgroup)
	{
		case HIT_HEAD: fMultifDamage  = 4.0
		case HIT_STOMACH: fMultifDamage  = 1.25
		case HIT_LEFTLEG: fMultifDamage  = 0.75
		case HIT_RIGHTLEG: fMultifDamage  = 0.75
		default: fMultifDamage  = 1.0
	}
	
	fDamage *= fMultifDamage
	
	// ExecuteHam
	fake_trake_attack(iAttacker, iVictim, fDamage, fDirection, pentru)
	
	// free pentru
	free_tr2(pentru)
}

stock fake_trake_attack(iAttacker, iVictim, Float:fDamage, Float:fDirection[3], iTraceHandle, iDamageBit = (DMG_NEVERGIB | DMG_BULLET))
{
	ExecuteHamB(Ham_TraceAttack, iVictim, iAttacker, fDamage, fDirection, iTraceHandle, iDamageBit)
}

stock fake_take_damage(iAttacker, iVictim, Float:fDamage, iInflictor = 0, iDamageBit = (DMG_NEVERGIB | DMG_BULLET))
{
	ExecuteHamB(Ham_TakeDamage, iVictim, iInflictor, iAttacker, fDamage, iDamageBit)
}

stock get_angle_to_target(id, const Float:fTarget[3], Float:TargetSize = 0.0)
{
	static Float:fOrigin[3], iAimOrigin[3], Float:fAimOrigin[3], Float:fV1[3]
	pev(id, pev_origin, fOrigin)
	get_user_origin(id, iAimOrigin, 3) // end position from eyes
	IVecFVec(iAimOrigin, fAimOrigin)
	xs_vec_sub(fAimOrigin, fOrigin, fV1)
	
	static Float:fV2[3]
	xs_vec_sub(fTarget, fOrigin, fV2)
	
	static iResult; iResult = get_angle_between_vectors(fV1, fV2)
	
	if (TargetSize > 0.0)
	{
		static Float:fTan; fTan = TargetSize / get_distance_f(fOrigin, fTarget)
		static fAngleToTargetSize; fAngleToTargetSize = floatround( floatatan(fTan, degrees) )
		iResult -= (iResult > 0) ? fAngleToTargetSize : -fAngleToTargetSize
	}
	
	return iResult
}

stock get_angle_between_vectors(const Float:fV1[3], const Float:fV2[3])
{
	static Float:fA1[3], Float:fA2[3]
	engfunc(EngFunc_VecToAngles, fV1, fA1)
	engfunc(EngFunc_VecToAngles, fV2, fA2)
	
	static iResult; iResult = floatround(fA1[1] - fA2[1])
	iResult = iResult % 360
	iResult = (iResult > 180) ? (iResult - 360) : iResult
	
	return iResult
}

stock get_position(ent, Float:forw, Float:right, Float:up, Float:vStart[])
{
	static Float:vOrigin[3], Float:vAngle[3], Float:vForward[3], Float:vRight[3], Float:vUp[3]
	
	pev(ent, pev_origin, vOrigin)
	pev(ent, pev_view_ofs,vUp) //for player
	xs_vec_add(vOrigin,vUp,vOrigin)
	pev(ent, pev_v_angle, vAngle) // if normal entity ,use pev_angles
	
	angle_vector(vAngle,ANGLEVECTOR_FORWARD,vForward) //or use EngFunc_AngleVectors
	angle_vector(vAngle,ANGLEVECTOR_RIGHT,vRight)
	angle_vector(vAngle,ANGLEVECTOR_UP,vUp)
	
	vStart[0] = vOrigin[0] + vForward[0] * forw + vRight[0] * right + vUp[0] * up
	vStart[1] = vOrigin[1] + vForward[1] * forw + vRight[1] * right + vUp[1] * up
	vStart[2] = vOrigin[2] + vForward[2] * forw + vRight[2] * right + vUp[2] * up
}

stock set_weapons_timeidle(id, WeaponId ,Float:TimeIdle)
{
	static entwpn; entwpn = fm_get_user_weapon_entity(id, WeaponId)
	if(!pev_valid(entwpn)) 
		return
		
	set_pdata_float(entwpn, 46, TimeIdle, 4)
	set_pdata_float(entwpn, 47, TimeIdle, 4)
	set_pdata_float(entwpn, 48, TimeIdle + 0.5, 4)
}

stock set_weapon_anim(id, anim)
{
	set_pev(id, pev_weaponanim, anim)
	
	message_begin(MSG_ONE_UNRELIABLE, SVC_WEAPONANIM, _, id)
	write_byte(anim)
	write_byte(0)
	message_end()	
}

stock set_player_nextattack(id, Float:NextTime) set_pdata_float(id, 83, NextTime, 5)
/* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
*{\\ rtf1\\ ansi\\ deff0{\\ fonttbl{\\ f0\\ fnil Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ lang1033\\ f0\\ fs16 \n\\ par }
*/
La fiecare respawn sa se dea acea sabie doar la tero nu si la ct iar dupa ce mori cand esti ct sa nu o mai ai.

2.
sma. | Afiseaza codul
#include <amxmodx>
#include <engine>
#include <fakemeta>
#include <fakemeta_util>
#include <hamsandwich>
#include <cstrike>
#include <xs>

#define PLUGIN "Dragon Sword"
#define VERSION "2.0"
#define AUTHOR "Dias Leon"

#define V_MODEL "models/v_dragonsword2.mdl"
#define P_MODEL "models/p_dragonsword.mdl"

#define CSW_DRAGONSWORD CSW_KNIFE
#define weapon_dragonsword "weapon_knife"
#define WEAPON_ANIMEXT "knife" //"skullaxe"

#define DRAW_TIME 1.0

#define SLASH_ROTATE_DAMAGE 75.0
#define SLASH_ROTATE_RADIUS 110.0
#define SLASH_ROTATE_POINT_DIS 60.0
#define SLASH_ROTATE_DELAY_TIME 0.7
#define SLASH_ROTATE_RESET_TIME 1.0

#define SLASH_AHEAD_DAMAGE 90.0
#define SLASH_AHEAD_RADIUS 90.0
#define SLASH_AHEAD_POINT_DIS 30.0
#define SLASH_AHEAD_DELAY_TIME 0.3
#define SLASH_AHEAD_RESET_TIME 0.9

#define STAB_DAMAGE 110.0
#define STAB_RADIUS 100.0
#define STAB_POINT_DIS 80.0
#define STAB_TIME 0.657
#define STAB_RESET_TIME 0.75

#define TASK_SLASHING 2033+20
#define TASK_STABING 2033+10

// OFFSET
const PDATA_SAFE = 2
const OFFSET_LINUX_WEAPONS = 4
const OFFSET_WEAPONOWNER = 41
const m_flNextAttack = 83
const m_szAnimExtention = 492

new const DragonSword_Sound[8][] = 
{
	"weapons/dragonsword_draw.wav",
	"weapons/dragonsword_hit1.wav",
	"weapons/dragonsword_hit2.wav",
	"weapons/dragonsword_idle.wav",
	"weapons/dragonsword_slash1.wav",
	"weapons/dragonsword_slash2.wav",
	"weapons/dragonsword_stab_hit.wav",
	"weapons/dragonsword_wall.wav"
}

enum
{
	ATTACK_SLASH_ROTATE = 1,
	ATTACK_SLASH_AHEAD,
	ATTACK_STAB
}

enum
{
	DS_ANIM_IDLE = 0,
	DS_ANIM_SLASH_ROTATE,
	DS_ANIM_SLASH_AHEAD,
	DS_ANIM_DRAW,
	DS_ANIM_STAB_BEGIN,
	DS_ANIM_STAB_END
}

enum
{
	HIT_NOTHING = 0,
	HIT_ENEMY,
	HIT_WALL
}

new g_Had_DragonSword[33], g_Slashing_Mode[33], g_Attack_Mode[33], g_Checking_Mode[33], g_Hit_Ing[33]
new g_Old_Weapon[33], g_Ham_Bot, g_MaxPlayers

public plugin_init()
{
	register_plugin(PLUGIN, VERSION, AUTHOR)
	
	register_event("HLTV", "Event_NewRound", "a", "1=0", "2=0")
	register_event("CurWeapon", "Event_CurWeapon", "be", "1=1")
	
	register_forward(FM_EmitSound, "fw_EmitSound")
	register_forward(FM_CmdStart, "fw_CmdStart")
	register_forward(FM_TraceLine, "fw_TraceLine")
	register_forward(FM_TraceHull, "fw_TraceHull")	
	
	RegisterHam(Ham_TraceAttack, "player", "fw_PlayerTraceAttack")
	
	g_MaxPlayers = get_maxplayers()
	register_clcmd("admin_get_dragonsword", "get_dragonsword", ADMIN_KICK)
}

public plugin_precache()
{
	engfunc(EngFunc_PrecacheModel, V_MODEL)
	engfunc(EngFunc_PrecacheModel, P_MODEL)
	
	for(new i = 0; i < sizeof(DragonSword_Sound); i++)
		engfunc(EngFunc_PrecacheSound, DragonSword_Sound)
}

public get_dragonsword(id)
{
	if(!is_user_alive(id))
		return
		
	remove_task(id+TASK_SLASHING)
	remove_task(id+TASK_STABING)
		
	g_Had_DragonSword[id] = 1
	g_Slashing_Mode[id] = 0
	g_Attack_Mode[id] = 0
	g_Checking_Mode[id] = 0
	g_Hit_Ing[id] = 0
	
	if(get_user_weapon(id) == CSW_KNIFE)
	{
		set_pev(id, pev_viewmodel2, V_MODEL)
		set_pev(id, pev_weaponmodel2, P_MODEL)	
		
		set_weapon_anim(id, DS_ANIM_DRAW)
		set_player_nextattack(id, DRAW_TIME)
	} else {
		engclient_cmd(id, weapon_dragonsword)
	}
}

public remove_dragonsword(id)
{
	remove_task(id+TASK_SLASHING)
	remove_task(id+TASK_STABING)
		
	g_Had_DragonSword[id] = 0
	g_Slashing_Mode[id] = 0
	g_Attack_Mode[id] = 0
	g_Checking_Mode[id] = 0
	g_Hit_Ing[id] = 0
}

public client_putinserver(id)
{
	if(!g_Ham_Bot && is_user_bot(id))
	{
		g_Ham_Bot = 1
		set_task(0.1, "Do_RegisterHam_Bot", id)
	}
}

public Do_RegisterHam_Bot(id)
{
	RegisterHamFromEntity(Ham_TraceAttack, id, "fw_PlayerTraceAttack")
}

public Event_NewRound()
{
	for(new i = 0; i < g_MaxPlayers; i++)
		remove_dragonsword(i)
}

public Event_CurWeapon(id)
{
	if(!is_user_alive(id))
		return

	// Problem Here ?. SHUT THE FUCK UP
	if((read_data(2) == CSW_DRAGONSWORD && g_Old_Weapon[id] != CSW_DRAGONSWORD) && g_Had_DragonSword[id])
	{
		set_pev(id, pev_viewmodel2, V_MODEL)
		set_pev(id, pev_weaponmodel2, P_MODEL)
	
		set_weapon_anim(id, DS_ANIM_DRAW)
		set_player_nextattack(id, DRAW_TIME)
		
		set_pdata_string(id, m_szAnimExtention * 4, WEAPON_ANIMEXT, -1 , 20)
	}
		
	g_Old_Weapon[id] = read_data(2)
}

public fw_EmitSound(id, channel, const sample[], Float:volume, Float:attn, flags, pitch)
{
	if(!is_user_connected(id))
		return FMRES_IGNORED
	if(/*get_user_weapon(id) != CSW_DRAGONSWORD || */!g_Had_DragonSword[id])
		return FMRES_IGNORED
		
	if(sample[8] == 'k' && sample[9] == 'n' && sample[10] == 'i')
	{
		if(sample[14] == 's' && sample[15] == 'l' && sample[16] == 'a')
			return FMRES_SUPERCEDE
		if (sample[14] == 'h' && sample[15] == 'i' && sample[16] == 't')
		{
			if (sample[17] == 'w') // wall
			{
				g_Hit_Ing[id] = HIT_WALL
				return FMRES_SUPERCEDE
			} else {
				g_Hit_Ing[id] = HIT_ENEMY
				return FMRES_SUPERCEDE
			}
		}
		if (sample[14] == 's' && sample[15] == 't' && sample[16] == 'a')
			return FMRES_SUPERCEDE;
	}
	
	return FMRES_IGNORED
}

public fw_CmdStart(id, uc_handle, seed)
{
	if (!is_user_alive(id)) 
		return
	if(get_user_weapon(id) != CSW_DRAGONSWORD || !g_Had_DragonSword[id])
		return
	
	static ent; ent = fm_get_user_weapon_entity(id, CSW_DRAGONSWORD)
	
	if(!pev_valid(ent))
		return
	if(get_pdata_float(ent, 46, OFFSET_LINUX_WEAPONS) > 0.0 || get_pdata_float(ent, 47, OFFSET_LINUX_WEAPONS) > 0.0) 
		return
	
	static CurButton
	CurButton = get_uc(uc_handle, UC_Buttons)
	
	if (CurButton & IN_ATTACK)
	{
		set_uc(uc_handle, UC_Buttons, CurButton & ~IN_ATTACK)
		
		if(!g_Slashing_Mode[id])
		{
			g_Attack_Mode[id] = ATTACK_SLASH_ROTATE
			g_Checking_Mode[id] = 1
			ExecuteHamB(Ham_Weapon_PrimaryAttack, ent)
			g_Checking_Mode[id] = 0
	
			set_pev(id, pev_framerate, 1.5)
			set_weapons_timeidle(id, CSW_DRAGONSWORD, SLASH_ROTATE_RESET_TIME)
			set_player_nextattack(id, SLASH_ROTATE_RESET_TIME)
			
			set_weapon_anim(id, DS_ANIM_SLASH_ROTATE)
			set_task(SLASH_ROTATE_DELAY_TIME, "Do_Slashing_Rotate", id+TASK_SLASHING)
		} else {
			g_Attack_Mode[id] = ATTACK_SLASH_AHEAD
			g_Checking_Mode[id] = 1
			ExecuteHamB(Ham_Weapon_PrimaryAttack, ent)
			g_Checking_Mode[id] = 0
			
			set_pev(id, pev_framerate, 2.0)
			set_weapons_timeidle(id, CSW_DRAGONSWORD, SLASH_AHEAD_RESET_TIME)
			set_player_nextattack(id, SLASH_AHEAD_RESET_TIME)
			
			set_weapon_anim(id, DS_ANIM_SLASH_AHEAD)
			set_task(SLASH_AHEAD_DELAY_TIME, "Do_Slashing_Ahead", id+TASK_SLASHING)
		}
		
		g_Slashing_Mode[id] = !g_Slashing_Mode[id]
	} else if (CurButton & IN_ATTACK2) {
		set_uc(uc_handle, UC_Buttons, CurButton & ~IN_ATTACK2)
		
		g_Attack_Mode[id] = ATTACK_STAB
		g_Checking_Mode[id] = 1
		ExecuteHamB(Ham_Weapon_SecondaryAttack, ent)
		g_Checking_Mode[id] = 0
		
		set_pev(id, pev_framerate, 1.5)
		set_weapons_timeidle(id, CSW_DRAGONSWORD, STAB_TIME + 0.1)
		set_player_nextattack(id, STAB_TIME + 0.1)
		
		set_weapon_anim(id, DS_ANIM_STAB_BEGIN)
		
		remove_task(id+TASK_STABING)
		set_task(STAB_TIME, "Do_StabNow", id+TASK_STABING)
	}
}

public Do_Slashing_Rotate(id)
{
	id -= TASK_SLASHING
	
	if(!is_user_alive(id))
		return
	if(get_user_weapon(id) != CSW_DRAGONSWORD || !g_Had_DragonSword[id])
		return
		
	if(Check_Attack(id, ATTACK_SLASH_ROTATE))
	{
		emit_sound(id, CHAN_WEAPON, DragonSword_Sound[1], 1.0, ATTN_NORM, 0, PITCH_NORM)
	} else {
		if(g_Hit_Ing[id] == HIT_WALL) emit_sound(id, CHAN_WEAPON, DragonSword_Sound[7], 1.0, ATTN_NORM, 0, PITCH_NORM)
		else if(g_Hit_Ing[id] == HIT_NOTHING) emit_sound(id, CHAN_WEAPON, DragonSword_Sound[4], 1.0, ATTN_NORM, 0, PITCH_NORM)
	}
	
	g_Attack_Mode[id] = 0
	g_Hit_Ing[id] = 0
}

public Do_Slashing_Ahead(id)
{
	id -= TASK_SLASHING
	
	if(!is_user_alive(id))
		return
	if(get_user_weapon(id) != CSW_DRAGONSWORD || !g_Had_DragonSword[id])
		return
		
	if(Check_Attack(id, ATTACK_SLASH_AHEAD))
	{
		emit_sound(id, CHAN_WEAPON, DragonSword_Sound[2], 1.0, ATTN_NORM, 0, PITCH_NORM)
	} else {
		if(g_Hit_Ing[id] == HIT_WALL) emit_sound(id, CHAN_WEAPON, DragonSword_Sound[7], 1.0, ATTN_NORM, 0, PITCH_NORM)
		else if(g_Hit_Ing[id] == HIT_NOTHING) emit_sound(id, CHAN_WEAPON, DragonSword_Sound[5], 1.0, ATTN_NORM, 0, PITCH_NORM)
	}
	
	g_Attack_Mode[id] = 0
	g_Hit_Ing[id] = 0
}

public Do_StabNow(id)
{
	id -= TASK_STABING
	
	if (!is_user_alive(id)) 
		return
	if(!g_Had_DragonSword[id])
		return		
		
	set_weapon_anim(id, DS_ANIM_STAB_END)
	
	if(get_user_weapon(id) != CSW_DRAGONSWORD)
	{
		set_weapons_timeidle(id, CSW_DRAGONSWORD, 0.0)
		set_player_nextattack(id, 0.0)
	} else {
		set_weapons_timeidle(id, CSW_DRAGONSWORD, STAB_RESET_TIME)
		set_player_nextattack(id, STAB_RESET_TIME)
	}		

	if(Check_Attack(id, ATTACK_STAB))
	{
		emit_sound(id, CHAN_WEAPON, DragonSword_Sound[1], 1.0, ATTN_NORM, 0, PITCH_NORM)
	} else {
		if(g_Hit_Ing[id] == HIT_WALL) emit_sound(id, CHAN_WEAPON, DragonSword_Sound[7], 1.0, ATTN_NORM, 0, PITCH_NORM)
		else if(g_Hit_Ing[id] == HIT_NOTHING) emit_sound(id, CHAN_WEAPON, DragonSword_Sound[6], 1.0, ATTN_NORM, 0, PITCH_NORM)
	}

	g_Attack_Mode[id] = 0
	g_Hit_Ing[id] = 0
}


public Check_Attack(id, Mode)
{
	static Float:Max_Distance, Float:Point[4][3], Float:TB_Distance, Float:Point_Dis
	
	if(Mode == ATTACK_SLASH_ROTATE)
	{
		Point_Dis = SLASH_ROTATE_POINT_DIS
		Max_Distance = SLASH_ROTATE_RADIUS
		TB_Distance = Max_Distance / 4.0
	} else if(Mode == ATTACK_SLASH_AHEAD) {
		Point_Dis = SLASH_AHEAD_POINT_DIS
		Max_Distance = SLASH_AHEAD_RADIUS
		TB_Distance = Max_Distance / 4.0
	} else if(Mode == ATTACK_STAB) {
		Point_Dis = STAB_POINT_DIS
		Max_Distance = STAB_RADIUS
		TB_Distance = Max_Distance / 4.0
	}
	
	static Float:VicOrigin[3], Float:MyOrigin[3]
	pev(id, pev_origin, MyOrigin)
	
	for(new i = 0; i < 4; i++)
		get_position(id, TB_Distance * (i + 1), 0.0, 0.0, Point)
		
	static Have_Victim; Have_Victim = 0
	static ent
	ent = fm_get_user_weapon_entity(id, get_user_weapon(id))
		
	if(!pev_valid(ent))
		return 0
		
	for(new i = 0; i < get_maxplayers(); i++)
	{
		if(!is_user_alive(i))
			continue
		if(id == i)
			continue
		if(entity_range(id, i) > Max_Distance)
			continue
	
		pev(i, pev_origin, VicOrigin)
		if(is_wall_between_points(MyOrigin, VicOrigin, id))
			continue
			
		if(get_distance_f(VicOrigin, Point[0]) <= Point_Dis
		|| get_distance_f(VicOrigin, Point[1]) <= Point_Dis
		|| get_distance_f(VicOrigin, Point[2]) <= Point_Dis
		|| get_distance_f(VicOrigin, Point[3]) <= Point_Dis)
		{
			if(!Have_Victim) Have_Victim = 1
			if(Mode == ATTACK_SLASH_ROTATE)
				do_attack(id, i, ent, SLASH_ROTATE_DAMAGE)
			else if(Mode == ATTACK_SLASH_AHEAD)
				do_attack(id, i, ent, SLASH_AHEAD_DAMAGE)
			else if(Mode == ATTACK_STAB)
				do_attack(id, i, ent, STAB_DAMAGE)
		}
	}	
	
	if(Have_Victim)
		return 1
	else
		return 0
	
	return 0
}	

public fw_TraceLine(Float:vector_start[3], Float:vector_end[3], ignored_monster, id, handle)
{
	if (!is_user_alive(id))
		return FMRES_IGNORED	
	if (get_user_weapon(id) != CSW_DRAGONSWORD || !g_Had_DragonSword[id])
		return FMRES_IGNORED
	
	static Float:vecStart[3], Float:vecEnd[3], Float:v_angle[3], Float:v_forward[3], Float:view_ofs[3], Float:fOrigin[3]
	
	pev(id, pev_origin, fOrigin)
	pev(id, pev_view_ofs, view_ofs)
	xs_vec_add(fOrigin, view_ofs, vecStart)
	pev(id, pev_v_angle, v_angle)
	
	engfunc(EngFunc_MakeVectors, v_angle)
	get_global_vector(GL_v_forward, v_forward)

	if(g_Attack_Mode[id] == ATTACK_SLASH_ROTATE) xs_vec_mul_scalar(v_forward, SLASH_ROTATE_RADIUS, v_forward)
	else if(g_Attack_Mode[id] == ATTACK_SLASH_AHEAD) xs_vec_mul_scalar(v_forward, SLASH_AHEAD_RADIUS, v_forward)
	else if(g_Attack_Mode[id] == ATTACK_STAB) xs_vec_mul_scalar(v_forward, STAB_RADIUS, v_forward)
	else xs_vec_mul_scalar(v_forward, 0.0, v_forward)
	xs_vec_add(vecStart, v_forward, vecEnd)
	
	engfunc(EngFunc_TraceLine, vecStart, vecEnd, ignored_monster, id, handle)
	
	return FMRES_SUPERCEDE
}

public fw_TraceHull(Float:vector_start[3], Float:vector_end[3], ignored_monster, hull, id, handle)
{
	if (!is_user_alive(id))
		return FMRES_IGNORED	
	if (get_user_weapon(id) != CSW_DRAGONSWORD || !g_Had_DragonSword[id])
		return FMRES_IGNORED
	
	static Float:vecStart[3], Float:vecEnd[3], Float:v_angle[3], Float:v_forward[3], Float:view_ofs[3], Float:fOrigin[3]
	
	pev(id, pev_origin, fOrigin)
	pev(id, pev_view_ofs, view_ofs)
	xs_vec_add(fOrigin, view_ofs, vecStart)
	pev(id, pev_v_angle, v_angle)
	
	engfunc(EngFunc_MakeVectors, v_angle)
	get_global_vector(GL_v_forward, v_forward)
	
	if(g_Attack_Mode[id] == ATTACK_SLASH_ROTATE) xs_vec_mul_scalar(v_forward, SLASH_ROTATE_RADIUS, v_forward)
	else if(g_Attack_Mode[id] == ATTACK_SLASH_AHEAD) xs_vec_mul_scalar(v_forward, SLASH_AHEAD_RADIUS, v_forward)
	else if(g_Attack_Mode[id] == ATTACK_STAB) xs_vec_mul_scalar(v_forward, STAB_RADIUS, v_forward)
	else xs_vec_mul_scalar(v_forward, 0.0, v_forward)
	xs_vec_add(vecStart, v_forward, vecEnd)
	
	engfunc(EngFunc_TraceHull, vecStart, vecEnd, ignored_monster, hull, id, handle)
	
	return FMRES_SUPERCEDE
}

public fw_PlayerTraceAttack(Victim, Attacker, Float:Damage, Float:Direction[3], TraceResult, DamageBits) 
{
	if(!is_user_alive(Attacker))	
		return HAM_IGNORED
	if(!g_Had_DragonSword[Attacker] || !g_Checking_Mode[Attacker])
		return HAM_IGNORED
		
	return HAM_SUPERCEDE
}

do_attack(Attacker, Victim, Inflictor, Float:fDamage)
{
	fake_player_trace_attack(Attacker, Victim, fDamage)
	fake_take_damage(Attacker, Victim, fDamage, Inflictor)
}

fake_player_trace_attack(iAttacker, iVictim, &Float:fDamage)
{
	// get fDirection
	new Float:fAngles[3], Float:fDirection[3]
	pev(iAttacker, pev_angles, fAngles)
	angle_vector(fAngles, ANGLEVECTOR_FORWARD, fDirection)
	
	// get fStart
	new Float:fStart[3], Float:fViewOfs[3]
	pev(iAttacker, pev_origin, fStart)
	pev(iAttacker, pev_view_ofs, fViewOfs)
	xs_vec_add(fViewOfs, fStart, fStart)
	
	// get aimOrigin
	new iAimOrigin[3], Float:fAimOrigin[3]
	get_user_origin(iAttacker, iAimOrigin, 3)
	IVecFVec(iAimOrigin, fAimOrigin)
	
	// TraceLine from fStart to AimOrigin
	new pentru = create_tr2() 
	engfunc(EngFunc_TraceLine, fStart, fAimOrigin, DONT_IGNORE_MONSTERS, iAttacker, pentru)
	new pHit = get_tr2(pentru, TR_pHit)
	new iHitgroup = get_tr2(pentru, TR_iHitgroup)
	new Float:fEndPos[3]
	get_tr2(pentru, TR_vecEndPos, fEndPos)

	// get target & body at aiming
	new iTarget, iBody
	get_user_aiming(iAttacker, iTarget, iBody)
	
	// if aiming find target is iVictim then update iHitgroup
	if (iTarget == iVictim)
	{
		iHitgroup = iBody
	}
	
	// if pentru find target not is iVictim
	else if (pHit != iVictim)
	{
		// get AimOrigin in iVictim
		new Float:fVicOrigin[3], Float:fVicViewOfs[3], Float:fAimInVictim[3]
		pev(iVictim, pev_origin, fVicOrigin)
		pev(iVictim, pev_view_ofs, fVicViewOfs) 
		xs_vec_add(fVicViewOfs, fVicOrigin, fAimInVictim)
		fAimInVictim[2] = fStart[2]
		fAimInVictim[2] += get_distance_f(fStart, fAimInVictim) * floattan( fAngles[0] * 2.0, degrees )
		
		// check aim in size of iVictim
		new iAngleToVictim = get_angle_to_target(iAttacker, fVicOrigin)
		iAngleToVictim = abs(iAngleToVictim)
		new Float:fDis = 2.0 * get_distance_f(fStart, fAimInVictim) * floatsin( float(iAngleToVictim) * 0.5, degrees )
		new Float:fVicSize[3]
		pev(iVictim, pev_size , fVicSize)
		if ( fDis <= fVicSize[0] * 0.5 )
		{
			// TraceLine from fStart to aimOrigin in iVictim
			new ptr2 = create_tr2() 
			engfunc(EngFunc_TraceLine, fStart, fAimInVictim, DONT_IGNORE_MONSTERS, iAttacker, ptr2)
			new pHit2 = get_tr2(ptr2, TR_pHit)
			new iHitgroup2 = get_tr2(ptr2, TR_iHitgroup)
			
			// if ptr2 find target is iVictim
			if ( pHit2 == iVictim && (iHitgroup2 != HIT_HEAD || fDis <= fVicSize[0] * 0.25) )
			{
				pHit = iVictim
				iHitgroup = iHitgroup2
				get_tr2(ptr2, TR_vecEndPos, fEndPos)
			}
			
			free_tr2(ptr2)
		}
		
		// if pHit still not is iVictim then set default HitGroup
		if (pHit != iVictim)
		{
			// set default iHitgroup
			iHitgroup = HIT_GENERIC
			
			new ptr3 = create_tr2() 
			engfunc(EngFunc_TraceLine, fStart, fVicOrigin, DONT_IGNORE_MONSTERS, iAttacker, ptr3)
			get_tr2(ptr3, TR_vecEndPos, fEndPos)
			
			// free ptr3
			free_tr2(ptr3)
		}
	}
	
	// set new Hit & Hitgroup & EndPos
	set_tr2(pentru, TR_pHit, iVictim)
	set_tr2(pentru, TR_iHitgroup, iHitgroup)
	set_tr2(pentru, TR_vecEndPos, fEndPos)
	
	// hitgroup multi fDamage
	new Float:fMultifDamage 
	switch(iHitgroup)
	{
		case HIT_HEAD: fMultifDamage  = 4.0
		case HIT_STOMACH: fMultifDamage  = 1.25
		case HIT_LEFTLEG: fMultifDamage  = 0.75
		case HIT_RIGHTLEG: fMultifDamage  = 0.75
		default: fMultifDamage  = 1.0
	}
	
	fDamage *= fMultifDamage
	
	// ExecuteHam
	fake_trake_attack(iAttacker, iVictim, fDamage, fDirection, pentru)
	
	// free pentru
	free_tr2(pentru)
}

stock fake_trake_attack(iAttacker, iVictim, Float:fDamage, Float:fDirection[3], iTraceHandle, iDamageBit = (DMG_NEVERGIB | DMG_BULLET))
{
	ExecuteHamB(Ham_TraceAttack, iVictim, iAttacker, fDamage, fDirection, iTraceHandle, iDamageBit)
}

stock fake_take_damage(iAttacker, iVictim, Float:fDamage, iInflictor = 0, iDamageBit = (DMG_NEVERGIB | DMG_BULLET))
{
	iInflictor = (!iInflictor) ? iAttacker : iInflictor
	ExecuteHamB(Ham_TakeDamage, iVictim, iInflictor, iAttacker, fDamage, iDamageBit)
}

stock get_angle_to_target(id, const Float:fTarget[3], Float:TargetSize = 0.0)
{
	new Float:fOrigin[3], iAimOrigin[3], Float:fAimOrigin[3], Float:fV1[3]
	pev(id, pev_origin, fOrigin)
	get_user_origin(id, iAimOrigin, 3) // end position from eyes
	IVecFVec(iAimOrigin, fAimOrigin)
	xs_vec_sub(fAimOrigin, fOrigin, fV1)
	
	new Float:fV2[3]
	xs_vec_sub(fTarget, fOrigin, fV2)
	
	new iResult = get_angle_between_vectors(fV1, fV2)
	
	if (TargetSize > 0.0)
	{
		new Float:fTan = TargetSize / get_distance_f(fOrigin, fTarget)
		new fAngleToTargetSize = floatround( floatatan(fTan, degrees) )
		iResult -= (iResult > 0) ? fAngleToTargetSize : -fAngleToTargetSize
	}
	
	return iResult
}

stock get_angle_between_vectors(const Float:fV1[3], const Float:fV2[3])
{
	new Float:fA1[3], Float:fA2[3]
	engfunc(EngFunc_VecToAngles, fV1, fA1)
	engfunc(EngFunc_VecToAngles, fV2, fA2)
	
	new iResult = floatround(fA1[1] - fA2[1])
	iResult = iResult % 360
	iResult = (iResult > 180) ? (iResult - 360) : iResult
	
	return iResult
}

stock fm_cs_get_weapon_ent_owner(ent)
{
	if (pev_valid(ent) != PDATA_SAFE)
		return -1
	
	return get_pdata_cbase(ent, OFFSET_WEAPONOWNER, OFFSET_LINUX_WEAPONS)
}

stock set_weapon_anim(id, anim)
{
	if(!is_user_alive(id))
		return
		
	set_pev(id, pev_weaponanim, anim)
	
	message_begin(MSG_ONE_UNRELIABLE, SVC_WEAPONANIM, _, id)
	write_byte(anim)
	write_byte(0)
	message_end()	
}

stock set_weapons_timeidle(id, WeaponId ,Float:TimeIdle)
{
	if(!is_user_alive(id))
		return
		
	static entwpn; entwpn = fm_get_user_weapon_entity(id, WeaponId)
	if(!pev_valid(entwpn)) 
		return
		
	set_pdata_float(entwpn, 46, TimeIdle, OFFSET_LINUX_WEAPONS)
	set_pdata_float(entwpn, 47, TimeIdle, OFFSET_LINUX_WEAPONS)
	set_pdata_float(entwpn, 48, TimeIdle + 0.5, OFFSET_LINUX_WEAPONS)
}

stock set_player_nextattack(id, Float:nexttime)
{
	if(!is_user_alive(id))
		return
		
	set_pdata_float(id, m_flNextAttack, nexttime, 5)
}

stock is_valid_entity(ent)
{
	if(pev_valid(ent) != PDATA_SAFE)
		return 0
		
	return 1
}

stock get_position(ent, Float:forw, Float:right, Float:up, Float:vStart[])
{
	static Float:vOrigin[3], Float:vAngle[3], Float:vForward[3], Float:vRight[3], Float:vUp[3]
	
	pev(ent, pev_origin, vOrigin)
	pev(ent, pev_view_ofs,vUp) //for player
	xs_vec_add(vOrigin,vUp,vOrigin)
	pev(ent, pev_v_angle, vAngle) // if normal entity ,use pev_angles
	
	angle_vector(vAngle,ANGLEVECTOR_FORWARD,vForward) //or use EngFunc_AngleVectors
	angle_vector(vAngle,ANGLEVECTOR_RIGHT,vRight)
	angle_vector(vAngle,ANGLEVECTOR_UP,vUp)
	
	vStart[0] = vOrigin[0] + vForward[0] * forw + vRight[0] * right + vUp[0] * up
	vStart[1] = vOrigin[1] + vForward[1] * forw + vRight[1] * right + vUp[1] * up
	vStart[2] = vOrigin[2] + vForward[2] * forw + vRight[2] * right + vUp[2] * up
}
	

stock is_wall_between_points(Float:start[3], Float:end[3], ignore_ent)
{
	static pentru
	pentru = create_tr2()

	engfunc(EngFunc_TraceLine, start, end, IGNORE_MONSTERS, ignore_ent, pentru)
	
	static Float:EndPos[3]
	get_tr2(pentru, TR_vecEndPos, EndPos)

	free_tr2(pentru)
	return floatround(get_distance_f(end, EndPos))
}
Aceeasi poveste ca la cea de sus
sma. | Afiseaza codul
#include <amxmodx>
#include <engine>
#include <fakemeta>
#include <fakemeta_util>
#include <hamsandwich>
#include <cstrike>

#define PLUGIN "CSO Shooting Star"
#define VERSION "1.0"
#define AUTHOR "Dias"

#define DAMAGE 70
#define RADIUS 150
#define AMMO 5

#define V_MODEL "models/v_firecracker.mdl"
#define P_MODEL "models/p_firecracker.mdl"
#define W_MODEL "models/w_firecracker.mdl"
#define S_MODEL "models/shell_firecracker.mdl"

new const WeaponSounds[8][] =
{
	"weapons/firecracker-1.wav",
	"weapons/firecracker-2.wav",
	"weapons/firecracker_draw.wav",
	"weapons/firecracker_bounce1.wav",
	"weapons/firecracker_bounce2.wav",
	"weapons/firecracker_bounce3.wav",
	"weapons/firecracker-wick.wav",
	"weapons/firecracker_explode.wav"
}

new const WeaponResources[7][] =
{
	"sprites/spark1.spr",
	"sprites/mooncake.spr",
	"sprites/muzzleflash18.spr",
	"sprites/scope_vip_grenade.spr",
	"sprites/weapon_firecracker.txt",
	"sprites/640hud7_2.spr",
	"sprites/640hud72_2.spr"
}

enum
{
	FC_ANIM_IDLE = 0,
	FC_ANIM_SHOOT1,
	FC_ANIM_SHOOT2,
	FC_ANIM_DRAW
}

#define CSW_FIRECRACKER CSW_DEAGLE
#define weapon_firecracker "weapon_deagle"

#define OLD_W_MODEL "models/w_deagle.mdl"
#define WEAPON_EVENT "events/deagle.sc"
#define WEAPON_SECRETCODE 21321

new g_Had_Firecracker[33], g_SpecialShoot[33], g_Old_Weapon[33], Float:g_LastShoot[33]
new g_firecracker_event, g_ham_bot, g_Exp_SprId, g_Exp2_SprId, g_MF_SprId, g_Trail_SprId

public plugin_init()
{
	register_plugin(PLUGIN, VERSION, AUTHOR)
	
	register_event("CurWeapon", "Event_CurWeapon", "be", "1=1")
	register_event("DeathMsg", "Event_DeathMsg", "a")
	
	register_think("grenade2", "fw_Grenade_Think")
	register_touch("grenade2", "*", "fw_Grenade_Touch")
	
	register_forward(FM_UpdateClientData, "fw_UpdateClientData_Post", 1)	
	register_forward(FM_PlaybackEvent, "fw_PlaybackEvent")	
	register_forward(FM_SetModel, "fw_SetModel")
	register_forward(FM_CmdStart, "fw_CmdStart")
	
	RegisterHam(Ham_TraceAttack, "worldspawn", "fw_TraceAttack")
	RegisterHam(Ham_TraceAttack, "player", "fw_TraceAttack")
	RegisterHam(Ham_Weapon_PrimaryAttack, weapon_firecracker, "fw_Item_PrimaryAttack")
	RegisterHam(Ham_Weapon_Reload, weapon_firecracker, "fw_Weapon_Reload")
	RegisterHam(Ham_Item_AddToPlayer, weapon_firecracker, "fw_Item_AddToPlayer_Post", 1)
	
	register_clcmd("admin_get_firecracker", "Get_Firecracker", ADMIN_BAN)
	register_clcmd("weapon_firecracker", "Hook_Weapon")
}

public plugin_precache()
{
	engfunc(EngFunc_PrecacheModel, V_MODEL)
	engfunc(EngFunc_PrecacheModel, P_MODEL)
	engfunc(EngFunc_PrecacheModel, W_MODEL)
	engfunc(EngFunc_PrecacheModel, S_MODEL)
	
	new i
	for(i = 0; i < sizeof(WeaponSounds); i++)
		engfunc(EngFunc_PrecacheSound, WeaponSounds)
	for(i = 0; i < sizeof(WeaponResources); i++)
	{
		if(i == 0) g_Exp_SprId = engfunc(EngFunc_PrecacheModel, WeaponResources)
		else if(i == 1) g_Exp2_SprId = engfunc(EngFunc_PrecacheModel, WeaponResources)
		else if(i == 2) g_MF_SprId = engfunc(EngFunc_PrecacheModel, WeaponResources)
		else if(i == 4) engfunc(EngFunc_PrecacheGeneric, WeaponResources)
		else engfunc(EngFunc_PrecacheModel, WeaponResources)
	}
	
	g_Trail_SprId = engfunc(EngFunc_PrecacheModel, "sprites/laserbeam.spr")
	
	register_forward(FM_PrecacheEvent, "fw_PrecacheEvent_Post", 1)
}

public fw_PrecacheEvent_Post(type, const name[])
{
	if(equal(WEAPON_EVENT, name))
		g_firecracker_event = get_orig_retval()		
}

public client_putinserver(id)
{
	if(!g_ham_bot && is_user_bot(id))
	{
		g_ham_bot = 1
		set_task(0.1, "Do_Register_HamBot", id)
	}
}

public Do_Register_HamBot(id)
{
	RegisterHamFromEntity(Ham_TraceAttack, id, "fw_TraceAttack")
}

public Hook_Weapon(id)
{
	engclient_cmd(id, weapon_firecracker)
	return PLUGIN_HANDLED
}

public Get_Firecracker(id)
{
	if(!is_user_alive(id))
		return
		
	g_Had_Firecracker[id] = 1
	g_SpecialShoot[id] = 0
	
	fm_give_item(id, weapon_firecracker)
	
	static Ent; Ent = fm_get_user_weapon_entity(id, CSW_FIRECRACKER)
	if(pev_valid(Ent)) cs_set_weapon_ammo(Ent, 0)
	
	// Update Ammo
	cs_set_user_bpammo(id, CSW_FIRECRACKER, AMMO)
	
	message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("AmmoX"), _, id)
	write_byte(1)
	write_byte(AMMO)
	message_end()
}

public Remove_Firecracker(id)
{
	if(!is_user_connected(id))
		return
		
	g_Had_Firecracker[id] = 0
	g_SpecialShoot[id] = 0
}

public Event_CurWeapon(id)
{
	if(!is_user_alive(id))
		return
		
	static CSWID; CSWID = read_data(2)	
	
	if((CSWID == CSW_FIRECRACKER) && g_Had_Firecracker[id])
	{
		if(g_Old_Weapon[id] != CSW_FIRECRACKER) // DRAW
		{
			set_pev(id, pev_viewmodel2, V_MODEL)
			set_pev(id, pev_weaponmodel2, P_MODEL)
			
			set_weapon_anim(id, FC_ANIM_DRAW)
		}
		
		engfunc(EngFunc_MessageBegin, MSG_ONE_UNRELIABLE, get_user_msgid("CurWeapon"), {0, 0, 0}, id)
		write_byte(1)
		write_byte(CSW_FIRECRACKER)
		write_byte(-1)
		message_end()
		
		static Ent; Ent = fm_get_user_weapon_entity(id, CSW_FIRECRACKER)
		if(pev_valid(Ent) && !cs_get_weapon_ammo(Ent)) cs_set_weapon_ammo(Ent, 0)
	}
	
	g_Old_Weapon[id] = CSWID
}

public Event_DeathMsg()
{
	static Victim; Victim = read_data(2)
	Remove_Firecracker(Victim)
}

public fw_UpdateClientData_Post(id, sendweapons, cd_handle)
{
	if(!is_user_alive(id) || !is_user_connected(id))
		return FMRES_IGNORED	
	if(get_user_weapon(id) == CSW_FIRECRACKER && g_Had_Firecracker[id])
		set_cd(cd_handle, CD_flNextAttack, get_gametime() + 0.001) 
	
	return FMRES_HANDLED
}

public fw_PlaybackEvent(flags, invoker, eventid, Float:delay, Float:origin[3], Float:angles[3], Float:fparam1, Float:fparam2, iParam1, iParam2, bParam1, bParam2)
{
	if (!is_user_connected(invoker))
		return FMRES_IGNORED	
	if(get_user_weapon(invoker) != CSW_FIRECRACKER || !g_Had_Firecracker[invoker])
		return FMRES_IGNORED
	if(eventid != g_firecracker_event)
		return FMRES_IGNORED
	
	engfunc(EngFunc_PlaybackEvent, flags | FEV_HOSTONLY, invoker, eventid, delay, origin, angles, fparam1, fparam2, iParam1, iParam2, bParam1, bParam2)
	
	Handle_Shoot(invoker)
		
	return FMRES_SUPERCEDE
}

public fw_SetModel(entity, model[])
{
	if(!pev_valid(entity))
		return FMRES_IGNORED
	
	static Classname[32]
	pev(entity, pev_classname, Classname, sizeof(Classname))
	
	if(!equal(Classname, "weaponbox"))
		return FMRES_IGNORED
	
	static iOwner
	iOwner = pev(entity, pev_owner)
	
	if(equal(model, OLD_W_MODEL))
	{
		static weapon; weapon = fm_find_ent_by_owner(-1, weapon_firecracker, entity)
		
		if(!pev_valid(weapon))
			return FMRES_IGNORED;
		
		if(g_Had_Firecracker[iOwner])
		{
			Remove_Firecracker(iOwner)
			
			set_pev(weapon, pev_impulse, WEAPON_SECRETCODE)
			engfunc(EngFunc_SetModel, entity, W_MODEL)
			
			return FMRES_SUPERCEDE
		}
	}

	return FMRES_IGNORED;
}

public fw_CmdStart(id, uc_handle, seed)
{
	if (!is_user_alive(id))
		return
	if(get_user_weapon(id) != CSW_FIRECRACKER || !g_Had_Firecracker[id])
		return
	
	static CurButton; CurButton = get_uc(uc_handle, UC_Buttons)
	if((CurButton & IN_ATTACK) && !(pev(id, pev_oldbuttons) & IN_ATTACK))
	{
		CurButton &= ~IN_ATTACK
		set_uc(uc_handle, UC_Buttons, CurButton)
		
		if(get_pdata_float(id, 83, 5) > 0.0)
			return
		if(cs_get_user_bpammo(id, CSW_FIRECRACKER) <= 0)
			return	
			
		g_SpecialShoot[id] = 0
		Handle_Shoot(id)
	}
	if((CurButton & IN_ATTACK2) && !(pev(id, pev_oldbuttons) & IN_ATTACK2))
	{
		if(get_pdata_float(id, 83, 5) > 0.0)
			return
		if(cs_get_user_bpammo(id, CSW_FIRECRACKER) <= 0)
			return
			
		static Ent; Ent = fm_get_user_weapon_entity(id, CSW_FIRECRACKER)
		if(pev_valid(Ent)) 
		{
			g_SpecialShoot[id] = 1
			Handle_Shoot(id)
			g_SpecialShoot[id] = 0
		}
	}
	if(CurButton & IN_RELOAD)
	{
		CurButton &= ~IN_RELOAD
		set_uc(uc_handle, UC_Buttons, CurButton)
	}
}

public fw_TraceAttack(Victim, Attacker, Float:Damage, Float:Direction[3], pentru, DamageBits)
{
	if(!is_user_alive(Attacker))
		return HAM_IGNORED	
	if(get_user_weapon(Attacker) != CSW_FIRECRACKER || !g_Had_Firecracker[Attacker])
		return HAM_IGNORED
		
	return HAM_SUPERCEDE
}

public fw_Item_PrimaryAttack(ent)
{
	if(!pev_valid(ent))
		return HAM_IGNORED
		
	static id; id = pev(ent, pev_owner)
	if(!is_user_alive(id) || !g_Had_Firecracker[id])
		return HAM_IGNORED

	static Float:PunchAngles[3]
	
	PunchAngles[0] = PunchAngles[1] = PunchAngles[2] = 0.0
	set_pev(id, pev_punchangle, PunchAngles)
		
	return HAM_HANDLED
}

public fw_Weapon_Reload(ent)
{
	static id; id = pev(ent, pev_owner)
	
	if(is_user_alive(id) && g_Had_Firecracker[id])
		return HAM_SUPERCEDE

	return HAM_IGNORED;
}

public fw_Item_AddToPlayer_Post(ent, id)
{
	if(!pev_valid(ent))
		return HAM_IGNORED
		
	if(pev(ent, pev_impulse) == WEAPON_SECRETCODE)
	{
		g_Had_Firecracker[id] = 1
		set_pev(ent, pev_impulse, 0)
	}		
	
	message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("WeaponList"), .player = id)
	write_string(g_Had_Firecracker[id] == 1 ? "weapon_firecracker" : "weapon_m4a1")
	write_byte(8) // PrimaryAmmoID
	write_byte(35) // PrimaryAmmoMaxAmount
	write_byte(-1) // SecondaryAmmoID
	write_byte(-1) // SecondaryAmmoMaxAmount
	write_byte(1) // SlotID (0...N)
	write_byte(1) // NumberInSlot (1...N)
	write_byte(g_Had_Firecracker[id] == 1 ? CSW_FIRECRACKER : CSW_M4A1) // WeaponID
	write_byte(0) // Flags
	message_end()

	return HAM_HANDLED	
}

public fw_Grenade_Think(Ent)
{
	if(!pev_valid(Ent))
		return
		
	static Float:Origin[3]
	pev(Ent, pev_origin, Origin)
	
	message_begin(MSG_ALL, SVC_TEMPENTITY)
	write_byte(TE_SPARKS)
	engfunc(EngFunc_WriteCoord, Origin[0])
	engfunc(EngFunc_WriteCoord, Origin[1])
	engfunc(EngFunc_WriteCoord, Origin[2])
	message_end()
	
	if(get_gametime() - 0.75 > pev(Ent, pev_fuser1))
	{
		emit_sound(Ent, CHAN_BODY, WeaponSounds[6], VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
		set_pev(Ent, pev_fuser1, get_gametime())
	}
	
	if(get_gametime() - pev(Ent, pev_fuser2) >= 2.0)
	{
		Grenade_Explosion(Ent)
		return
	}
		
	set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
}

public fw_Grenade_Touch(Ent, Id)
{
	if(!pev_valid(Ent))
		return
		
	static Bounce; Bounce = pev(Ent, pev_iuser1)
	if(Bounce)
	{
		/*
		static Float:Velocity[3]
		pev(Ent, pev_velocity, Velocity)
		
		xs_vec_mul_scalar(Velocity, 0.9, Velocity)
		set_pev(Ent, pev_velocity, Velocity)*/
		
		emit_sound(Ent, CHAN_BODY, WeaponSounds[random_num(3, 5)], VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
	} else {
		Grenade_Explosion(Ent)
	}
}

public Grenade_Explosion(Ent)
{
	static Float:Origin[3], TE_FLAG
	pev(Ent, pev_origin, Origin)
	
	TE_FLAG |= TE_EXPLFLAG_NODLIGHTS
	TE_FLAG |= TE_EXPLFLAG_NOSOUND
	TE_FLAG |= TE_EXPLFLAG_NOPARTICLES
	
	engfunc(EngFunc_MessageBegin, MSG_PAS, SVC_TEMPENTITY, Origin)
	write_byte(TE_EXPLOSION)
	engfunc(EngFunc_WriteCoord, Origin[0])
	engfunc(EngFunc_WriteCoord, Origin[1])
	engfunc(EngFunc_WriteCoord, Origin[2] + 36.0)
	write_short(g_Exp_SprId)
	write_byte(10)
	write_byte(30)
	write_byte(TE_FLAG)
	message_end()	
	
	engfunc(EngFunc_MessageBegin, MSG_PAS, SVC_TEMPENTITY, Origin)
	write_byte(TE_EXPLOSION)
	engfunc(EngFunc_WriteCoord, Origin[0])
	engfunc(EngFunc_WriteCoord, Origin[1])
	engfunc(EngFunc_WriteCoord, Origin[2] + 36.0)
	write_short(g_Exp2_SprId)
	write_byte(10)
	write_byte(30)
	write_byte(TE_FLAG)
	message_end()		
	
	message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
	write_byte(TE_WORLDDECAL)
	engfunc(EngFunc_WriteCoord, Origin[0])
	engfunc(EngFunc_WriteCoord, Origin[1])
	engfunc(EngFunc_WriteCoord, Origin[2])
	write_byte(random_num(46, 48))
	message_end()		
	
	emit_sound(Ent, CHAN_BODY, WeaponSounds[7], VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
	Check_RadiusDamage(Ent, pev(Ent, pev_owner))
	
	engfunc(EngFunc_RemoveEntity, Ent)
}

public Handle_Shoot(id)
{
	if(get_gametime() - 2.5 > g_LastShoot[id])
	{
		g_LastShoot[id] = get_gametime()
		
		static Ent; Ent = fm_get_user_weapon_entity(id, CSW_FIRECRACKER)
		if(!pev_valid(Ent)) return
		
		static Ammo; Ammo = cs_get_user_bpammo(id, CSW_FIRECRACKER)
		if(Ammo <= 0) return
		
		Ammo--
		cs_set_user_bpammo(id, CSW_FIRECRACKER, Ammo)
		
		if(Ammo <= 0) 
		{
			set_weapon_anim(id, FC_ANIM_SHOOT2)
			emit_sound(id, CHAN_WEAPON, WeaponSounds[1], VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
		} else {
			set_weapon_anim(id, FC_ANIM_SHOOT1)
			emit_sound(id, CHAN_WEAPON, WeaponSounds[0], VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
		}
		
		Make_Muzzleflash(id)
		Make_PunchAngles(id)
	
		set_weapons_timeidle(id, 2.5)
		set_player_nextattack(id, 2.5)
		
		Make_Grenade(id, g_SpecialShoot[id])
	}
}

public Make_Muzzleflash(id)
{
	static Float:Origin[3], TE_FLAG
	get_position(id, 80.0, 20.0, -10.0, Origin)
	
	TE_FLAG |= TE_EXPLFLAG_NODLIGHTS
	TE_FLAG |= TE_EXPLFLAG_NOSOUND
	TE_FLAG |= TE_EXPLFLAG_NOPARTICLES
	
	engfunc(EngFunc_MessageBegin, MSG_ONE_UNRELIABLE, SVC_TEMPENTITY, Origin, id)
	write_byte(TE_EXPLOSION)
	engfunc(EngFunc_WriteCoord, Origin[0])
	engfunc(EngFunc_WriteCoord, Origin[1])
	engfunc(EngFunc_WriteCoord, Origin[2])
	write_short(g_MF_SprId)
	write_byte(3)
	write_byte(20)
	write_byte(TE_FLAG)
	message_end()
}

public Make_PunchAngles(id)
{
	static Float:PunchAngles[3]
	
	PunchAngles[0] = random_float(-2.0, 0.0)
	PunchAngles[1] = random_float(-1.0, 1.0)
	
	set_pev(id, pev_punchangle, PunchAngles)
}

public Make_Grenade(id, Bounce)
{
	static Ent; Ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))
	if(!pev_valid(Ent)) return
	
	static Float:Origin[3], Float:Angles[3]
	
	get_position(id, 50.0, 10.0, 0.0, Origin)
	pev(id, pev_angles, Angles)
	
	set_pev(Ent, pev_movetype, MOVETYPE_BOUNCE)
	set_pev(Ent, pev_solid, SOLID_BBOX)
	set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
	
	set_pev(Ent, pev_classname, "grenade2")
	engfunc(EngFunc_SetModel, Ent, S_MODEL)
	set_pev(Ent, pev_origin, Origin)
	set_pev(Ent, pev_angles, Angles)
	set_pev(Ent, pev_owner, id)
	
	set_pev(Ent, pev_iuser1, Bounce)
	set_pev(Ent, pev_fuser2, get_gametime())
	
	// Create Velocity
	static Float:Velocity[3], Float:TargetOrigin[3]
	
	fm_get_aim_origin(id, TargetOrigin)
	get_speed_vector(Origin, TargetOrigin, 700.0, Velocity)
	
	set_pev(Ent, pev_velocity, Velocity)
	
	// Make a Beam
	message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
	write_byte(TE_BEAMFOLLOW)
	write_short(Ent) // entity
	write_short(g_Trail_SprId) // sprite
	write_byte(10)  // life
	write_byte(3)  // width
	write_byte(255) // r
	write_byte(170)  // g
	write_byte(212)  // b
	write_byte(200) // brightness
	message_end()	
}

public Check_RadiusDamage(Ent, Id)
{
	static Attacker
	if(!is_user_connected(Id)) Attacker = 0
	else Attacker = Id
	
	for(new i = 0; i < get_maxplayers(); i++)
	{
		if(!is_user_alive(i))
			continue
		if(i == Attacker)
			continue
		if(entity_range(Ent, i) > float(RADIUS))
			continue
			
		ExecuteHamB(Ham_TakeDamage, i, 0, Attacker, float(DAMAGE), DMG_BLAST)
	}
}

stock get_speed_vector(const Float:origin1[3],const Float:origin2[3],Float:speed, Float:new_velocity[3])
{
	new_velocity[0] = origin2[0] - origin1[0]
	new_velocity[1] = origin2[1] - origin1[1]
	new_velocity[2] = origin2[2] - origin1[2]
	new Float:num; num = floatsqroot(speed*speed / (new_velocity[0]*new_velocity[0] + new_velocity[1]*new_velocity[1] + new_velocity[2]*new_velocity[2]))
	new_velocity[0] *= num
	new_velocity[1] *= num
	new_velocity[2] *= num
	
	return 1;
}

stock get_position(id,Float:forw, Float:right, Float:up, Float:vStart[])
{
	static Float:vOrigin[3], Float:vAngle[3], Float:vForward[3], Float:vRight[3], Float:vUp[3]
	
	pev(id, pev_origin, vOrigin)
	pev(id, pev_view_ofs, vUp) //for player
	xs_vec_add(vOrigin, vUp, vOrigin)
	pev(id, pev_v_angle, vAngle) // if normal entity ,use pev_angles
	
	angle_vector(vAngle,ANGLEVECTOR_FORWARD, vForward) //or use EngFunc_AngleVectors
	angle_vector(vAngle,ANGLEVECTOR_RIGHT, vRight)
	angle_vector(vAngle,ANGLEVECTOR_UP, vUp)
	
	vStart[0] = vOrigin[0] + vForward[0] * forw + vRight[0] * right + vUp[0] * up
	vStart[1] = vOrigin[1] + vForward[1] * forw + vRight[1] * right + vUp[1] * up
	vStart[2] = vOrigin[2] + vForward[2] * forw + vRight[2] * right + vUp[2] * up
}

stock set_weapon_anim(id, anim)
{
	if(!is_user_alive(id))
		return
	
	set_pev(id, pev_weaponanim, anim)
	
	message_begin(MSG_ONE_UNRELIABLE, SVC_WEAPONANIM, {0, 0, 0}, id)
	write_byte(anim)
	write_byte(pev(id, pev_body))
	message_end()
}

stock set_weapons_timeidle(id, Float:TimeIdle)
{
	if(!is_user_alive(id))
		return
		
	static Ent; Ent = fm_get_user_weapon_entity(id, CSW_FIRECRACKER)
	if(!pev_valid(Ent)) 
		return
	
	set_pdata_float(Ent, 46, TimeIdle, 4)
	set_pdata_float(Ent, 47, TimeIdle, 4)
	set_pdata_float(Ent, 48, TimeIdle + 1.0, 4)
}

stock set_player_nextattack(id, Float:nexttime)
{
	if(!is_user_alive(id))
		return
		
	set_pdata_float(id, 83, nexttime, 5)
}
iar la acesta sa se poata lua cu bani (16000$) si de catre CT si T dar cand mori sa nu o mai ai.

Atat sper ca ma poate ajuta cineva
Multumesc
RoyalServer 2
User avatar
Mădălin
Administrator
Administrator
Posts: 5295
Joined: 06 Mar 2013, 21:40
Detinator Steam: Nu
Reputatie: Administrator
Fost manager cs.extream.ro
Web designer
Administratorul anului 2023
Has thanked: 45 times
Been thanked: 310 times
Contact:

05 Dec 2013, 17:16

Locked

Return to “Cereri”

  • Information