Fire M4A1 Normal CS Problem

Fire M4A1 Normal CS Problem Dec 17, 2021 13:46:01 GMT
Quote
Post by ShaunCraft15 on Dec 17, 2021 13:46:01 GMT

Hello Guys I release Now Fire M4A1 Normal CS Version but i have problem Burn Effect Allow on my team how i can fix it plz help me
Here The Code
/*-----------------------------------------------------------------------------------------------------
				[[AMXX] Extra Item: Fire M4A1]
		
		- Credits:
		
		* [P]erfec[T] [S]cr[@]s[H]: For The Elemental Code
		
		* ShaunCraft: Removing The Frost Effect From Elemental and add the new tracer
		
		- YouTube:
		
		* Link: https://www.youtube.com/channel/UCWVhiguRxt4tyacImGjiqQw
		
		- Releases:
		
		V1.0:
		
		* First Release
		
		V1.1: 
		
		* Tracer is always show
		
		V1.2:
		
		* Changed The Tracer
		
		V1.3: 
		
		* Fixed More Bugs
		
		V1.4: 
		
		* Removed the sprite Folder
		* Fix the color of tracer
		
		V1.5: 
		
		* Fixed The W_ Model Bug
		* Supported For ZP4.3 + ZPA + ZPSP
		
		V1.6: 
		
		* Added Fire Slowdown For ZP43 and ZPA + Changed Tracer System with fixed one
		* New Fire M4A1 skin from Lost Souls New Update!!
		
		V1.7:
		
		* Added Fire Hud Icon When Zombie Burned (ZP43 And ZPA)
		* Fix Damage System Burn Humans on ZP50 (Apply This Fix at All)
		* Added ConCmd For Admin to burn users "zp_burn_user name" (All)
		* Supported Crxranks and you can disable it (If You Went Buy This Extra with Level)
		* Added Command create_blast2 and you can disable it (Ring Effect From Fire Grenade)
		* Support Sniper Class To Block This Extra Item On ZP50 (Block This Extra Item For Sniper Class)
		* Added HUD Message For Burn Damage
		* Supported Now For Normal CS!!
		
		
		Sorry For bad english!!!
		
		Enjoy :)
		
------------------------------------------------------------------------------------------------------*/


#define PLUGIN "[AMXX] Fire M4A1"
#define VERSION "1.7"
#define AUTHOR "ShaunCraft"


/*------------------------------------------=[Includes]=--------------------------------------------*/
#include <amxmodx>
#include <amxmisc>
#include <engine>
#include <hamsandwich>
#include <fakemeta>
#include <xs>
#include <cstrike>
/*-------------------------------=[Variables, Conts, Defines & Cvars]=-------------------------------*/

//This define For Blast Effect From Grenade Fire if u dont need this use // from #example to ---> //#example
#define ALLOW_MAKE_BLAST_EFFECT

//This define For Buy This Item with Level if u dont have or use crxranks use // from #example to ---> //#example
//#define CRXRANKS

//This define For To Allow Hud Message with Cureent Damage if u dont need it use // from #example to ---> //#example
#define ALLOW_HUDMESSAGE_DMG

//If You Have CrxRanks if u don't Have Sniper Class use // from #example to ---> //#example
#if defined CRXRANKS
     #include <crxranks>
#endif

//Change The [ZP] Prefix Here
#define ZP_PREFIX "^x01[^x04ZP^x01] "

new FM_V_MODEL[] = "models/v_fire_m4a1.mdl"
new FM_P_MODEL[] = "models/p_fire_m4a1.mdl"
new FM_W_MODEL[] = "models/w_fire_m4a1.mdl"

new g_firem4[33]
new tracer_spr

#if defined ALLOW_MAKE_BLAST_EFFECT
new const GRENADE_FIRE[64] = "zombie_plague/grenade_explode.wav"
new g_sprite_grenade_ring[64] = "sprites/shockwave.spr"
new g_exploSpr
#endif

