ZP Frostnade convert to biohazard

[burakxd383]

herkese selamlar,
Zombie Plague 5.0 modundaki frostnade eklentisini biohazarda uyarlamaya çalıştım mod içinde çalışır hale getirdim fakat zombiyi dondurmuyor zombiye atıldığında sis hem dondurucu hem sis bombası olarak patlıyor fakat zombi donmuyor yardım edebilen olursa sevinirim

Kod: Tümünü seç

/*================================================================================
	
	---------------------------
	-*- [ZP] Grenade: Frost -*-
	---------------------------
	
	This plugin is part of Zombie Plague Mod and is distributed under the
	terms of the GNU General Public License. Check ZP_ReadMe.txt for details.
	
================================================================================*/

#include <amxmodx>
#include <fun>
#include <fakemeta>
#include <hamsandwich>
//#include <amx_settings_api>
//#include <cs_weap_models_api>
//#include <cs_ham_bots_api>
#include <biohazard>

// Settings file
//new const ZP_SETTINGS_FILE[] = "zombieplague.ini"

// Default sounds
new const sound_grenade_frost_explode[][] = { "warcraft3/frostnova.wav" }
new const sound_grenade_frost_player[][] = { "warcraft3/impalehit.wav" }
new const sound_grenade_frost_break[][] = { "warcraft3/impalelaunch1.wav" }

#define MODEL_MAX_LENGTH 64
#define SOUND_MAX_LENGTH 64
#define SPRITE_MAX_LENGTH 64

// Models
new g_model_grenade_frost[MODEL_MAX_LENGTH] = "models/zombie_plague/v_grenade_frost.mdl"

// Sprites
new g_sprite_grenade_trail[SPRITE_MAX_LENGTH] = "sprites/laserbeam.spr"
new g_sprite_grenade_ring[SPRITE_MAX_LENGTH] = "sprites/shockwave.spr"
new g_sprite_grenade_glass[SPRITE_MAX_LENGTH] = "models/glassgibs.mdl"

new Array:g_sound_grenade_frost_explode
new Array:g_sound_grenade_frost_player
new Array:g_sound_grenade_frost_break

#define GRAVITY_HIGH 999999.9
#define GRAVITY_NONE 0.000001

#define TASK_FROST_REMOVE 100
#define ID_FROST_REMOVE (taskid - TASK_FROST_REMOVE)

#define MAXPLAYERS 32

#define flag_get(%1,%2) (%1 & (1 << (%2 & 31)))
#define flag_get_boolean(%1,%2) (flag_get(%1,%2) ? true : false)
#define flag_set(%1,%2) %1 |= (1 << (%2 & 31))
#define flag_unset(%1,%2) %1 &= ~(1 << (%2 & 31))

// Hack to be able to use Ham_Player_ResetMaxSpeed (by joaquimandrade)
new Ham:Ham_Player_ResetMaxSpeed = Ham_Item_PreFrame

// Explosion radius for custom grenades
const Float:NADE_EXPLOSION_RADIUS = 240.0

// HACK: pev_ field used to store custom nade types and their values
const PEV_NADE_TYPE = pev_flTimeStepSound
const NADE_TYPE_FROST = 3333

// Some constants
const UNIT_SECOND = (1<<12)
const BREAK_GLASS = 0x01
const FFADE_IN = 0x0000
const FFADE_STAYOUT = 0x0004

// Custom Forwards
enum _:TOTAL_FORWARDS
{
	FW_USER_FREEZE_PRE = 0,
	FW_USER_UNFROZEN
}
new g_Forwards[TOTAL_FORWARDS]
new g_ForwardResult

new g_IsFrozen
new Float:g_FrozenGravity[MAXPLAYERS+1]
new g_FrozenRenderingFx[MAXPLAYERS+1]
new Float:g_FrozenRenderingColor[MAXPLAYERS+1][3]
new g_FrozenRenderingRender[MAXPLAYERS+1]
new Float:g_FrozenRenderingAmount[MAXPLAYERS+1]

new g_MsgDamage, g_MsgScreenFade
new g_trailSpr, g_exploSpr, g_glassSpr

new cvar_grenade_frost_duration, cvar_grenade_frost_hudicon

public plugin_init()
{
	//register_plugin("[ZP] Grenade: Frost", 1.0, "ZP Dev Team")
	
	RegisterHam(Ham_Player_ResetMaxSpeed, "player", "fw_ResetMaxSpeed_Post", 1)
	//RegisterHamBots(Ham_Player_ResetMaxSpeed, "fw_ResetMaxSpeed_Post", 1)
	RegisterHam(Ham_TakeDamage, "player", "fw_TakeDamage")
	//RegisterHamBots(Ham_TakeDamage, "fw_TakeDamage")
	RegisterHam(Ham_TraceAttack, "player", "fw_TraceAttack")
	//RegisterHamBots(Ham_TraceAttack, "fw_TraceAttack")
	RegisterHam(Ham_Killed, "player", "fw_PlayerKilled")
	//RegisterHamBots(Ham_Killed, "fw_PlayerKilled")
	register_forward(FM_PlayerPreThink, "fw_PlayerPreThink")
	register_forward(FM_SetModel, "fw_SetModel")
	RegisterHam(Ham_Think, "grenade", "fw_ThinkGrenade")
	
	g_MsgDamage = get_user_msgid("Damage")
	g_MsgScreenFade = get_user_msgid("ScreenFade")
	
	cvar_grenade_frost_duration = register_cvar("zp_grenade_frost_duration", "3")
	cvar_grenade_frost_hudicon = register_cvar("zp_grenade_frost_hudicon", "1")
	
	//g_Forwards[FW_USER_FREEZE_PRE] = CreateMultiForward("zp_fw_grenade_frost_pre", ET_CONTINUE, FP_CELL)
	//g_Forwards[FW_USER_UNFROZEN] = CreateMultiForward("zp_fw_grenade_frost_unfreeze", ET_IGNORE, FP_CELL)
}

public plugin_natives()
{
	register_library("zp50_grenade_frost")
	register_native("zp_grenade_frost_get", "native_grenade_frost_get")
	register_native("zp_grenade_frost_set", "native_grenade_frost_set")
}

public native_grenade_frost_get(plugin_id, num_params)
{
	new id = get_param(1)
	
	if (!is_user_alive(id))
	{
		log_error(AMX_ERR_NATIVE, "[ZP] Invalid Player (%d)", id)
		return false;
	}
	
	return flag_get_boolean(g_IsFrozen, id);
}

public native_grenade_frost_set(plugin_id, num_params)
{
	new id = get_param(1)
	
	if (!is_user_alive(id))
	{
		log_error(AMX_ERR_NATIVE, "[ZP] Invalid Player (%d)", id)
		return false;
	}
	
	new set = get_param(2)
	
	// Unfreeze
	if (!set)
	{
		// Not frozen
		if (!flag_get(g_IsFrozen, id))
			return true;
		
		// Remove freeze right away and stop the task
		remove_freeze(id+TASK_FROST_REMOVE)
		remove_task(id+TASK_FROST_REMOVE)
		return true;
	}
	
	return set_freeze(id);
}