// Cvars
new cvar_dmgmultiplier, g_maxplayers, cvar_oneround, cvar_fire_damage

//Hud Message Sync
#if defined ALLOW_HUDMESSAGE_DMG
new g_HudSync
#endif

//For Current Damage System
new g_iDmg[33]

new cvar_burndmg, cvar_slowdown, cvar_hud_icon, cvar_burn_time, cvar_cost

#define TASK_BURN 100
#define ID_BURN (taskid - TASK_BURN)

new g_burning_duration[33] // burning task duration

new g_MsgDamage

new const fire_player[][] = {"scientist/sci_fear8.wav", "scientist/sci_pain1.wav", "scientist/scream02.wav"}

// Sprites
new g_sprite_grenade_fire[64] = "sprites/flame.spr"
new g_sprite_grenade_smoke[64] = "sprites/black_smoke3.spr"

new g_flameSpr, g_smokeSpr

//Bot Cvars & Variables
new g_hamczbots, cvar_botquota

new g_currentweapon[33]

#if defined CRXRANKS
new cvar_req_level
#endif

/*---------------------------------------=[Plugin Register]=-----------------------------------------*/
public plugin_init()
{
	// Plugin Register
	register_plugin(PLUGIN, VERSION, AUTHOR)
	
	// Cvar Register
	cvar_dmgmultiplier = register_cvar("amx_firem4_dmg_multiplier", "2") //Damage Multiplier
	cvar_burndmg = register_cvar("amx_firem4_fire_dmg", "2") // Fire Damage
	cvar_slowdown = register_cvar("amx_firem4_fire_slowdown", "0.5") //Fire M4A1 Burn Effect Slowdown
	cvar_burn_time = register_cvar("amx_firem4_burn_time", "10") //Fire M4A1 Burn Time
	cvar_hud_icon = register_cvar("amx_firem4_fire_hud_icon", "1") //Fire M4A1 Fire Hud
	
	g_MsgDamage = get_user_msgid("Damage")
	
	cvar_oneround = register_cvar("amx_firem4_one_round", "1") //Fire M4A1 For One Round
	cvar_fire_damage = register_cvar("amx_firem4_fire_damage", "500") // Max Current Damage to Burn Task
	
	#if defined CRXRANKS
	cvar_req_level = register_cvar("amx_firem4_required_level", "2")
	#endif
	
	cvar_cost = register_cvar("amx_firem4_cost", "12000")
	
	//Admin Burn User Command
	register_concmd("amx_burn_user", "cmd_burn_user", 0)
	
	//Admin Give Command
	register_concmd("amx_givefirem4", "cmd_firem4", 0)
	
	// Events
	register_event("DeathMsg", "Death", "a")
	register_event("HLTV", "event_round_start", "a", "1=0", "2=0")
	register_event("WeapPickup","CheckModel","b","1=19")
	register_event("CurWeapon","CurrentWeapon","be","1=1")
	register_event("CurWeapon", "Ham_TraceAttack_Player", "be", "1=1", "3>0")
	
	
	// Forwards
	register_forward(FM_PlayerPreThink, "fw_PlayerPreThink")
	register_forward(FM_SetModel, "fw_SetModel")
	
	// Cvar Pointer
	cvar_botquota = get_cvar_pointer("bot_quota")
	
	// Hams
	RegisterHam(Ham_Spawn, "player", "fw_PlayerSpawn_Post", 1 )
	RegisterHam(Ham_TakeDamage, "player", "fw_TakeDamage")
	RegisterHam(Ham_Killed, "player", "fw_PlayerKilled")
	RegisterHam(Ham_Item_AddToPlayer, "weapon_m4a1", "fw_AddToPlayer")
	RegisterHam(Ham_TraceAttack, "player", "Ham_TraceAttack_Player", false);
	RegisterHam(Ham_TraceAttack, "worldspawn", "Ham_TraceAttack_Player", false);
	RegisterHam(Ham_TraceAttack, "func_breakable", "Ham_TraceAttack_Player", false) 
	RegisterHam(Ham_TraceAttack, "func_wall", "Ham_TraceAttack_Player", false)
	RegisterHam(Ham_TraceAttack, "func_door", "Ham_TraceAttack_Player", false)
	RegisterHam(Ham_TraceAttack, "func_door_rotating", "Ham_TraceAttack_Player", false)
	RegisterHam(Ham_TraceAttack, "func_plat", "Ham_TraceAttack_Player", false)
	RegisterHam(Ham_TraceAttack, "func_train", "Ham_TraceAttack_Player", false)
	RegisterHam(Ham_TraceAttack, "func_conveyor", "Ham_TraceAttack_Player", false)
	RegisterHam(Ham_TraceAttack, "hostage_entity", "Ham_TraceAttack_Player", false)
	RegisterHam(Ham_TraceAttack, "func_illusionary", "Ham_TraceAttack_Player", false)
	
	#if defined ALLOW_HUDMESSAGE_DMG
	g_HudSync = CreateHudSyncObj()
	#endif
	
	g_maxplayers = get_maxplayers()
}