public plugin_precache()
{
	// Initialize arrays
	g_sound_grenade_frost_explode = ArrayCreate(SOUND_MAX_LENGTH, 1)
	g_sound_grenade_frost_player = ArrayCreate(SOUND_MAX_LENGTH, 1)
	g_sound_grenade_frost_break = ArrayCreate(SOUND_MAX_LENGTH, 1)
	
	// Load from external file
	//amx_load_setting_string_arr(ZP_SETTINGS_FILE, "Sounds", "GRENADE FROST EXPLODE", g_sound_grenade_frost_explode)
	//amx_load_setting_string_arr(ZP_SETTINGS_FILE, "Sounds", "GRENADE FROST PLAYER", g_sound_grenade_frost_player)
	//amx_load_setting_string_arr(ZP_SETTINGS_FILE, "Sounds", "GRENADE FROST BREAK", g_sound_grenade_frost_break)
	
	// If we couldn't load custom sounds from file, use and save default ones
	new index
	if (ArraySize(g_sound_grenade_frost_explode) == 0)
	{
		for (index = 0; index < sizeof sound_grenade_frost_explode; index++)
			ArrayPushString(g_sound_grenade_frost_explode, sound_grenade_frost_explode[index])
		
		// Save to external file
		//amx_save_setting_string_arr(ZP_SETTINGS_FILE, "Sounds", "GRENADE FROST EXPLODE", g_sound_grenade_frost_explode)
	}
	if (ArraySize(g_sound_grenade_frost_player) == 0)
	{
		for (index = 0; index < sizeof sound_grenade_frost_player; index++)
			ArrayPushString(g_sound_grenade_frost_player, sound_grenade_frost_player[index])
		
		// Save to external file
		//amx_save_setting_string_arr(ZP_SETTINGS_FILE, "Sounds", "GRENADE FROST PLAYER", g_sound_grenade_frost_player)
	}
	if (ArraySize(g_sound_grenade_frost_break) == 0)
	{
		for (index = 0; index < sizeof sound_grenade_frost_break; index++)
			ArrayPushString(g_sound_grenade_frost_break, sound_grenade_frost_break[index])
		
		// Save to external file
		//amx_save_setting_string_arr(ZP_SETTINGS_FILE, "Sounds", "GRENADE FROST BREAK", g_sound_grenade_frost_break)
	}
	
	// Load from external file, save if not found
	/*if (!amx_load_setting_string(ZP_SETTINGS_FILE, "Weapon Models", "GRENADE FROST", g_model_grenade_frost, charsmax(g_model_grenade_frost)))
		amx_save_setting_string(ZP_SETTINGS_FILE, "Weapon Models", "GRENADE FROST", g_model_grenade_frost)
	if (!amx_load_setting_string(ZP_SETTINGS_FILE, "Grenade Sprites", "TRAIL", g_sprite_grenade_trail, charsmax(g_sprite_grenade_trail)))
		amx_save_setting_string(ZP_SETTINGS_FILE, "Grenade Sprites", "TRAIL", g_sprite_grenade_trail)
	if (!amx_load_setting_string(ZP_SETTINGS_FILE, "Grenade Sprites", "RING", g_sprite_grenade_ring, charsmax(g_sprite_grenade_ring)))
		amx_save_setting_string(ZP_SETTINGS_FILE, "Grenade Sprites", "RING", g_sprite_grenade_ring)
	if (!amx_load_setting_string(ZP_SETTINGS_FILE, "Grenade Sprites", "GLASS", g_sprite_grenade_glass, charsmax(g_sprite_grenade_glass)))
		amx_save_setting_string(ZP_SETTINGS_FILE, "Grenade Sprites", "GLASS", g_sprite_grenade_glass)*/
	
	// Precache sounds
	new sound[SOUND_MAX_LENGTH]
	for (index = 0; index < ArraySize(g_sound_grenade_frost_explode); index++)
	{
		ArrayGetString(g_sound_grenade_frost_explode, index, sound, charsmax(sound))
		precache_sound(sound)
	}
	for (index = 0; index < ArraySize(g_sound_grenade_frost_player); index++)
	{
		ArrayGetString(g_sound_grenade_frost_player, index, sound, charsmax(sound))
		precache_sound(sound)
	}
	for (index = 0; index < ArraySize(g_sound_grenade_frost_break); index++)
	{
		ArrayGetString(g_sound_grenade_frost_break, index, sound, charsmax(sound))
		precache_sound(sound)
	}
	
	// Precache models
	precache_model(g_model_grenade_frost)
	g_trailSpr = precache_model(g_sprite_grenade_trail)
	g_exploSpr = precache_model(g_sprite_grenade_ring)
	g_glassSpr = precache_model(g_sprite_grenade_glass)
}

/*public zp_fw_core_cure_post(id, attacker)
{
	// Set custom grenade model
	cs_set_player_view_model(id, CSW_FLASHBANG, g_model_grenade_frost)
	
	// If frozen, remove freeze after player is cured
	if (flag_get(g_IsFrozen, id))
	{
		// Update gravity and rendering values first
		ApplyFrozenGravity(id)
		ApplyFrozenRendering(id)
		
		// Remove freeze right away and stop the task
		remove_freeze(id+TASK_FROST_REMOVE)
		remove_task(id+TASK_FROST_REMOVE)
	}
}

public zp_fw_core_infect(id, attacker)
{
	// Remove custom grenade model
	cs_reset_player_view_model(id, CSW_FLASHBANG)
}*/

public event_infect(id, attacker)
{
	// If frozen, update gravity and rendering
	if (flag_get(g_IsFrozen, id))
	{
		ApplyFrozenGravity(id)
		ApplyFrozenRendering(id)
	}
}

public client_disconnected(id)
{
	flag_unset(g_IsFrozen, id)
	remove_task(id+TASK_FROST_REMOVE)
}

public fw_ResetMaxSpeed_Post(id)
{
	// Dead or not frozen
	if (!is_user_alive(id) || !flag_get(g_IsFrozen, id))
		return;
	
	// Prevent from moving
	set_user_maxspeed(id, 1.0)
}

// Ham Trace Attack Forward
public fw_TraceAttack(victim, attacker)
{
	// Non-player damage or self damage
	if (victim == attacker || !is_user_alive(attacker))
		return HAM_IGNORED;
	
	// Block damage while frozen, as it makes killing zombies too easy
	if (flag_get(g_IsFrozen, victim))
		return HAM_SUPERCEDE;
	
	return HAM_IGNORED;
}

// Ham Take Damage Forward (needed to block explosion damage too)
public fw_TakeDamage(victim, inflictor, attacker, Float:damage, damage_type)
{
	// Non-player damage or self damage
	if (victim == attacker || !is_user_alive(attacker))
		return HAM_IGNORED;
	
	// Block damage while frozen, as it makes killing zombies too easy
	if (flag_get(g_IsFrozen, victim))
		return HAM_SUPERCEDE;
	
	return HAM_IGNORED;
}

// Ham Player Killed Forward
public fw_PlayerKilled(victim, attacker, shouldgib)
{
	// Frozen player being killed (usually caused by a 3rd party plugin, e.g. lasermines)
	if (flag_get(g_IsFrozen, victim))
	{
		// Remove freeze right away and stop the task
		remove_freeze(victim+TASK_FROST_REMOVE)
		remove_task(victim+TASK_FROST_REMOVE)
	}
}

// Forward Player PreThink
public fw_PlayerPreThink(id)
{
	// Not alive or not frozen
	if (!is_user_alive(id) || !flag_get(g_IsFrozen, id))
		return;
	
	// Stop motion
	set_pev(id, pev_velocity, Float:{0.0,0.0,0.0})
}

// Forward Set Model
public fw_SetModel(entity, const model[])
{
	// We don't care
	if (strlen(model) < 8)
		return;
	
	// Narrow down our matches a bit
	if (model[7] != 'w' || model[8] != '_')
		return;
	
	// Get damage time of grenade
	static Float:dmgtime
	pev(entity, pev_dmgtime, dmgtime)
	
	// Grenade not yet thrown
	if (dmgtime == 0.0)
		return;
	
	// Grenade's owner is zombie?
	if (is_user_zombie(pev(entity, pev_owner)))
		return;
	
	// Flashbang
	if (model[9] == 'f' && model[10] == 'l')
	{
		// Give it a glow
		fm_set_rendering(entity, kRenderFxGlowShell, 0, 100, 200, kRenderNormal, 16);
		
		// And a colored trail
		message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
		write_byte(TE_BEAMFOLLOW) // TE id
		write_short(entity) // entity
		write_short(g_trailSpr) // sprite
		write_byte(10) // life
		write_byte(10) // width
		write_byte(0) // r
		write_byte(100) // g
		write_byte(200) // b
		write_byte(200) // brightness
		message_end()
		
		// Set grenade type on the thrown grenade entity
		set_pev(entity, PEV_NADE_TYPE, NADE_TYPE_FROST)
	}
}

// Ham Grenade Think Forward
public fw_ThinkGrenade(entity)
{
	// Invalid entity
	if (!pev_valid(entity)) return HAM_IGNORED;
	
	// Get damage time of grenade
	static Float:dmgtime
	pev(entity, pev_dmgtime, dmgtime)
	
	// Check if it's time to go off
	if (dmgtime > get_gametime())
		return HAM_IGNORED;
	
	// Check if it's one of our custom nades
	switch (pev(entity, PEV_NADE_TYPE))
	{
		case NADE_TYPE_FROST: // Frost Grenade
		{
			frost_explode(entity)
			return HAM_SUPERCEDE;
		}
	}
	
	return HAM_IGNORED;
}