/*------------------------------------------=[Precaches]=--------------------------------------------*/
public plugin_precache() 
{
	// Models
	precache_model(FM_V_MODEL)
	precache_model(FM_P_MODEL)
	precache_model(FM_W_MODEL)
	
	// Tracer Spr
	tracer_spr = precache_model("sprites/xenobeam.spr")
	
	//Blast Spr
	#if defined ALLOW_MAKE_BLAST_EFFECT
	
	g_exploSpr = precache_model(g_sprite_grenade_ring)
	
	engfunc(EngFunc_PrecacheSound, GRENADE_FIRE)
	
	#endif
	
	g_flameSpr = precache_model(g_sprite_grenade_fire)
	g_smokeSpr = precache_model(g_sprite_grenade_smoke)
	
	new i
	for (i = 0; i < sizeof fire_player; i++)
		engfunc(EngFunc_PrecacheSound, fire_player[i])
	
}

/*---------------------------------------=[Bug Prevention]=-----------------------------------------*/
public event_round_start()
{
	if(get_pcvar_num(cvar_oneround))
	{
		for (new i = 1; i <= g_maxplayers; i++)
		{
			g_firem4[i] = false
			
			remove_task(i+TASK_BURN)
			g_burning_duration[i] = 0
			
		}
	}
}

public Death() g_firem4[read_data(2)] = false

public fw_PlayerSpawn_Post(victim, attacker, shouldgib)
{
	remove_task(victim+TASK_BURN)
	g_burning_duration[victim] = 0
}
// Ham Player Killed Forward
public fw_PlayerKilled(victim, attacker, shouldgib)
{
	// Stop burning
	remove_task(victim+TASK_BURN)
	g_burning_duration[victim] = 0
}
public client_disconnect(id)
{
	g_firem4[id] = false
	
	remove_task(id+TASK_BURN)
	g_burning_duration[id] = 0
	
}
public client_putinserver(id)
{
	g_firem4[id] = false
	
	remove_task(id+TASK_BURN)
	g_burning_duration[id] = 0
	
	if (is_user_bot(id) && !g_hamczbots && cvar_botquota)
	{
		set_task(0.1, "register_ham_czbots", id);
	}
}
public register_ham_czbots(id)
{
	if (g_hamczbots || !is_user_bot(id) || !get_pcvar_num(cvar_botquota))
		return;

	RegisterHamFromEntity(Ham_TakeDamage, id, "fw_TakeDamage");
	RegisterHamFromEntity(Ham_TraceAttack, id, "Ham_TraceAttack_Player", false);
	RegisterHamFromEntity(Ham_Killed, id, "fw_PlayerKilled");
	RegisterHamFromEntity(Ham_Spawn, id, "fw_PlayerSpawn_Post");

	g_hamczbots = true;
}
/*-----------------------------------------=[Take Damage]=-------------------------------------------*/
public fw_TakeDamage(victim, inflictor, attacker, Float:damage, damage_type)
{
	#if defined ALLOW_MAKE_BLAST_EFFECT
	static Float:originF[3]
	pev(victim, pev_origin, originF)
	#endif

	if(is_user_alive(attacker) && get_user_weapon(attacker) == CSW_M4A1 && g_firem4[attacker])
	{
		SetHamParamFloat(4, damage * get_pcvar_float(cvar_dmgmultiplier));
	}
	if((get_user_weapon(attacker) == CSW_M4A1) && g_firem4[attacker])
	{
		g_iDmg[attacker] += (floatround(damage) * get_pcvar_num(cvar_dmgmultiplier))
	}
	if((g_iDmg[attacker] >= get_pcvar_num(cvar_fire_damage)) && (get_user_weapon(attacker) == CSW_M4A1) && g_firem4[attacker])
	{
		#if defined ALLOW_MAKE_BLAST_EFFECT
		create_blast2(originF)
		emit_sound(0, CHAN_WEAPON, GRENADE_FIRE, 1.0, ATTN_NORM, 0, PITCH_NORM)
		#endif
		
		#if defined ALLOW_HUDMESSAGE_DMG
		new szName[32]
		get_user_name(victim, szName, charsmax(szName))
		
		set_hudmessage(255, 170, 0, 0.21, 0.15, 2, 0.5, 1.0, 0.015, 0.5)
		ShowSyncHudMsg(attacker, g_HudSync, "Zombie %s Has Been Burned", szName)
		ShowSyncHudMsg(victim, g_HudSync, "You Has Been Burned")
		
		#endif
		
		set_user_burn(victim)
		
		g_iDmg[attacker] = 0
	}
	
	return HAM_IGNORED
}
/*-----------------------------------------=[Custom Model]=-------------------------------------------*/
public CheckModel(id)
{
	if ( !g_firem4[id] )
		return PLUGIN_HANDLED
	
	if (is_user_alive(id))
	{
		set_pev(id, pev_viewmodel2, FM_V_MODEL)
		set_pev(id, pev_weaponmodel2, FM_P_MODEL)
	}
	return PLUGIN_HANDLED
}

public CurrentWeapon(id)
{
	if ((get_user_weapon(id) == CSW_M4A1) && g_firem4[id])
	{
		CheckModel(id)
	}
	return PLUGIN_HANDLED
}
/*-----------------------------------------=[World Model]=-------------------------------------------*/
public fw_SetModel(entity, model[])
{
	
	static szClassName[33]; pev(entity, pev_classname, szClassName, charsmax(szClassName))
	if(!equal(szClassName, "weaponbox")) return FMRES_IGNORED;
	
	static owner, wpn
	owner = pev(entity, pev_owner)
	wpn = find_ent_by_owner(-1, "weapon_m4a1", entity)
	
	if(g_firem4[owner] && pev_valid(wpn))
	{
		g_firem4[owner] = false
		set_pev(wpn, pev_impulse, 324584)
		engfunc(EngFunc_SetModel, entity, FM_W_MODEL)
		
		return FMRES_SUPERCEDE
	}
	return FMRES_IGNORED
}