// Frost Grenade Explosion
frost_explode(ent)
{
	// Get origin
	static Float:origin[3]
	pev(ent, pev_origin, origin)
	
	// Make the explosion
	create_blast3(origin)
	
	// Frost nade explode sound
	static sound[SOUND_MAX_LENGTH]
	ArrayGetString(g_sound_grenade_frost_explode, random_num(0, ArraySize(g_sound_grenade_frost_explode) - 1), sound, charsmax(sound))
	emit_sound(ent, CHAN_WEAPON, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
	
	// Collisions
	new victim = -1
	
	while ((victim = engfunc(EngFunc_FindEntityInSphere, victim, origin, NADE_EXPLOSION_RADIUS)) != 0)
	{
		// Only effect alive zombies
		if (!is_user_alive(victim) || !is_user_zombie(victim))
			continue;
		
		set_freeze(victim)
	}
	
	// Get rid of the grenade
	engfunc(EngFunc_RemoveEntity, ent)
}

set_freeze(victim)
{
	// Already frozen
	if (flag_get(g_IsFrozen, victim))
		return false;
	
	// Allow other plugins to decide whether player should be frozen or not
	ExecuteForward(g_Forwards[FW_USER_FREEZE_PRE], g_ForwardResult, victim)
	if (g_ForwardResult >= PLUGIN_HANDLED)
	{
		// Get player's origin
		static origin2[3]
		get_user_origin(victim, origin2)
		
		// Broken glass sound
		static sound[SOUND_MAX_LENGTH]
		ArrayGetString(g_sound_grenade_frost_break, random_num(0, ArraySize(g_sound_grenade_frost_break) - 1), sound, charsmax(sound))
		emit_sound(victim, CHAN_BODY, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
		
		// Glass shatter
		message_begin(MSG_PVS, SVC_TEMPENTITY, origin2)
		write_byte(TE_BREAKMODEL) // TE id
		write_coord(origin2[0]) // x
		write_coord(origin2[1]) // y
		write_coord(origin2[2]+24) // z
		write_coord(16) // size x
		write_coord(16) // size y
		write_coord(16) // size z
		write_coord(random_num(-50, 50)) // velocity x
		write_coord(random_num(-50, 50)) // velocity y
		write_coord(25) // velocity z
		write_byte(10) // random velocity
		write_short(g_glassSpr) // model
		write_byte(10) // count
		write_byte(25) // life
		write_byte(BREAK_GLASS) // flags
		message_end()
		
		return false;
	}
	
	// Freeze icon?
	if (get_pcvar_num(cvar_grenade_frost_hudicon))
	{
		message_begin(MSG_ONE_UNRELIABLE, g_MsgDamage, _, victim)
		write_byte(0) // damage save
		write_byte(0) // damage take
		write_long(DMG_DROWN) // damage type - DMG_FREEZE
		write_coord(0) // x
		write_coord(0) // y
		write_coord(0) // z
		message_end()
	}
	
	// Set frozen flag
	flag_set(g_IsFrozen, victim)
	
	// Freeze sound
	static sound[SOUND_MAX_LENGTH]
	ArrayGetString(g_sound_grenade_frost_player, random_num(0, ArraySize(g_sound_grenade_frost_player) - 1), sound, charsmax(sound))
	emit_sound(victim, CHAN_BODY, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
	
	// Add a blue tint to their screen
	message_begin(MSG_ONE, g_MsgScreenFade, _, victim)
	write_short(0) // duration
	write_short(0) // hold time
	write_short(FFADE_STAYOUT) // fade type
	write_byte(0) // red
	write_byte(50) // green
	write_byte(200) // blue
	write_byte(100) // alpha
	message_end()
	
	// Update player entity rendering
	ApplyFrozenRendering(victim)
	
	// Block gravity
	ApplyFrozenGravity(victim)
	
	// Update player's maxspeed
	ExecuteHamB(Ham_Player_ResetMaxSpeed, victim)
	
	// Set a task to remove the freeze
	set_task(get_pcvar_float(cvar_grenade_frost_duration), "remove_freeze", victim+TASK_FROST_REMOVE)
	return true;
}

ApplyFrozenGravity(id)
{
	// Get current gravity
	new Float:gravity = get_user_gravity(id)
	
	// Already set, no worries...
	if (gravity == GRAVITY_HIGH || gravity == GRAVITY_NONE)
		return;
	
	// Save player's old gravity
	g_FrozenGravity[id] = gravity
	
	// Prevent from jumping
	if (pev(id, pev_flags) & FL_ONGROUND)
		set_user_gravity(id, GRAVITY_HIGH) // set really high
	else
		set_user_gravity(id, GRAVITY_NONE) // no gravity
}

ApplyFrozenRendering(id)
{
	// Get current rendering
	new rendering_fx = pev(id, pev_renderfx)
	new Float:rendering_color[3]
	pev(id, pev_rendercolor, rendering_color)
	new rendering_render = pev(id, pev_rendermode)
	new Float:rendering_amount
	pev(id, pev_renderamt, rendering_amount)
	
	// Already set, no worries...
	if (rendering_fx == kRenderFxGlowShell && rendering_color[0] == 0.0 && rendering_color[1] == 100.0
		&& rendering_color[2] == 200.0 && rendering_render == kRenderNormal && rendering_amount == 25.0)
		return;
	
	// Save player's old rendering	
	g_FrozenRenderingFx[id] = pev(id, pev_renderfx)
	pev(id, pev_rendercolor, g_FrozenRenderingColor[id])
	g_FrozenRenderingRender[id] = pev(id, pev_rendermode)
	pev(id, pev_renderamt, g_FrozenRenderingAmount[id])
	
	// Light blue glow while frozen
	fm_set_rendering(id, kRenderFxGlowShell, 0, 100, 200, kRenderNormal, 25)
}

// Remove freeze task
public remove_freeze(taskid)
{
	// Remove frozen flag
	flag_unset(g_IsFrozen, ID_FROST_REMOVE)
	
	// Restore gravity
	set_pev(ID_FROST_REMOVE, pev_gravity, g_FrozenGravity[ID_FROST_REMOVE])
	
	// Update player's maxspeed
	ExecuteHamB(Ham_Player_ResetMaxSpeed, ID_FROST_REMOVE)
	
	// Restore rendering
	fm_set_rendering_float(ID_FROST_REMOVE, g_FrozenRenderingFx[ID_FROST_REMOVE], g_FrozenRenderingColor[ID_FROST_REMOVE], g_FrozenRenderingRender[ID_FROST_REMOVE], g_FrozenRenderingAmount[ID_FROST_REMOVE])
	
	// Gradually remove screen's blue tint
	message_begin(MSG_ONE, g_MsgScreenFade, _, ID_FROST_REMOVE)
	write_short(UNIT_SECOND) // duration
	write_short(0) // hold time
	write_short(FFADE_IN) // fade type
	write_byte(0) // red
	write_byte(50) // green
	write_byte(200) // blue
	write_byte(100) // alpha
	message_end()
	
	// Broken glass sound
	static sound[SOUND_MAX_LENGTH]
	ArrayGetString(g_sound_grenade_frost_break, random_num(0, ArraySize(g_sound_grenade_frost_break) - 1), sound, charsmax(sound))
	emit_sound(ID_FROST_REMOVE, CHAN_BODY, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
	
	// Get player's origin
	static origin[3]
	get_user_origin(ID_FROST_REMOVE, origin)
	
	// Glass shatter
	message_begin(MSG_PVS, SVC_TEMPENTITY, origin)
	write_byte(TE_BREAKMODEL) // TE id
	write_coord(origin[0]) // x
	write_coord(origin[1]) // y
	write_coord(origin[2]+24) // z
	write_coord(16) // size x
	write_coord(16) // size y
	write_coord(16) // size z
	write_coord(random_num(-50, 50)) // velocity x
	write_coord(random_num(-50, 50)) // velocity y
	write_coord(25) // velocity z
	write_byte(10) // random velocity
	write_short(g_glassSpr) // model
	write_byte(10) // count
	write_byte(25) // life
	write_byte(BREAK_GLASS) // flags
	message_end()
	
	ExecuteForward(g_Forwards[FW_USER_UNFROZEN], g_ForwardResult, ID_FROST_REMOVE)
}

// Frost Grenade: Freeze Blast
create_blast3(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(0) // red
	write_byte(100) // green
	write_byte(200) // 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(0) // red
	write_byte(100) // green
	write_byte(200) // 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(0) // red
	write_byte(100) // green
	write_byte(200) // blue
	write_byte(200) // brightness
	write_byte(0) // speed
	message_end()
}

// Set entity's rendering type (from fakemeta_util)
stock fm_set_rendering(entity, fx = kRenderFxNone, r = 255, g = 255, b = 255, render = kRenderNormal, amount = 16)
{
	static Float:color[3]
	color[0] = float(r)
	color[1] = float(g)
	color[2] = float(b)
	
	set_pev(entity, pev_renderfx, fx)
	set_pev(entity, pev_rendercolor, color)
	set_pev(entity, pev_rendermode, render)
	set_pev(entity, pev_renderamt, float(amount))
}

// Set entity's rendering type (float parameters version)
stock fm_set_rendering_float(entity, fx = kRenderFxNone, Float:color[3], render = kRenderNormal, Float:amount = 16.0)
{
	set_pev(entity, pev_renderfx, fx)
	set_pev(entity, pev_rendercolor, color)
	set_pev(entity, pev_rendermode, render)
	set_pev(entity, pev_renderamt, amount)
}

[tilki andrei]

#include <amxmodx>
#include <cstrike>
#include <fakemeta>
#include <fun>
#include <hamsandwich>

new const VERSION[] = "2.12";

#define message_begin_fl(%1,%2,%3,%4) engfunc(EngFunc_MessageBegin, %1, %2, %3, %4)
#define write_coord_fl(%1) engfunc(EngFunc_WriteCoord, %1)

#define m_pActiveItem 373
#define m_flFlashedUntil 514
#define m_flFlashHoldTime 517
#define OFFSET_WEAPON_CSWID 43
#define Ham_Player_ResetMaxSpeed Ham_Item_PreFrame

#define MAX_WEAPONS 32
#define AMMO_FLASHBANG 11
#define AMMO_HEGRENADE 12
#define AMMO_SMOKEGRENADE 13
#define DMG_GRENADE (1<<24) // thanks arkshine
#define FFADE_IN 0x0000 // just here so we don't pass 0 into the function
#define BREAK_GLASS 0x01

#define GLOW_AMOUNT 1.0
#define FROST_RADIUS 240.0

#define NT_FLASHBANG (1<<0) // 1; CSW:25
#define NT_HEGRENADE (1<<1) // 2; CSW:4
#define NT_SMOKEGRENADE (1<<2) // 4; CSW:9

#define ICON_HASNADE 1
#define ICON_ISCHILLED 2

#define TASK_REMOVE_CHILL 100
#define TASK_REMOVE_FREEZE 200

new const MODEL_FROZEN[] = "models/pi_shrub.mdl";
new const MODEL_GLASSGIBS[] = "models/glassgibs.mdl";

new const SOUND_EXPLODE[] = "x/x_shoot1.wav";
new const SOUND_FROZEN[] = "debris/glass1.wav";
new const SOUND_UNFROZEN[] = "debris/glass3.wav";
new const SOUND_CHILLED[] = "player/pl_duct2.wav";
new const SOUND_PICKUP[] = "items/gunpickup2.wav";

new const SPRITE_TRAIL[] = "sprites/laserbeam.spr";
new const SPRITE_SMOKE[] = "sprites/steam1.spr";
new const SPRITE_EXPLO[] = "sprites/shockwave.spr";

new pcv_enabled, pcv_override, pcv_nadetypes, pcv_teams, pcv_price, pcv_limit, pcv_buyzone, pcv_color, pcv_icon,
pcv_by_radius, pcv_hitself, pcv_los, pcv_maxdamage, pcv_mindamage, pcv_chill_maxchance, pcv_chill_minchance,
pcv_chill_duration, pcv_chill_variance, pcv_chill_speed, pcv_freeze_maxchance, pcv_freeze_minchance,
pcv_freeze_duration, pcv_freeze_variance;

new maxPlayers, gmsgScreenFade, gmsgStatusIcon, gmsgBlinkAcct, gmsgAmmoPickup, gmsgTextMsg,
gmsgWeapPickup, glassGibs, trailSpr, smokeSpr, exploSpr, mp_friendlyfire, czero, bot_quota, czBotHams, fmFwdPPT,
fnFwdPlayerChilled, fnFwdPlayerFrozen;

new isChilled[33], isFrozen[33], frostKilled[33], novaDisplay[33], Float:glowColor[33][3], Float:oldGravity[33], oldRenderFx[33],
Float:oldRenderColor[33][3], oldRenderMode[33], Float:oldRenderAmt[33], hasFrostNade[33], nadesBought[33], lastWeapon[33];

public plugin_init()
{
register_plugin("FrostNades",VERSION,"Avalanche");
register_cvar("fn_version",VERSION,FCVAR_SERVER);

pcv_enabled = register_cvar("fn_enabled","1");
pcv_override = register_cvar("fn_override","1");
pcv_nadetypes = register_cvar("fn_nadetypes","4"); // NT_SMOKEGRENADE
pcv_teams = register_cvar("fn_teams","3");
pcv_price = register_cvar("fn_price","300");
pcv_icon = register_cvar("fn_icon","1");
pcv_limit = register_cvar("fn_limit","0");
pcv_buyzone = register_cvar("fn_buyzone","1");
pcv_color = register_cvar("fn_color","0 206 209");

pcv_by_radius = register_cvar("fn_by_radius","0.0");
pcv_hitself = register_cvar("fn_hitself","1");
pcv_los = register_cvar("fn_los","1");
pcv_maxdamage = register_cvar("fn_maxdamage","20.0");
pcv_mindamage = register_cvar("fn_mindamage","1.0");
pcv_chill_maxchance = register_cvar("fn_chill_maxchance","100.0");
pcv_chill_minchance = register_cvar("fn_chill_minchance","100.0");
pcv_chill_duration = register_cvar("fn_chill_duration","7.0");
pcv_chill_variance = register_cvar("fn_chill_variance","1.0");
pcv_chill_speed = register_cvar("fn_chill_speed","60.0");
pcv_freeze_maxchance = register_cvar("fn_freeze_maxchance","110.0");
pcv_freeze_minchance = register_cvar("fn_freeze_minchance","40.0");
pcv_freeze_duration = register_cvar("fn_freeze_duration","4.0");
pcv_freeze_variance = register_cvar("fn_freeze_variance","0.5");

mp_friendlyfire = get_cvar_pointer("mp_friendlyfire");

new mod[6];
get_modname(mod,5);
if(equal(mod,"czero"))
{
czero = 1;
bot_quota = get_cvar_pointer("bot_quota");
}

maxPlayers = get_maxplayers();
gmsgScreenFade = get_user_msgid("ScreenFade");
gmsgStatusIcon = get_user_msgid("StatusIcon");
gmsgBlinkAcct = get_user_msgid("BlinkAcct");
gmsgAmmoPickup = get_user_msgid("AmmoPickup");
gmsgWeapPickup = get_user_msgid("WeapPickup");
gmsgTextMsg = get_user_msgid("TextMsg");

register_forward(FM_SetModel,"fw_setmodel",1);
register_message(get_user_msgid("DeathMsg"),"msg_deathmsg");

register_event("CurWeapon","event_curweapon","b","1=1"); // current weapon
register_event("AmmoX","event_ammox","b","1=11","1=12","1=13"); // flash, HE, smoke

RegisterHam(Ham_Spawn,"player","ham_player_spawn",1);
RegisterHam(Ham_Killed,"player","ham_player_killed",1);
RegisterHam(Ham_Player_ResetMaxSpeed,"player","ham_player_resetmaxspeed",1);
RegisterHam(Ham_Think,"grenade","ham_grenade_think",0);

register_clcmd("say /fn","buy_frostnade");
register_clcmd("say_team /fn","buy_frostnade");
register_clcmd("say /frostnade","buy_frostnade");
register_clcmd("say_team /frostnade","buy_frostnade");

fnFwdPlayerChilled = CreateMultiForward("frostnades_player_chilled", ET_STOP, FP_CELL, FP_CELL);
fnFwdPlayerFrozen = CreateMultiForward("frostnades_player_frozen", ET_STOP, FP_CELL, FP_CELL);
}

public plugin_end()
{
DestroyForward(fnFwdPlayerChilled);
DestroyForward(fnFwdPlayerFrozen);
}

public plugin_precache()
{
precache_model(MODEL_FROZEN);
glassGibs = precache_model(MODEL_GLASSGIBS);

precache_sound(SOUND_EXPLODE); // grenade explodes
precache_sound(SOUND_FROZEN); // player is frozen
precache_sound(SOUND_UNFROZEN); // frozen wears off
precache_sound(SOUND_CHILLED); // player is chilled
precache_sound(SOUND_PICKUP); // player buys frostnade

trailSpr = precache_model(SPRITE_TRAIL);
smokeSpr = precache_model(SPRITE_SMOKE);
exploSpr = precache_model(SPRITE_EXPLO);
}

public client_putinserver(id)
{
isChilled[id] = 0;
isFrozen[id] = 0;
frostKilled[id] = 0;
novaDisplay[id] = 0;
hasFrostNade[id] = 0;
lastWeapon[id] = 0;

if(czero && !czBotHams && is_user_bot(id) && get_pcvar_num(bot_quota) > 0)
set_task(0.1,"czbot_hook_ham",id);
}

public client_disconnect(id)
{
if(isChilled[id]) task_remove_chill(TASK_REMOVE_CHILL+id);
if(isFrozen[id]) task_remove_freeze(TASK_REMOVE_FREEZE+id);
}

// registering a ham hook for "player" won't register it for CZ bots,
// for some reason. so we have to register it by entity.
public czbot_hook_ham(id)
{
if(!czBotHams && is_user_connected(id) && is_user_bot(id) && get_pcvar_num(bot_quota) > 0)
{
RegisterHamFromEntity(Ham_Spawn,id,"ham_player_spawn",1);
RegisterHamFromEntity(Ham_Killed,id,"ham_player_killed",1);
RegisterHamFromEntity(Ham_Player_ResetMaxSpeed,id,"ham_player_resetmaxspeed",1);
czBotHams = 1;
}
}

/****************************************
* PRIMARY FUNCTIONS AND SUCH
****************************************/

public buy_frostnade(id)
{
if(!get_pcvar_num(pcv_enabled) || get_pcvar_num(pcv_override))
return PLUGIN_CONTINUE;

if(!is_user_alive(id)) return PLUGIN_HANDLED;

if(get_pcvar_num(pcv_buyzone) && !cs_get_user_buyzone(id))
{
// #Cstrike_NotInBuyZone won't work for some reason
client_print(id,print_center,"You are not in a buy zone.");

return PLUGIN_HANDLED;
}

if(!(get_pcvar_num(pcv_teams) & _:cs_get_user_team(id)))
{
// have to do it this way to format
message_begin(MSG_ONE,gmsgTextMsg,_,id);
write_byte(print_center);
write_string("#Alias_Not_Avail");
write_string("Frost Grenade");
message_end();

return PLUGIN_HANDLED;
}

if(hasFrostNade[id])
{
client_print(id,print_center,"#Cstrike_Already_Own_Weapon");
return PLUGIN_HANDLED;
}

new limit = get_pcvar_num(pcv_limit);
if(limit && nadesBought[id] >= limit)
{
client_print(id,print_center,"#Cstrike_TitlesTXT_Cannot_Carry_Anymore");
return PLUGIN_HANDLED;
}

new money = cs_get_user_money(id), price = get_pcvar_num(pcv_price);

// need more vespene gas
if(money < price)
{
client_print(id,print_center,"#Cstrike_TitlesTXT_Not_Enough_Money");

message_begin(MSG_ONE_UNRELIABLE,gmsgBlinkAcct,_,id);
write_byte(2);
message_end();

return PLUGIN_HANDLED;
}

// try to use smokegrenade, then flashbang, then hegrenade
new wpnid = CSW_SMOKEGRENADE, ammoid = AMMO_SMOKEGRENADE, wpnName[20] = "weapon_smokegrenade", type = get_pcvar_num(pcv_nadetypes);
if(!(type & NT_SMOKEGRENADE))
{
if(type & NT_FLASHBANG)
{
wpnid = CSW_FLASHBANG;
ammoid = AMMO_FLASHBANG;
wpnName = "weapon_flashbang";
}
else if(type & NT_HEGRENADE)
{
wpnid = CSW_HEGRENADE;
ammoid = AMMO_HEGRENADE;
wpnName = "weapon_hegrenade";
}
}

hasFrostNade[id] = wpnid;
nadesBought[id]++;
cs_set_user_money(id,money - price);

new ammo = cs_get_user_bpammo(id,wpnid);

// give him one
if(!ammo) give_item(id,wpnName);
else
{
cs_set_user_bpammo(id,wpnid,ammo+1);

// just so the player can see what kind it is on his HUD

message_begin(MSG_ONE,gmsgAmmoPickup,_,id);
write_byte(ammoid);
write_byte(ammo+1);
message_end();

message_begin(MSG_ONE,gmsgWeapPickup,_,id);
write_byte(wpnid);
message_end();

// won't play via cs_set_user_bpammo
engfunc(EngFunc_EmitSound,id,CHAN_ITEM,SOUND_PICKUP,VOL_NORM,ATTN_NORM,0,PITCH_NORM);
}

return PLUGIN_HANDLED;
}

// the round ends or starts
public event_round_change()
{
if(!get_pcvar_num(pcv_enabled)) return;

for(new i=1;i<=maxPlayers;i++)
{
if(is_user_alive(i))
{
if(isChilled) task_remove_chill(TASK_REMOVE_CHILL+i);
if(isFrozen) task_remove_freeze(TASK_REMOVE_FREEZE+i);
}
}
}

// the round ends
public event_round_end()
{
if(!get_pcvar_num(pcv_enabled)) return;

for(new i=1;i<=maxPlayers;i++)
{
if(is_user_alive(i))
{
if(isChilled) task_remove_chill(TASK_REMOVE_CHILL+i);
if(isFrozen) task_remove_freeze(TASK_REMOVE_FREEZE+i);
}
}
}

public fw_setmodel(ent,model[])
{
if(!get_pcvar_num(pcv_enabled)) return FMRES_IGNORED;

new owner = pev(ent,pev_owner);
if(!is_user_connected(owner)) return FMRES_IGNORED;

// this isn't going to explode
new Float:dmgtime;
pev(ent,pev_dmgtime,dmgtime);
if(dmgtime == 0.0) return FMRES_IGNORED;

new type, csw;
if(model[7] == 'w' && model[8] == '_')
{
switch(model[9])
{
case 'h': { type = NT_HEGRENADE; csw = CSW_HEGRENADE; }
case 'f': { type = NT_FLASHBANG; csw = CSW_FLASHBANG; }
case 's': { type = NT_SMOKEGRENADE; csw = CSW_SMOKEGRENADE; }
}
}
if(!type) return FMRES_IGNORED;

new team = _:cs_get_user_team(owner);

// have a frostnade (override off) ;OR; override enabled, on valid team, using valid frostnade type
if(hasFrostNade[owner] == csw || (get_pcvar_num(pcv_override)
&& (get_pcvar_num(pcv_teams) & team) && (get_pcvar_num(pcv_nadetypes) & type)))
{
hasFrostNade[owner] = 0;

set_pev(ent,pev_team,team);
set_pev(ent,pev_bInDuck,1); // flag it as a frostnade

new rgb[3], Float:rgbF[3];
get_rgb_colors(team,rgb);
IVecFVec(rgb, rgbF);

// glowshell
set_pev(ent,pev_rendermode,kRenderNormal);
set_pev(ent,pev_renderfx,kRenderFxGlowShell);
set_pev(ent,pev_rendercolor,rgbF);
set_pev(ent,pev_renderamt,16.0);

set_beamfollow(ent,10,10,rgb,100);
}

return FMRES_IGNORED;
}

// freeze a player in place whilst he's frozen
public fw_playerprethink(id)
{
/*if(isChilled[id])
{
// remember rendering changes
new fx = pev(id,pev_renderfx), Float:color[3], mode = pev(id,pev_rendermode), Float:amount;
pev(id,pev_rendercolor,color);
pev(id,pev_renderamt,amount);

if(fx != kRenderFxGlowShell)
{
oldRenderFx[id] = fx;
set_pev(id,pev_renderfx,kRenderFxGlowShell);
}
if(color[0] != glowColor[id][0] || color[1] != glowColor[id][1] || color[2] != glowColor[id][2])
{
oldRenderColor[id] = color;
set_pev(id,pev_rendercolor,glowColor[id]);
}
if(mode != kRenderNormal)
{
oldRenderMode[id] = mode;
set_pev(id,pev_rendermode,kRenderNormal);
}
if(amount != GLOW_AMOUNT)
{
oldRenderAmt[id] = amount;
set_pev(id,pev_renderamt,GLOW_AMOUNT);
}
}*/

if(isFrozen[id])
{
set_pev(id,pev_velocity,Float:{0.0,0.0,0.0}); // stop motion

new Float:gravity;
pev(id,pev_gravity,gravity);

// remember any gravity changes
if(gravity != 0.000000001 && gravity != 999999999.9)
oldGravity[id] = gravity;

// if are on the ground and about to jump, set the gravity too high to really do so
if((pev(id,pev_button) & IN_JUMP) && !(pev(id,pev_oldbuttons) & IN_JUMP) && (pev(id,pev_flags) & FL_ONGROUND))
set_pev(id,pev_gravity,999999999.9);

// otherwise, set the gravity so low that they don't fall
else set_pev(id,pev_gravity,0.000000001);
}

return FMRES_IGNORED;
}

// override grenade kill message with skull and crossbones
public msg_deathmsg(msg_id,msg_dest,msg_entity)
{
new victim = get_msg_arg_int(2);
if(!is_user_connected(victim) || !frostKilled[victim]) return PLUGIN_CONTINUE;

static weapon[8];
get_msg_arg_string(4,weapon,7);
if(equal(weapon,"grenade")) set_msg_arg_string(4,"frostgrenade");

frostKilled[victim] = 0;
return PLUGIN_CONTINUE;
}

// maintain speed on weapon changes
public event_curweapon(id)
{
new weapon = read_data(2);

if(get_pcvar_num(pcv_enabled) && is_user_alive(id) && weapon != lastWeapon[id]
&& get_pcvar_num(pcv_icon) == ICON_HASNADE)
{
manage_icon(id,ICON_HASNADE);
}

lastWeapon[id] = weapon;
}

// a player's grenade ammo changes
public event_ammox(id)
{
if(get_pcvar_num(pcv_enabled) && is_user_connected(id))
{
// just lost my frost grenade
if(hasFrostNade[id] && !cs_get_user_bpammo(id,hasFrostNade[id]))
{
hasFrostNade[id] = 0;
}

if(get_pcvar_num(pcv_icon) == ICON_HASNADE)
{
manage_icon(id,ICON_HASNADE);
}
}
}

// rezzed
public ham_player_spawn(id)
{
nadesBought[id] = 0;

if(is_user_alive(id))
{
if(isChilled[id]) task_remove_chill(TASK_REMOVE_CHILL+id);
if(isFrozen[id]) task_remove_freeze(TASK_REMOVE_FREEZE+id);
}

return HAM_IGNORED;
}

// killed to death
public ham_player_killed(id)
{
hasFrostNade[id] = 0;

if(get_pcvar_num(pcv_enabled) && get_pcvar_num(pcv_icon) == ICON_HASNADE)
{
manage_icon(id,ICON_HASNADE);
}

if(isChilled[id]) task_remove_chill(TASK_REMOVE_CHILL+id);
if(isFrozen[id]) task_remove_freeze(TASK_REMOVE_FREEZE+id);

return HAM_IGNORED;
}

// movement speed is changed
public ham_player_resetmaxspeed(id)
{
if(get_pcvar_num(pcv_enabled))
{
set_user_chillfreeze_speed(id);
}

return HAM_IGNORED;
}

// grenade is ticking away
public ham_grenade_think(ent)
{
// not a frostnade
if(!pev_valid(ent) || !pev(ent,pev_bInDuck)) return HAM_IGNORED;

new Float:dmgtime;
pev(ent,pev_dmgtime,dmgtime);
if(dmgtime > get_gametime()) return HAM_IGNORED;

// and boom goes the dynamite
frostnade_explode(ent);

return HAM_SUPERCEDE;
}

// a frost grenade explodes
public frostnade_explode(ent)
{
new nadeTeam = pev(ent,pev_team), owner = pev(ent,pev_owner), Float:nadeOrigin[3];
pev(ent,pev_origin,nadeOrigin);

// make the smoke
message_begin_fl(MSG_PVS,SVC_TEMPENTITY,nadeOrigin,0);
write_byte(TE_SMOKE);
write_coord_fl(nadeOrigin[0]); // x
write_coord_fl(nadeOrigin[1]); // y
write_coord_fl(nadeOrigin[2]); // z
write_short(smokeSpr); // sprite
write_byte(random_num(30,40)); // scale
write_byte(5); // framerate
message_end();

// explosion
create_blast(nadeTeam,nadeOrigin);
emit_sound(ent,CHAN_ITEM,SOUND_EXPLODE,VOL_NORM,ATTN_NORM,0,PITCH_HIGH);

// cache our cvars
new ff = get_pcvar_num(mp_friendlyfire), Float:by_radius = get_pcvar_float(pcv_by_radius),
hitself = get_pcvar_num(pcv_hitself), los = get_pcvar_num(pcv_los), Float:maxdamage = get_pcvar_float(pcv_maxdamage),
Float:mindamage = get_pcvar_float(pcv_mindamage), Float:chill_maxchance = get_pcvar_float(pcv_chill_maxchance),
Float:chill_minchance = get_pcvar_float(pcv_chill_minchance), Float:freeze_maxchance, Float:freeze_minchance;

if(!by_radius)
{
freeze_maxchance = get_pcvar_float(pcv_freeze_maxchance);
freeze_minchance = get_pcvar_float(pcv_freeze_minchance);
}

new ta, Float:targetOrigin[3], Float:distance, tr = create_tr2(), Float:fraction, Float:damage, gotFrozen = 0;
for(new target=1;target<=maxPlayers;target++)
{
// dead, invincible, or self attack that is not allowed
if(!is_user_alive(target) || pev(target,pev_takedamage) == DAMAGE_NO
|| (pev(target,pev_flags) & FL_GODMODE) ||(target == owner && !hitself))
continue;

// this is a team attack with ff disabled, excluding self attack
ta = (_:cs_get_user_team(target) == nadeTeam);
if(ta && !ff && target != owner) continue;

pev(target,pev_origin,targetOrigin);
distance = vector_distance(nadeOrigin,targetOrigin);

// too far
if(distance > FROST_RADIUS) continue;

// check line of sight
if(los)
{
nadeOrigin[2] += 2.0;
engfunc(EngFunc_TraceLine,nadeOrigin,targetOrigin,DONT_IGNORE_MONSTERS,ent,tr);
nadeOrigin[2] -= 2.0;

get_tr2(tr,TR_flFraction,fraction);
if(fraction != 1.0 && get_tr2(tr,TR_pHit) != target) continue;
}

// damaged
if(maxdamage > 0.0)
{
damage = radius_calc(distance,FROST_RADIUS,maxdamage,mindamage);
if(ta) damage /= 2.0; // half damage for friendlyfire

if(damage > 0.0)
{
frostKilled[target] = 1;
ExecuteHamB(Ham_TakeDamage,target,ent,owner,damage,DMG_GRENADE);
if(!is_user_alive(target)) continue; // dead now
frostKilled[target] = 0;
}
}

// frozen
if((by_radius && radius_calc(distance,FROST_RADIUS,100.0,0.0) >= by_radius)
|| (!by_radius && random_num(1,100) <= floatround(radius_calc(distance,FROST_RADIUS,freeze_maxchance,freeze_minchance))))
{
if(freeze_player(target,owner,nadeTeam))
{
gotFrozen = 1;
emit_sound(target,CHAN_ITEM,SOUND_FROZEN,1.0,ATTN_NONE,0,PITCH_LOW);
}
}

// chilled
if(by_radius || random_num(1,100) <= floatround(radius_calc(distance,FROST_RADIUS,chill_maxchance,chill_minchance)))
{
if(chill_player(target,owner,nadeTeam))
{
if(!gotFrozen) emit_sound(target,CHAN_ITEM,SOUND_CHILLED,VOL_NORM,ATTN_NORM,0,PITCH_HIGH);
}
}
}

free_tr2(tr);
set_pev(ent,pev_flags,pev(ent,pev_flags)|FL_KILLME);
}

freeze_player(id,attacker,nadeTeam)
{
new fwdRetVal = PLUGIN_CONTINUE;
ExecuteForward(fnFwdPlayerFrozen, fwdRetVal, id, attacker);

if(fwdRetVal == PLUGIN_HANDLED || fwdRetVal == PLUGIN_HANDLED_MAIN)
{
return 0;
}

if(!isFrozen[id])
{
pev(id,pev_gravity,oldGravity[id]);

// register our forward only when we need it
if(!fmFwdPPT)
{
fmFwdPPT = register_forward(FM_PlayerPreThink,"fw_playerprethink",0);
}
}

isFrozen[id] = nadeTeam;

set_pev(id,pev_velocity,Float:{0.0,0.0,0.0});
set_user_chillfreeze_speed(id);

new Float:duration = get_pcvar_float(pcv_freeze_duration), Float:variance = get_pcvar_float(pcv_freeze_variance);
duration += random_float(-variance,variance);

remove_task(TASK_REMOVE_FREEZE+id);
set_task(duration,"task_remove_freeze",TASK_REMOVE_FREEZE+id);

if(!pev_valid(novaDisplay[id])) create_nova(id);

if(get_pcvar_num(pcv_icon) == ICON_ISCHILLED) manage_icon(id,ICON_ISCHILLED);

return 1;
}

public task_remove_freeze(taskid)
{
new id = taskid-TASK_REMOVE_FREEZE;

if(pev_valid(novaDisplay[id]))
{
new Float:origin[3];
pev(novaDisplay[id],pev_origin,origin);

// add some tracers
message_begin_fl(MSG_PVS,SVC_TEMPENTITY,origin,0);
write_byte(TE_IMPLOSION);
write_coord_fl(origin[0]); // x
write_coord_fl(origin[1]); // y
write_coord_fl(origin[2] + 8.0); // z
write_byte(64); // radius
write_byte(10); // count
write_byte(3); // duration
message_end();

// add some sparks
message_begin_fl(MSG_PVS,SVC_TEMPENTITY,origin,0);
write_byte(TE_SPARKS);
write_coord_fl(origin[0]); // x
write_coord_fl(origin[1]); // y
write_coord_fl(origin[2]); // z
message_end();

// add the shatter
message_begin_fl(MSG_PAS,SVC_TEMPENTITY,origin,0);
write_byte(TE_BREAKMODEL);
write_coord_fl(origin[0]); // x
write_coord_fl(origin[1]); // y
write_coord_fl(origin[2] + 24.0); // z
write_coord_fl(16.0); // size x
write_coord_fl(16.0); // size y
write_coord_fl(16.0); // size z
write_coord(random_num(-50,50)); // velocity x
write_coord(random_num(-50,50)); // velocity y
write_coord_fl(25.0); // velocity z
write_byte(10); // random velocity
write_short(glassGibs); // model
write_byte(10); // count
write_byte(25); // life
write_byte(BREAK_GLASS); // flags
message_end();

emit_sound(novaDisplay[id],CHAN_ITEM,SOUND_UNFROZEN,VOL_NORM,ATTN_NORM,0,PITCH_LOW);
set_pev(novaDisplay[id],pev_flags,pev(novaDisplay[id],pev_flags)|FL_KILLME);
}

isFrozen[id] = 0;
novaDisplay[id] = 0;

// unregister forward if we are no longer using it
unregister_prethink();

if(!is_user_connected(id)) return;

// restore speed, but then check for chilled
ExecuteHam(Ham_Player_ResetMaxSpeed, id);
set_user_chillfreeze_speed(id);

set_pev(id,pev_gravity,oldGravity[id]);

// sometimes trail fades during freeze, reapply
if(isChilled[id])
{
new rgb[3];
get_rgb_colors(isChilled[id],rgb);
set_beamfollow(id,30,8,rgb,100);
}

if(get_pcvar_num(pcv_icon) == ICON_ISCHILLED) manage_icon(id,ICON_ISCHILLED);
}

chill_player(id,attacker,nadeTeam)
{
new fwdRetVal = PLUGIN_CONTINUE;
ExecuteForward(fnFwdPlayerChilled, fwdRetVal, id, attacker);

if(fwdRetVal == PLUGIN_HANDLED || fwdRetVal == PLUGIN_HANDLED_MAIN)
{
return 0;
}

// we aren't already been chilled
if(!isChilled[id])
{
oldRenderFx[id] = pev(id,pev_renderfx);
pev(id,pev_rendercolor,oldRenderColor[id]);
oldRenderMode[id] = pev(id,pev_rendermode);
pev(id,pev_renderamt,oldRenderAmt[id]);

isChilled[id] = nadeTeam; // fix -- thanks Exolent

// register our forward only when we need it
//if(!fmFwdPPT) fmFwdPPT = register_forward(FM_PlayerPreThink,"fw_playerprethink",0);
}

isChilled[id] = nadeTeam;

set_user_chillfreeze_speed(id);

new Float:duration = get_pcvar_float(pcv_chill_duration), Float:variance = get_pcvar_float(pcv_chill_variance);
duration += random_float(-variance,variance);

remove_task(TASK_REMOVE_CHILL+id);
set_task(duration,"task_remove_chill",TASK_REMOVE_CHILL+id);

new rgb[3];
get_rgb_colors(nadeTeam,rgb);

IVecFVec(rgb, glowColor[id]);

// glowshell
set_user_rendering(id, kRenderFxGlowShell, rgb[0], rgb[1], rgb[2], kRenderNormal, floatround(GLOW_AMOUNT));

set_beamfollow(id,30,8,rgb,100);

// I decided to let the frostnade tint override a flashbang,
// because if you are frozen, then you have much bigger problems.

// add a blue tint to their screen
message_begin(MSG_ONE,gmsgScreenFade,_,id);
write_short(_:(4096.0 * duration)); // duration
write_short(_:(3072.0 * duration)); // hold time (4096.0 * 0.75)
write_short(FFADE_IN); // flags
write_byte(rgb[0]); // red
write_byte(rgb[1]); // green
write_byte(rgb[2]); // blue
write_byte(100); // alpha
message_end();

if(get_pcvar_num(pcv_icon) == ICON_ISCHILLED) manage_icon(id,ICON_ISCHILLED);

return 1;
}

public task_remove_chill(taskid)
{
new id = taskid-TASK_REMOVE_CHILL;

isChilled[id] = 0;

// unregister forward if we are no longer using it
//unregister_prethink();

if(!is_user_connected(id)) return;

// set speed to normal, then check for frozen
ExecuteHam(Ham_Player_ResetMaxSpeed, id);
set_user_chillfreeze_speed(id);

// reset rendering
set_user_rendering(id, oldRenderFx[id], floatround(oldRenderColor[id][0]), floatround(oldRenderColor[id][1]), floatround(oldRenderColor[id][2]), oldRenderMode[id], floatround(oldRenderAmt[id]));

clear_beamfollow(id);

// calculate end of flashbang
new Float:flashedUntil = get_pdata_float(id,m_flFlashedUntil),
Float:flashHoldTime = get_pdata_float(id,m_flFlashHoldTime),
Float:endOfFlash = flashedUntil + (flashHoldTime * 0.67);

// not blinded
if(get_gametime() >= endOfFlash)
{
// clear tint
message_begin(MSG_ONE,gmsgScreenFade,_,id);
write_short(0); // duration
write_short(0); // hold time
write_short(FFADE_IN); // flags
write_byte(0); // red
write_byte(0); // green
write_byte(0); // blue
write_byte(255); // alpha
message_end();
}

if(get_pcvar_num(pcv_icon) == ICON_ISCHILLED) manage_icon(id,ICON_ISCHILLED);
}

// make a frost nova at a player's feet
create_nova(id)
{
new nova = engfunc(EngFunc_CreateNamedEntity,engfunc(EngFunc_AllocString,"info_target"));

engfunc(EngFunc_SetSize,nova,Float:{-8.0,-8.0,-4.0},Float:{8.0,8.0,4.0});
engfunc(EngFunc_SetModel,nova,MODEL_FROZEN);

// random orientation
new Float:angles[3];
angles[1] = random_float(0.0,360.0);
set_pev(nova,pev_angles,angles);

// put it at their feet
new Float:novaOrigin[3];
pev(id,pev_origin,novaOrigin);
engfunc(EngFunc_SetOrigin,nova,novaOrigin);

// make it translucent
new rgb[3];
get_rgb_colors(isFrozen[id], rgb);
IVecFVec(rgb, angles); // let's just use angles

set_pev(nova,pev_rendercolor,angles); // see above
set_pev(nova,pev_rendermode,kRenderTransAlpha);
set_pev(nova,pev_renderfx,kRenderFxGlowShell);
set_pev(nova,pev_renderamt,128.0);

novaDisplay[id] = nova;
}

// manage our snowflake (show it, hide it, flash it?)
manage_icon(id,mode)
{
new status, team = _:cs_get_user_team(id);

// so if I have it, status = 1; if I also have it out, status = 2
if(mode == ICON_HASNADE)
{
if(hasFrostNade[id])
{
status = 1;
if(get_user_weapon(id) == hasFrostNade[id]) status = 2;
}
else if(get_pcvar_num(pcv_override) && (get_pcvar_num(pcv_teams) & team))
{
new weapon = get_user_weapon(id), types = get_pcvar_num(pcv_nadetypes);

if(types & NT_HEGRENADE)
{
if(pev(id,pev_weapons) & (1<<CSW_HEGRENADE))
{
status = 1;
if(weapon == CSW_HEGRENADE) status = 2;
}
}
if(status != 2 && (types & NT_SMOKEGRENADE))
{
if(pev(id,pev_weapons) & (1<<CSW_SMOKEGRENADE))
{
status = 1;
if(weapon == CSW_SMOKEGRENADE) status = 2;
}
}
if(status != 2 && (types & NT_FLASHBANG))
{
if(pev(id,pev_weapons) & (1<<CSW_FLASHBANG))
{
status = 1;
if(weapon == CSW_FLASHBANG) status = 2;
}
}
}
}
else // ICON_ISCHILLED
{
if(isFrozen[id]) status = 2;
else if(isChilled[id]) status = 1;
}

new rgb[3];
if(status) get_rgb_colors(team,rgb); // only get colors if we need to

message_begin(MSG_ONE,gmsgStatusIcon,_,id);
write_byte(status); // status (0=hide, 1=show, 2=flash)
write_string("dmg_cold"); // sprite name
write_byte(rgb[0]); // red
write_byte(rgb[1]); // green
write_byte(rgb[2]); // blue
message_end();
}

/****************************************
* UTILITY FUNCTIONS
****************************************/

// check if prethink is still being used, if not, unhook it
unregister_prethink()
{
if(fmFwdPPT)
{
new i;
for(i=1;i<=maxPlayers;i++) if(/*isChilled ||*/ isFrozen) break;
if(i > maxPlayers)
{
unregister_forward(FM_PlayerPreThink,fmFwdPPT,0);
fmFwdPPT = 0;
}
}
}

// make the explosion effects
create_blast(team,Float:origin[3])
{
new rgb[3];
get_rgb_colors(team,rgb);

// smallest ring
message_begin_fl(MSG_PVS,SVC_TEMPENTITY,origin,0);
write_byte(TE_BEAMCYLINDER);
write_coord_fl(origin[0]); // x
write_coord_fl(origin[1]); // y
write_coord_fl(origin[2]); // z
write_coord_fl(origin[0]); // x axis
write_coord_fl(origin[1]); // y axis
write_coord_fl(origin[2] + 385.0); // z axis
write_short(exploSpr); // sprite
write_byte(0); // start frame
write_byte(0); // framerate
write_byte(4); // life
write_byte(60); // width
write_byte(0); // noise
write_byte(rgb[0]); // red
write_byte(rgb[1]); // green
write_byte(rgb[2]); // blue
write_byte(100); // brightness
write_byte(0); // speed
message_end();

// medium ring
message_begin_fl(MSG_PVS,SVC_TEMPENTITY,origin,0);
write_byte(TE_BEAMCYLINDER);
write_coord_fl(origin[0]); // x
write_coord_fl(origin[1]); // y
write_coord_fl(origin[2]); // z
write_coord_fl(origin[0]); // x axis
write_coord_fl(origin[1]); // y axis
write_coord_fl(origin[2] + 470.0); // z axis
write_short(exploSpr); // sprite
write_byte(0); // start frame
write_byte(0); // framerate
write_byte(4); // life
write_byte(60); // width
write_byte(0); // noise
write_byte(rgb[0]); // red
write_byte(rgb[1]); // green
write_byte(rgb[2]); // blue
write_byte(100); // brightness
write_byte(0); // speed
message_end();

// largest ring
message_begin_fl(MSG_PVS,SVC_TEMPENTITY,origin,0);
write_byte(TE_BEAMCYLINDER);
write_coord_fl(origin[0]); // x
write_coord_fl(origin[1]); // y
write_coord_fl(origin[2]); // z
write_coord_fl(origin[0]); // x axis
write_coord_fl(origin[1]); // y axis
write_coord_fl(origin[2] + 555.0); // z axis
write_short(exploSpr); // sprite
write_byte(0); // start frame
write_byte(0); // framerate
write_byte(4); // life
write_byte(60); // width
write_byte(0); // noise
write_byte(rgb[0]); // red
write_byte(rgb[1]); // green
write_byte(rgb[2]); // blue
write_byte(100); // brightness
write_byte(0); // speed
message_end();

// light effect
message_begin_fl(MSG_PAS,SVC_TEMPENTITY,origin,0);
write_byte(TE_DLIGHT);
write_coord_fl(origin[0]); // x
write_coord_fl(origin[1]); // y
write_coord_fl(origin[2]); // z
write_byte(_:(FROST_RADIUS/5.0)); // radius
write_byte(rgb[0]); // r
write_byte(rgb[1]); // g
write_byte(rgb[2]); // b
write_byte(8); // life
write_byte(60); // decay rate
message_end();
}

// give an entity a beam trail
set_beamfollow(ent,life,width,rgb[3],brightness)
{
clear_beamfollow(ent);

message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
write_byte(TE_BEAMFOLLOW);
write_short(ent); // entity
write_short(trailSpr); // sprite
write_byte(life); // life
write_byte(width); // width
write_byte(rgb[0]); // red
write_byte(rgb[1]); // green
write_byte(rgb[2]); // blue
write_byte(brightness); // brightness
message_end();
}

// removes beam trails from an entity
clear_beamfollow(ent)
{
message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
write_byte(TE_KILLBEAM);
write_short(ent); // entity
message_end();
}

// gets RGB colors from the cvar
get_rgb_colors(team,rgb[3])
{
static color[12], parts[3][4];
get_pcvar_string(pcv_color,color,11);

// if cvar is set to "team", use colors based on the given team
if(equali(color,"team",4))
{
if(team == 1)
{
rgb[0] = 150;
rgb[1] = 0;
rgb[2] = 0;
}
else
{
rgb[0] = 0;
rgb[1] = 0;
rgb[2] = 150;
}
}
else
{
parse(color,parts[0],3,parts[1],3,parts[2],3);
rgb[0] = str_to_num(parts[0]);
rgb[1] = str_to_num(parts[1]);
rgb[2] = str_to_num(parts[2]);
}
}

// scale a value equally (inversely?) with the distance that something
// is from the center of another thing. that makes pretty much no sense,
// so basically, the closer we are to the center of a ring, the higher
// our value gets.
//
// EXAMPLE: distance = 60.0, radius = 240.0, maxVal = 100.0, minVal = 20.0
// we are 0.75 (1.0-(60.0/240.0)) of the way to the radius, so scaled with our
// values, it comes out to 80.0 (20.0 + (0.75 * (100.0 - 20.0)))
Float:radius_calc(Float:distance,Float:radius,Float:maxVal,Float:minVal)
{
if(maxVal <= 0.0) return 0.0;
if(minVal >= maxVal) return minVal;
return minVal + ((1.0 - (distance / radius)) * (maxVal - minVal));
}

// sets a user's chilled/frozen speed if applicable
// (NOTE: does NOT reset his maxspeed if he is not chilled/frozen)
set_user_chillfreeze_speed(id)
{
if(isFrozen[id])
{
set_user_maxspeed(id, 1.0);
}
else if(isChilled[id])
{
set_user_maxspeed(id, get_default_maxspeed(id)*(get_pcvar_float(pcv_chill_speed)/100.0));
}
}

// gets the maxspeed a user should have, given his current weapon
stock Float:get_default_maxspeed(id)
{
new wEnt = get_pdata_cbase(id, m_pActiveItem), Float:result = 250.0;

if(pev_valid(wEnt))
{
ExecuteHam(Ham_CS_Item_GetMaxSpeed, wEnt, result);
}

return result;
}

[burakxd383]

sorunu kendi çabamla çözdüm uyarladım konu kilit**