public fw_AddToPlayer(wpn, id)
{
	if(pev_valid(wpn) && is_user_connected(id) && pev(wpn, pev_impulse) == 324584)
	{
		g_firem4[id] = true
		set_pev(wpn, pev_impulse, 0)
		return HAM_HANDLED
	}
	return HAM_IGNORED
}
/*----------------------------------------=[Weapon Tracer]=------------------------------------------*/
public Ham_TraceAttack_Player(iVictim, iAttacker, Float:fDamage, Float:fDeriction[3], iTraceHandle, iBitDamage)
{
	if(!is_user_alive(iAttacker)) return
	
	g_currentweapon[iAttacker] = get_user_weapon(iAttacker)
		
	if(g_currentweapon[iAttacker] != CSW_M4A1) return
	
	free_tr2(iTraceHandle)
	
	if(!g_firem4[iAttacker]) return
	
	#if defined ALLOW_HUDMESSAGE_DMG
	set_hudmessage(255, 170, 0, -1.0, 0.17, 0, 3.0, 1.5)
	ShowSyncHudMsg(iAttacker, g_HudSync, "Fire Damage^n%d/%d", g_iDmg[iAttacker], get_pcvar_num(cvar_fire_damage))
	#endif
	
	static Float:end[3]
	
	get_tr2(iTraceHandle, TR_vecEndPos, end)

	message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
	write_byte(TE_BEAMENTPOINT)
	write_short(iAttacker | 0x1000)
	engfunc(EngFunc_WriteCoord, end[0])
	engfunc(EngFunc_WriteCoord, end[1])
	engfunc(EngFunc_WriteCoord, end[2])
	write_short(tracer_spr)
	write_byte(1) // framerate
	write_byte(5) // framerate
	write_byte(1) // life
	write_byte(23)  // width
	write_byte(0)// noise
	write_byte(200)// r, g, b
	write_byte(80)// r, g, b
	write_byte(4)// r, g, b
	write_byte(200)	// brightness
	write_byte(5)	// speed
	message_end()
}
/*----------------------------------=[ConCmds]=------------------------------------*/
public cmd_burn_user(id, level, cid)
{
	if ((get_user_flags(id) & level) != level)
		return PLUGIN_HANDLED;

	static arg[32], player;
	read_argv(1, arg, charsmax(arg));
	player = cmd_target(id, arg, (CMDTARGET_ONLY_ALIVE | CMDTARGET_ALLOW_SELF));
	
	if (!player)
		return PLUGIN_HANDLED;
	
	#if defined ALLOW_MAKE_BLAST_EFFECT
	static Float:originF[3]
	pev(player, pev_origin, originF)
	#endif
	
	#if defined ALLOW_MAKE_BLAST_EFFECT
	create_blast2(originF)
	emit_sound(0, CHAN_WEAPON, GRENADE_FIRE, 1.0, ATTN_NORM, 0, PITCH_NORM)
	#endif
	
	set_user_burn(player)
	
	zp_color_print(player, "You Get Burned By ^04Admin")
	
	zp_color_print(id, "Player ^04%s ^01Burned!!")
	

	return PLUGIN_HANDLED;
}
public cmd_firem4(id, level, cid)
{
	if ((get_user_flags(id) & level) != level)
		return PLUGIN_HANDLED;

	static arg[32], player;
	read_argv(1, arg, charsmax(arg));
	player = cmd_target(id, arg, (CMDTARGET_ONLY_ALIVE | CMDTARGET_ALLOW_SELF));
	
	if (!player)
		return PLUGIN_HANDLED;
	
	g_firem4[player] = true;
		
	ham_strip_weapon(player, "weapon_m4a1")
		
	give_item(player, "weapon_m4a1");
		
	cs_set_user_bpammo(player, CSW_M4A1, 90);
		
	zp_color_print(player, "You Won ^4Fire ^3M4A1 From Admin")

	return PLUGIN_HANDLED;
}
public CmdBuyAk(id)
{
	if ( !is_user_alive(id) )
	{
		zp_color_print(id, "To Buy ^04Fire M4A1 ^01You Need Be ^04Alive^04!!!")
		return PLUGIN_HANDLED
	}
	
	new money = cs_get_user_money(id)
	
	if (money >= get_pcvar_num(cvar_cost))
	{
		#if defined CRXRANKS
		if(crxranks_get_user_level(id) <= get_pcvar_num(cvar_req_level))
		{
			cs_set_user_money(id, money - get_pcvar_num(cvar_cost))
			g_firem4[id] = true;
			ham_strip_weapon(id, "weapon_m4a1")
			give_item(id, "weapon_m4a1");
		}
		else
		zp_color_print(id, "You Can't Buy This Item, You Need Up To Level ^04%d", get_pcvar_num(cvar_req_level))
		#else
		cs_set_user_money(id, money - get_pcvar_num(cvar_cost))
		g_firem4[id] = true;
		ham_strip_weapon(id, "weapon_m4a1")
		give_item(id, "weapon_m4a1");
		#endif	
	}
	else
	{
		zp_color_print(id, "You don't Have Enough Money To Buy ^04Fire M4A1 ^01it ^04%d Cost", get_pcvar_num(cvar_cost))
	}
	return PLUGIN_HANDLED
}
/*----------------------------------=[Fire Effect (Target)]=------------------------------------*/
public set_user_burn(Target)
{
	if(is_user_alive(Target))
	{		
		// Heat icon?
		if (get_pcvar_num(cvar_hud_icon)) ShowIcon(Target)
			
		g_burning_duration[Target] += get_pcvar_num(cvar_burn_time) * 5
						
		// Set burning task on Target if not present
		if (!task_exists(Target+TASK_BURN))
		{
			set_task(0.2, "burning_flame", Target+TASK_BURN, _, _, "b")
			if (get_pcvar_num(cvar_hud_icon))
			set_task(1.0, "ShowIcon", Target+TASK_BURN)
		}
							  
	}
}
ShowIcon(Target)
{
	message_begin(MSG_ONE_UNRELIABLE, g_MsgDamage, _, Target) //Start Message
	write_byte(0) // damage save
	write_byte(0) // damage take
	write_long(DMG_BURN) // damage type
	write_coord(0) // x
	write_coord(0) // y
	write_coord(0) // z
	message_end() //End Message
}
// Burning Flames
public burning_flame(taskid)
{
	// Get player origin and flags
	static origin[3], flags
	get_user_origin(ID_BURN, origin)
	flags = pev(ID_BURN, pev_flags)
	
	// Madness mode - in water - burning stopped
	if ((flags & FL_INWATER) || g_burning_duration[ID_BURN] < 1)
	{
		// Smoke sprite
		message_begin(MSG_PVS, SVC_TEMPENTITY, origin)
		write_byte(TE_SMOKE) // TE id
		write_coord(origin[0]) // x
		write_coord(origin[1]) // y
		write_coord(origin[2]-50) // z
		write_short(g_smokeSpr) // sprite
		write_byte(random_num(15, 20)) // scale
		write_byte(random_num(10, 20)) // framerate
		message_end()
		
		// Task not needed anymore
		remove_task(taskid);
		return;
	}
	
	// Randomly play burning zombie scream sounds (not for nemesis)
	if (!random_num(0, 20))
	engfunc(EngFunc_EmitSound, ID_BURN, CHAN_VOICE, fire_player[random_num(0, sizeof fire_player - 1)], 1.0, ATTN_NORM, 0, PITCH_NORM)
	
	// Fire slow down, unless nemesis
	if ((flags & FL_ONGROUND) && get_pcvar_float(cvar_slowdown) > 0.0)
	{
		static Float:velocity[3]
		pev(ID_BURN, pev_velocity, velocity)
		xs_vec_mul_scalar(velocity, get_pcvar_float(cvar_slowdown), velocity)
		set_pev(ID_BURN, pev_velocity, velocity)
	}
	
	// Get player's health
	static health
	health = pev(ID_BURN, pev_health)
	
	// Take damage from the fire
	if (health - floatround(get_pcvar_float(cvar_burndmg), floatround_ceil) > 0)
		fm_set_user_health(ID_BURN, health - floatround(get_pcvar_float(cvar_burndmg), floatround_ceil))	
	
	// Flame sprite
	message_begin(MSG_PVS, SVC_TEMPENTITY, origin)
	write_byte(TE_SPRITE) // TE id
	write_coord(origin[0]+random_num(-5, 5)) // x
	write_coord(origin[1]+random_num(-5, 5)) // y
	write_coord(origin[2]+random_num(-10, 10)) // z
	write_short(g_flameSpr) // sprite
	write_byte(random_num(5, 10)) // scale
	write_byte(200) // brightness
	message_end()
	
	// Decrease burning duration counter
	g_burning_duration[ID_BURN]--
}
/*---------------------------------------------=[Blast Effect (Ring)]=--------------------------------------------*/
#if defined ALLOW_MAKE_BLAST_EFFECT 
create_blast2(const Float:originF[3])
{
	// Smallest ring
	engfunc(EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, originF, 0)
	write_byte(TE_BEAMCYLINDER) // TE id
	engfunc(EngFunc_WriteCoord, originF[0]) // x
	engfunc(EngFunc_WriteCoord, originF[1]) // y
	engfunc(EngFunc_WriteCoord, originF[2]) // z
	engfunc(EngFunc_WriteCoord, originF[0]) // x axis
	engfunc(EngFunc_WriteCoord, originF[1]) // y axis
	engfunc(EngFunc_WriteCoord, originF[2]+385.0) // z axis
	write_short(g_exploSpr) // sprite
	write_byte(0) // startframe
	write_byte(0) // framerate
	write_byte(4) // life
	write_byte(60) // width
	write_byte(0) // noise
	write_byte(200) // red
	write_byte(100) // green
	write_byte(0) // blue
	write_byte(200) // brightness
	write_byte(0) // speed
	message_end()
	
	// Medium ring
	engfunc(EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, originF, 0)
	write_byte(TE_BEAMCYLINDER) // TE id
	engfunc(EngFunc_WriteCoord, originF[0]) // x
	engfunc(EngFunc_WriteCoord, originF[1]) // y
	engfunc(EngFunc_WriteCoord, originF[2]) // z
	engfunc(EngFunc_WriteCoord, originF[0]) // x axis
	engfunc(EngFunc_WriteCoord, originF[1]) // y axis
	engfunc(EngFunc_WriteCoord, originF[2]+470.0) // z axis
	write_short(g_exploSpr) // sprite
	write_byte(0) // startframe
	write_byte(0) // framerate
	write_byte(4) // life
	write_byte(60) // width
	write_byte(0) // noise
	write_byte(200) // red
	write_byte(50) // green
	write_byte(0) // blue
	write_byte(200) // brightness
	write_byte(0) // speed
	message_end()
	
	// Largest ring
	engfunc(EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, originF, 0)
	write_byte(TE_BEAMCYLINDER) // TE id
	engfunc(EngFunc_WriteCoord, originF[0]) // x
	engfunc(EngFunc_WriteCoord, originF[1]) // y
	engfunc(EngFunc_WriteCoord, originF[2]) // z
	engfunc(EngFunc_WriteCoord, originF[0]) // x axis
	engfunc(EngFunc_WriteCoord, originF[1]) // y axis
	engfunc(EngFunc_WriteCoord, originF[2]+555.0) // z axis
	write_short(g_exploSpr) // sprite
	write_byte(0) // startframe
	write_byte(0) // framerate
	write_byte(4) // life
	write_byte(60) // width
	write_byte(0) // noise
	write_byte(200) // red
	write_byte(0) // green
	write_byte(0) // blue
	write_byte(200) // brightness
	write_byte(0) // speed
	message_end()
}
#endif
/*---------------------------------------------=[Stocks]=--------------------------------------------*/
stock give_item(index, const item[]) 
{
	if (!equal(item, "weapon_", 7) && !equal(item, "ammo_", 5) && !equal(item, "item_", 5) && !equal(item, "tf_weapon_", 10))
		return 0;

	new ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, item));
	
	if (!pev_valid(ent))
		return 0;

	new Float:origin[3];
	pev(index, pev_origin, origin);
	set_pev(ent, pev_origin, origin);
	set_pev(ent, pev_spawnflags, pev(ent, pev_spawnflags) | SF_NORESPAWN);
	dllfunc(DLLFunc_Spawn, ent);

	new save = pev(ent, pev_solid);
	dllfunc(DLLFunc_Touch, ent, index);
	if (pev(ent, pev_solid) != save)
		return ent;

	engfunc(EngFunc_RemoveEntity, ent);

	return -1;
}

// Set player's health (from fakemeta_util)
stock fm_set_user_health(id, health)
{
	(health > 0) ? set_pev(id, pev_health, float(health)) : dllfunc(DLLFunc_ClientKill, id);
}

//ZP50 Colorchat stock
stock zp_color_print(target, const message[], any:...)
{
	static buffer[512], msg_SayText = 0
	if( !msg_SayText ) msg_SayText = get_user_msgid("SayText")
	
	// Send to everyone
	if (!target)
	{
		static player, maxplayers, argscount
		maxplayers = get_maxplayers()
		argscount = numargs()
		
		for (player = 1; player <= maxplayers; player++)
		{
			// Not connected
			if (!is_user_connected(player))
				continue;
			
			// Remember changed arguments
			static arg_index, changed_args[20], changedcount // [20] = max LANG_PLAYER occurencies	
			changedcount = 0
			
			// Replace LANG_PLAYER with player id
			for (arg_index = 2; arg_index < argscount; arg_index++)
			{
				if (getarg(arg_index) == LANG_PLAYER && arg_index + 1 < argscount)
				{
					// Check if next param string is a registered language translation
					static lang_key[64], arg_subindex
					arg_subindex = 0
					while ((lang_key[arg_subindex] = getarg(arg_index + 1, arg_subindex++))) { /* keep looping */ }
					if (GetLangTransKey(lang_key) != TransKey_Bad)
					{
						setarg(arg_index, 0, player)
						changed_args[changedcount++] = arg_index
						arg_index++ // skip next argument since we know it's a translation key
					}
				}
			}
			
			// Format message for player (+add ZP prefix)
			vformat(buffer, charsmax(buffer), message, 3)
			format(buffer, charsmax(buffer), "%s%s", ZP_PREFIX , buffer)
			
			// Send it
			message_begin(MSG_ONE_UNRELIABLE, msg_SayText, _, player)
			write_byte(player)
			write_string(buffer)
			message_end()
			
			// Replace back player id's with LANG_PLAYER
			for (arg_index = 0; arg_index < changedcount; arg_index++)
				setarg(changed_args[arg_index], 0, LANG_PLAYER)
		}
	}
	// Send to specific target
	else
	{
		// Format message for player (+add ZP prefix)
		vformat(buffer, charsmax(buffer), message, 3)
		format(buffer, charsmax(buffer), "%s%s", ZP_PREFIX , buffer)
		
		// Send it
		message_begin(MSG_ONE, msg_SayText, _, target)
		write_byte(target)
		write_string(buffer)
		message_end()
	}
}
stock ham_strip_weapon(id,weapon[])
{
    if(!equal(weapon,"weapon_",7)) return 0

    new wId = get_weaponid(weapon)
    if(!wId) return 0

    new wEnt
    while((wEnt = engfunc(EngFunc_FindEntityByString,wEnt,"classname",weapon)) && pev(wEnt,pev_owner) != id) {}
    if(!wEnt) return 0

    if(get_user_weapon(id) == wId) ExecuteHamB(Ham_Weapon_RetireWeapon,wEnt)

    if(!ExecuteHamB(Ham_RemovePlayerItem,id,wEnt)) return 0
    ExecuteHamB(Ham_Item_Kill,wEnt)

    set_pev(id,pev_weapons,pev(id,pev_weapons) & ~(1<<wId))

    return 1
}