/*==============================================================================================================
	Z	O	M	B	I	E	-	P	L	A	G	U	E
===============================================================================================================*/

/*====================
	INCLUDES
====================*/

#include <amxmodx>
#include <amxmisc>
#include <fun>
#include <cstrike>
#include <hamsandwich>
#include <fakemeta>
#include <engine>
#include <dhudmessage>
#include <oldmenu>

/*=================
	ENUMS
=================*/

enum _:EXTRA_VARS
{
	PLUGIN_NAME, PLUGIN_VERSION, PLUGIN_AUTHOR,

	BIG_START_GAME_ROUND = 0, BIG_END_GAME_ROUND, BIG_REGISTER_HAMS_BOTS,

	BIP_IS_CONNECTED = 0, BIP_IS_ALIVE, BIP_IS_ZOMBIE, BIP_RESPAWN_AS_ZOMBIE, MAX_PLAYER_BIT_VARS = 32,

	CLASS_HUMAN = 0, CLASS_FIRST_ZOMBIE, CLASS_ZOMBIE,

	TEAM_UNASSIGNED = 0, TEAM_TERRORIST, TEAM_COUNTER_TERRORIST, TEAM_SPECTATOR,

	MODE_NONE = 0, MODE_INFECTION,

	MESSAGE_HIDEWEAPON = 0, MESSAGE_CROSSHAIR, MESSAGE_TEAMINFO, MESSAGE_DEATHMSG, MESSAGE_SCOREATTRIB,
	MESSAGE_SCREENFADE, MESSAGE_SAYTEXT, MAX_CACHE_MESSAGES,

	CVAR_DELAY = 0,

	CVAR_RESPAWN,
	CVAR_RESPAWN_DELAY,
	CVAR_RESPAWN_AS,
	CVAR_RESPAWN_ZOMBIES,
	CVAR_RESPAWN_HUMANS,
	CVAR_INFECTION_RESPAWN,

	MAX_CUSTOM_CVARS,

	HIDE_HUDS = (1<<5)|(1<<3),

	OFFSET_PRIVATE_DATA = 2, OFFSET_CBASEPLAYERITEM = 4, OFFSET_CBASEPLAYER = 5, OFFSET_ITEM_PLAYER = 41,
	OFFSET_CS_TEAM = 114, OFFSET_CLIENT_MAP_ZONE = 235, OFFSET_CLIENT_DEATHS = 444,

	HUD_CHANNEL_ONE = 1, MAX_HUD_CHANNELS,

	EFFECT_ZOMBIE = 0, EFFECT_FIRST_ZOMBIE, EFFECT_RESPAWN_ZOMBIE,

	ENTITY_COUNT_DOWN = 0, ENTITY_CACHE_CVARS, ENTITY_HUD_STATS, MAX_CUSTOM_ENTITYS,

	COUNT_ALIVE_PLAYERS, COUNT_PLAYING_PLAYERS = 0, COUNT_HUMANS,

	HUMAN_THIS_LIGHT = 0, ZOMBIE_THIS_LIGHT, NVG_THIS_LIGHT,

	FFADE_IN = 0x0000, FFADE_STAYOUT = 0x0004,

	MAIN_MENU = 0, ARMAMENT_MAIN_MENU, ARMAMENT_INDUSTRY_MENU,

	CHAT_COLOR_GREY = 40, CHAT_COLOR_RED, CHAT_COLOR_BLUE
}

enum _:TASK_LIST (+= 10)
{
	TASK_CHOOSE_ROUND_MOD = 1000
}

enum _:CVARS_STRUCT
{
	SZ_CVAR_NAME[27],
	SZ_CVAR_VALUE[5]
}

enum GLOBAL_VARS
{
	GI_MAX_PLAYERS,
	GI_FORWARD_SPAWN,
	GI_COUNT_DOWN,
	GI_CURRENT_ROUND_MODE,

	GA_CACHE_MESSAGES[MAX_CACHE_MESSAGES],
	GA_CUSTOM_CVARS[MAX_CUSTOM_CVARS],
	GA_CACHE_CVARS[MAX_CUSTOM_CVARS],
	GA_HUD_CHANNEL[MAX_HUD_CHANNELS]
}

enum _:PLAYER_VARS
{
	PI_CLASS,
	PI_CURRENT_HEALTH,
	PI_CURRENT_ARMOR,

	PSZ_CLIENT_NAME[32]
}

/*==================
	MACROS
==================*/

#define M_PlayWithBots

#define M_SetGlobalBit(%1,%2)		%1 |= (1<<%2)
#define M_ClearGlobalBit(%1,%2)		%1 &= ~(1<<%2)
#define M_HasGlobalBit(%1,%2)		(%1 & (1<<%2))

#define M_SetPlayerBit(%1,%2) 		%1 |= (1<<(%2&31))
#define M_ClearPlayerBit(%1,%2)		%1 &= ~(1<<(%2&31))
#define M_HasPlayerBit(%1,%2)		(%1 & (1<<(%2&31)))

#define M_SwitchGlobalBool(%1)		%1 = !%1
#define M_IsBoolActive(%1)		(%1 ? true : false)

#define M_CountDownThink		1.0
#define M_CacheCvarsThink		0.3
#define M_HudStatsThink			0.1

/*==================
	CONSTS
==================*/

new const C_PluginInfo[][] =
{
	"ZOMBIE PLAGUE",
	"0.1b",
	"Chamo. & matrix123"
}

new const C_CsTeamNames[][] =
{
	"UNASSIGNED",
	"TERRORIST",
	"CT",
	"SPECTATOR"
}

new const C_CacheMessages[MAX_CACHE_MESSAGES][] =
{
	"HideWeapon",
	"Crosshair",
	"TeamInfo",
	"DeathMsg",
	"ScoreAttrib",
	"ScreenFade",
	"SayText"
}

new const C_CustomCvars[MAX_CUSTOM_CVARS][CVARS_STRUCT] =
{
	{ "ZP_Delay",				"10" },

	{ "ZP_Respawn",				"1" },
	{ "ZP_Respawn_Delay",			"5.0" },
	{ "ZP_Respawn_As",			"1" },
	{ "ZP_Respawn_Zombies",			"1" },
	{ "ZP_Respawn_Humans",			"1" },
	{ "ZP_Respawn_On_Infection",		"1" }
}

new const C_LightStyleValues[][] =
{
	"c",
	"h",
	"z"
}

new const C_FogValues[][] =
{
	"0.0050",
	"105 105 105"
}

new const C_CountDownClassName[] = "CountDown"
new const C_CacheCvarsClassName[] = "CacheCvars"
new const C_HudStatsClassName[] = "HUDStats"

/*================
	VARS
================*/

// Integers
new I_GlobalBitVars, I_PlayerBitVars[MAX_PLAYER_BIT_VARS];

// Arrays
new A_GlobalVars[GLOBAL_VARS], A_PlayerVars[33][PLAYER_VARS], A_CustomEntitys[MAX_CUSTOM_ENTITYS]

/*=============================================================
			PLUGIN'S FORWARDS
=============================================================*/

public plugin_precache()
{
	new I_Ent = create_entity("hostage_entity")

	if (is_valid_ent(I_Ent))
	{
		entity_set_origin(I_Ent, Float:{ 8192.0, 8192.0, 8192.0 })
		DispatchSpawn(I_Ent)
	}

	do
		I_Ent = create_entity("env_snow");
	while (!is_valid_ent(I_Ent))

	do
		I_Ent = create_entity("env_fog");
	while (!is_valid_ent(I_Ent))

	if (is_valid_ent(I_Ent))
	{
		DispatchKeyValue(I_Ent, "density", C_FogValues[0]);
		DispatchKeyValue(I_Ent, "rendercolor", C_FogValues[1]);
	}

	A_GlobalVars[GI_FORWARD_SPAWN] = register_forward(FM_Spawn, "FM_Spawn_Pre")
}

public plugin_init()
{
	register_plugin(C_PluginInfo[PLUGIN_NAME], C_PluginInfo[PLUGIN_VERSION], C_PluginInfo[PLUGIN_VERSION])

	new I;
	new const C_WeaponsEntsNames[][] =
	{
		"", "weapon_p228", "", "weapon_scout", "weapon_hegrenade", "weapon_xm1014", "weapon_c4", "weapon_mac10",
		"weapon_aug", "weapon_smokegrenade", "weapon_elite", "weapon_fiveseven", "weapon_ump45", "weapon_sg550",
		"weapon_galil", "weapon_famas", "weapon_usp", "weapon_glock18", "weapon_awp", "weapon_mp5navy", "weapon_m249",
		"weapon_m3", "weapon_m4a1", "weapon_tmp", "weapon_g3sg1", "weapon_flashbang", "weapon_deagle", "weapon_sg552",
		"weapon_ak47", "weapon_knife", "weapon_p90"
	}

	register_event("HLTV", "EVENT_HLTV", "a", "1=0", "2=0")
	register_logevent("LOGEVENT_RoundEnd", 2, "1=Round_End")

	RegisterHam(Ham_Spawn, "player", "HAM_PLAYER_Spawn_Post", true)
	RegisterHam(Ham_TraceAttack, "player", "HAM_PLAYER_TraceAttack_Pre")
	RegisterHam(Ham_TakeDamage, "player", "HAM_PLAYER_TakeDamage_Pre")
	RegisterHam(Ham_Killed, "player", "HAM_PLAYER_Killed_Post", true)

	for (I = 0; I < sizeof (C_WeaponsEntsNames); I++)
	{
		if (C_WeaponsEntsNames[I][0])
			RegisterHam(Ham_Item_Deploy, C_WeaponsEntsNames[I], "Ham_Item_Deploy_Post", true)
	}

	RegisterHam(Ham_Touch, "weaponbox", "HAM_WEAPON_Touch_Pre")
	RegisterHam(Ham_Touch, "weapon_shield", "HAM_WEAPON_Touch_Pre")

	register_think(C_CountDownClassName, "THINK_CountDown")
	register_think(C_CacheCvarsClassName, "THINK_CacheCvars")
	register_think(C_HudStatsClassName, "THINK_HudStats")

	register_forward(FM_ClientKill, "FM_ClientKill_Pre")
	unregister_forward(FM_Spawn, A_GlobalVars[GI_FORWARD_SPAWN])

	register_clcmd("chooseteam", "CLCOMMAND_ChooseTeam")

	for (I = 0; I < MAX_CACHE_MESSAGES; I++)
		A_GlobalVars[GA_CACHE_MESSAGES][I] = get_user_msgid(C_CacheMessages[I])

	register_message(get_user_msgid("TextMsg"), "MESSAGE_TextMsg")
	register_message(get_user_msgid("Health"), "MESSAGE_Health")
	register_message(get_user_msgid("StatusIcon"), "MESSAGE_StatusIcon")
	register_message(get_user_msgid("Battery"), "MESSAGE_Battery")
	register_message(get_user_msgid("NVGToggle"), "MESSAGE_NVGToggle")

	A_GlobalVars[GI_MAX_PLAYERS] = get_maxplayers()

	for (I = 0; I < MAX_CUSTOM_CVARS; I++)
		A_GlobalVars[GA_CUSTOM_CVARS][I] = register_cvar(C_CustomCvars[I][SZ_CVAR_NAME], C_CustomCvars[I][SZ_CVAR_VALUE])


	do
		A_CustomEntitys[ENTITY_COUNT_DOWN] = create_entity("info_target")
	while (!IsValidEntity(A_CustomEntitys[ENTITY_COUNT_DOWN]))

	entity_set_string(A_CustomEntitys[ENTITY_COUNT_DOWN], EV_SZ_classname, C_CountDownClassName)
	entity_set_float(A_CustomEntitys[ENTITY_COUNT_DOWN], EV_FL_nextthink, (GetCurrentTime()+M_CountDownThink))

	do
		A_CustomEntitys[ENTITY_CACHE_CVARS] = create_entity("info_target")
	while (!IsValidEntity(A_CustomEntitys[ENTITY_CACHE_CVARS]))

	entity_set_string(A_CustomEntitys[ENTITY_CACHE_CVARS], EV_SZ_classname, C_CacheCvarsClassName)
	entity_set_float(A_CustomEntitys[ENTITY_CACHE_CVARS], EV_FL_nextthink, (GetCurrentTime()+M_CacheCvarsThink))

	do
		A_CustomEntitys[ENTITY_HUD_STATS] = create_entity("info_target")
	while (!IsValidEntity(A_CustomEntitys[ENTITY_HUD_STATS]))

	entity_set_string(A_CustomEntitys[ENTITY_HUD_STATS], EV_SZ_classname, C_HudStatsClassName)
	entity_set_float(A_CustomEntitys[ENTITY_HUD_STATS], EV_FL_nextthink, (GetCurrentTime()+M_HudStatsThink))

	for (I = 0; I < MAX_HUD_CHANNELS; I++)
		A_GlobalVars[GA_HUD_CHANNEL][I] = CreateHudSyncObj()

	oldmenu_register()






	//register_event("CurWeapon", "TEST", "b", "1=1")
}

/*
public TEST(id)
{
	static lol;

	if (++lol >= 100)
		return;

	log_amx("TEST call after: %.10f game time", get_gametime())
}
*/




public plugin_cfg()
{
	set_task(0.3, "EVENT_HLTV")
}

/*=============================================================
			CLIENT'S FORWARDS
=============================================================*/

public client_putinserver(I_Client)
{
	M_SetPlayerBit(I_PlayerBitVars[BIP_IS_CONNECTED], I_Client)
	get_user_name(I_Client, A_PlayerVars[I_Client][PSZ_CLIENT_NAME], charsmax(A_PlayerVars[][PSZ_CLIENT_NAME]))

	#if defined PlayWithBots
	{
		if (is_user_bot(I_Client))
			set_task(0.1, "RegisterHamsForBots", I_Client)
	}
	#endif

	ResetPlayerVars(I_Client)

	set_task(0.1, "SendTeamInfoChatColor", I_Client)
}

public client_disconnect(I_Client)
{
	M_ClearPlayerBit(I_PlayerBitVars[BIP_IS_CONNECTED], I_Client)
	ResetPlayerVars(I_Client)
}

/*===================================================================
			HOOKED EVENTS & LOG-EVENTS CALLBACKS
===================================================================*/

// Events Callbacks
public EVENT_HLTV()
{
	M_ClearGlobalBit(I_GlobalBitVars, BIG_END_GAME_ROUND)
	M_ClearGlobalBit(I_GlobalBitVars, BIG_START_GAME_ROUND)

	if (!A_GlobalVars[GI_COUNT_DOWN])
		entity_set_float(A_CustomEntitys[ENTITY_COUNT_DOWN], EV_FL_nextthink, (GetCurrentTime()+M_CountDownThink))

	A_GlobalVars[GI_COUNT_DOWN] = A_GlobalVars[GA_CACHE_CVARS][CVAR_DELAY]

	remove_task(TASK_CHOOSE_ROUND_MOD)
	set_task(float(A_GlobalVars[GI_COUNT_DOWN]), "ChooseRoundMod", TASK_CHOOSE_ROUND_MOD)
}

// Log-Events Callbacks
public LOGEVENT_RoundEnd()
{
	M_SetGlobalBit(I_GlobalBitVars, BIG_END_GAME_ROUND)

	set_task(0.2, "BalanceTeams")
}

/*============================================================================
			HAMSANDWICH'S FORWARDS CALLBACKS
============================================================================*/

public HAM_PLAYER_Spawn_Post(const I_Player)
{
	if (!is_user_alive(I_Player))
		return;

	M_SetPlayerBit(I_PlayerBitVars[BIP_IS_ALIVE], I_Player)


	if (M_HasPlayerBit(I_PlayerBitVars[BIP_RESPAWN_AS_ZOMBIE], I_Player))
	{
		ZombieMe(I_Player, CLASS_ZOMBIE, _, true)
		return;
	}

	strip_user_weapons(I_Player)
	give_item(I_Player, "weapon_knife")


	/*==========	TESTS	==========*/
	give_item(I_Player, "weapon_m4a1")
	cs_set_user_bpammo(I_Player, CSW_M4A1, 500)
	cs_set_user_armor(I_Player, 150, CS_ARMOR_VESTHELM)
	/*==========	TESTS	==========*/





	set_task(0.01, "HideHUDs", I_Player)

	M_ClearPlayerBit(I_PlayerBitVars[BIP_IS_ZOMBIE], I_Player)
	UpdatePlayerLight(I_Player, C_LightStyleValues[HUMAN_THIS_LIGHT])
}

public HAM_PLAYER_TraceAttack_Pre(const I_Player, const I_Attacker, const Float:F_Damage, Float:F_Direction[3], const I_TraceHandle, const I_DamageBits)
{
	if (!M_HasGlobalBit(I_GlobalBitVars, BIG_START_GAME_ROUND) || M_HasGlobalBit(I_GlobalBitVars, BIG_END_GAME_ROUND))
		return HAM_SUPERCEDE;

	if (M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ZOMBIE], I_Player) && M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ZOMBIE], I_Attacker))
		return HAM_SUPERCEDE;

	return HAM_IGNORED;
}

public HAM_PLAYER_TakeDamage_Pre(const I_Player, const I_Inflictor, const I_Attacker, Float:F_Damage, const I_DamageBits)
{
	if (!M_HasGlobalBit(I_GlobalBitVars, BIG_START_GAME_ROUND) || M_HasGlobalBit(I_GlobalBitVars, BIG_END_GAME_ROUND))
		return HAM_SUPERCEDE;

	if (M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ZOMBIE], I_Player) && M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ZOMBIE], I_Attacker))
		return HAM_SUPERCEDE;

	if (!M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ZOMBIE], I_Attacker))
	{
		return HAM_IGNORED;
	}

	if (GetCount(COUNT_HUMANS) < 2)
		return HAM_IGNORED;

	static Float:F_Armor;
	F_Armor = entity_get_float(I_Player, EV_FL_armorvalue)

	if (F_Armor > 0.0)
	{
		if ((F_Armor-F_Damage) > 0.1)
			entity_set_float(I_Player, EV_FL_armorvalue, (F_Armor-F_Damage))
		else
			cs_set_user_armor(I_Player, 0, CS_ARMOR_NONE)
		return HAM_SUPERCEDE;
	}

	ZombieMe(I_Player, CLASS_ZOMBIE, I_Attacker)
	return HAM_SUPERCEDE;
}

public Ham_Item_Deploy_Post(const I_Item)
{
	if (!IsValidEntity(I_Item))
		return;

	static I_ItemOwner, I_ItemWeaponID;
	I_ItemOwner = get_pdata_cbase(I_Item, OFFSET_ITEM_PLAYER, OFFSET_CBASEPLAYERITEM)
	I_ItemWeaponID = cs_get_weapon_id(I_Item)

	ReplaceWeaponModels(I_ItemOwner, I_ItemWeaponID)
}

public HAM_PLAYER_Killed_Post(const I_Player, const I_Attacker, const bool:BO_ShouldGib)
{
	M_ClearPlayerBit(I_PlayerBitVars[BIP_IS_ALIVE], I_Player)

	if (!IsAvailableRespawn(I_Player))
		return;

	set_task(Float:A_GlobalVars[GA_CACHE_CVARS][CVAR_RESPAWN_DELAY], "RespawnPlayer", I_Player)
}

public HAM_WEAPON_Touch_Pre()
	return HAM_SUPERCEDE;

/*========================================================================
			ENGINE'S FORWARDS CALLBACKS
========================================================================*/

public THINK_CountDown(const I_Entity)
{
	if (!IsValidEntity(I_Entity))
	{
		log_amx("ZP ERROR: '%s' entity #%d is invalid!!!", C_CountDownClassName, I_Entity)
		return;
	}

	static I_LastCall;

	if (A_GlobalVars[GI_COUNT_DOWN] < 1 || (M_HasGlobalBit(I_GlobalBitVars, BIG_START_GAME_ROUND) || M_HasGlobalBit(I_GlobalBitVars, BIG_END_GAME_ROUND)))
	{
		A_GlobalVars[GI_COUNT_DOWN] = I_LastCall = 0
		return;
	}

	static Float:F_XPos, Float:F_YPos, A_Color[3];
	GetCountDownProperties(I_LastCall, F_XPos, F_YPos, A_Color)
	I_LastCall++

	set_dhudmessage(A_Color[0], A_Color[1], A_Color[2], F_XPos, F_YPos, 0, 0.0,(A_GlobalVars[GI_COUNT_DOWN] < 2 ? 1.5 : 0.4), 0.3, 0.3)
	show_dhudmessage(0, "******************************^nLA RONDA INICIARA EN:^n %d SEGUNDO%s^n******************************", A_GlobalVars[GI_COUNT_DOWN],
	A_GlobalVars[GI_COUNT_DOWN] < 2 ? "" : "S")

	A_GlobalVars[GI_COUNT_DOWN]--
	entity_set_float(I_Entity, EV_FL_nextthink, (GetCurrentTime()+M_CountDownThink))
}

public THINK_CacheCvars(const I_Entity)
{
	if (!IsValidEntity(I_Entity))
	{
		log_amx("ZP ERROR: '%s' entity #%d is invalid!!!", C_CacheCvarsClassName, I_Entity)
		return;
	}

	for (new I; I < MAX_CUSTOM_CVARS; I++)
	{
		if (I == CVAR_RESPAWN_DELAY)
			A_GlobalVars[GA_CACHE_CVARS][I] = _:get_pcvar_float(A_GlobalVars[GA_CUSTOM_CVARS][I])
		else
			A_GlobalVars[GA_CACHE_CVARS][I] = get_pcvar_num(A_GlobalVars[GA_CUSTOM_CVARS][I])
	}

	entity_set_float(I_Entity, EV_FL_nextthink, (GetCurrentTime()+M_CacheCvarsThink))
}

public THINK_HudStats(const I_Entity)
{
	if (!IsValidEntity(I_Entity))
	{
		log_amx("ZP ERROR: '%s' entity #%d is invalid!!!", C_HudStatsClassName, I_Entity)
		return;
	}

	if (!M_HasGlobalBit(I_GlobalBitVars, BIG_START_GAME_ROUND))
	{
		entity_set_float(I_Entity, EV_FL_nextthink, (GetCurrentTime()+M_HudStatsThink))
		return;
	}

	static I_Players;

	for (I_Players = 1; I_Players <= A_GlobalVars[GI_MAX_PLAYERS]; I_Players++)
	{
		if (!M_HasPlayerBit(I_PlayerBitVars[BIP_IS_CONNECTED], I_Players))
			continue;

		if (M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ALIVE], I_Players))
		{
			/*set_hudmessage(255, 255, 255, -1.0, 0.5, 0, 0.0, 1.5, 0.1, 0.1)
			ShowSyncHudMsg(I_Players, A_GlobalVars[GA_HUD_CHANNEL][HUD_CHANNEL_ONE], "Nombre: %s^nVida: %d | Chaleco: %d^nClase: %s",
			A_PlayerVars[I_Players][PSZ_CLIENT_NAME], A_PlayerVars[I_Players][PI_CURRENT_HEALTH], A_PlayerVars[I_Players][PI_CURRENT_ARMOR],
			M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ZOMBIE], I_Players) ? "Zombie" : "Humano")
			*/

			set_hudmessage(255, 255, 255, 0.0, 0.8, 0, 0.0, 1.5, 0.1, 0.1, A_GlobalVars[GA_HUD_CHANNEL][HUD_CHANNEL_ONE])
			show_hudmessage(I_Players, "Nombre: %s^nVida: %d | Chaleco: %d^nClase: %s",
			A_PlayerVars[I_Players][PSZ_CLIENT_NAME], A_PlayerVars[I_Players][PI_CURRENT_HEALTH], A_PlayerVars[I_Players][PI_CURRENT_ARMOR],
			M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ZOMBIE], I_Players) ? "Zombie" : "Humano")
		}
	}

	entity_set_float(I_Entity, EV_FL_nextthink, (GetCurrentTime()+M_HudStatsThink))
}

/*=========================================================================
			FAKEMETA'S FORWARDS CALLBACKS
=========================================================================*/

public FM_Spawn_Pre(const I_Entity)
{
	if (!IsValidEntity(I_Entity))
		return FMRES_IGNORED;

	static SZ_ClassName[32];
	entity_get_string(I_Entity, EV_SZ_classname, SZ_ClassName, charsmax(SZ_ClassName))

	static const ObjetiveEntitysClasNames[][] =
	{
		"func_bomb_target", "info_bomb_target", "info_vip_start", "func_vip_safetyzone", "func_escapezone",
		"hostage_entity", "monster_scientist", "func_hostage_rescue", "info_hostage_rescue", "item_longjump",
		"func_vehicle", "func_buyzone", "func_tankcontrols", "game_text", "armoury_entity"
	}

	for (new I; I < sizeof (ObjetiveEntitysClasNames); I++)
	{
		if (equal(SZ_ClassName, ObjetiveEntitysClasNames[I]))
		{
			remove_entity(I_Entity)
			return FMRES_SUPERCEDE;
		}
	}
	return FMRES_IGNORED;
}

public FM_ClientKill_Pre()
	return FMRES_SUPERCEDE;

/*=====================================================================
			HOOKED COMMANDS CALLBACKS
=====================================================================*/

// Client commands (CLCOMMAND_*)
public CLCOMMAND_ChooseTeam(const I_Client)
{
	if (!is_user_alive(I_Client))
		return PLUGIN_CONTINUE;

	ShowMenu(I_Client, MAIN_MENU)
	return PLUGIN_HANDLED;
}

/*============================================================================
			HOOKED CLIENT MESSAGES CALLBACKS
============================================================================*/

public MESSAGE_TextMsg()
{
	static SZ_Text[22];
	get_msg_arg_string(2, SZ_Text, charsmax(SZ_Text))

	if (equal(SZ_Text, "#Game_will_restart_in"))
	{
		LOGEVENT_RoundEnd()
	}
	else if (equal(SZ_Text, "#Hostages_Not_Rescued") || equal(SZ_Text, "#Round_Draw") || equal(SZ_Text, "#Terrorists_Win") || equal(SZ_Text, "#CTs_Win"))
		return PLUGIN_HANDLED;

	return PLUGIN_CONTINUE;
}

public MESSAGE_Health(I_MsgID, I_MsgDest, I_MsgClient)
{
	A_PlayerVars[I_MsgClient][PI_CURRENT_HEALTH] = get_user_health(I_MsgClient)

	if (A_PlayerVars[I_MsgClient][PI_CURRENT_HEALTH] < 256)
		return;

	set_msg_arg_int(1, ARG_BYTE, 255)
}

public MESSAGE_StatusIcon(I_MsgID, I_MsgDest, I_MsgClient)
{
	static SZ_Icon[8], bool:I_StatusEnable;
	get_msg_arg_string(2, SZ_Icon, charsmax(SZ_Icon))
	I_StatusEnable = bool:get_msg_arg_int(1)

	if (equal(SZ_Icon, "buyzone") && I_StatusEnable)
	{
		static I_MapZone;
		I_MapZone = get_pdata_int(I_MsgClient, OFFSET_CLIENT_MAP_ZONE)
		set_pdata_int(I_MsgClient, OFFSET_CLIENT_MAP_ZONE, (I_MapZone & ~(1<<0)))
		return PLUGIN_HANDLED;
	}
	return PLUGIN_CONTINUE;
}

public MESSAGE_Battery(I_MsgID, I_MsgDest, I_MsgClient)
{
	A_PlayerVars[I_MsgClient][PI_CURRENT_ARMOR] = get_msg_arg_int(1)
}

public MESSAGE_NVGToggle(I_MsgID, I_MsgDest, I_MsgClient)
{
	static bool:BO_Flag;
	BO_Flag = bool:get_msg_arg_int(1)

	switch (BO_Flag)
	{
		case true:
		{
			UpdatePlayerLight(I_MsgClient, C_LightStyleValues[NVG_THIS_LIGHT])
			UpdatePlayerNVG(I_MsgClient, _, _, FFADE_STAYOUT, { 255, 35, 35 }, 50)
		}
		case false:
		{
			UpdatePlayerNVG(I_MsgClient)
			UpdatePlayerLight(I_MsgClient, C_LightStyleValues[ZOMBIE_THIS_LIGHT])
		}
	}
	return PLUGIN_HANDLED;
}

/*========================================================================
			SHOW MENUS & MENUS CALLBACKS
========================================================================*/

// Show menus
ShowMenu(const I_Player, const I_MenuType)
{
	new bool:BO_DiseableExitButton;

	switch (I_MenuType)
	{
		case MAIN_MENU:
		{
			oldmenu_create("HM_Main", "\r********************^n\y%s \r%s^n********************^n\wEditado por: \y%s",
			C_PluginInfo[PLUGIN_NAME], C_PluginInfo[PLUGIN_VERSION], C_PluginInfo[PLUGIN_AUTHOR])

			oldmenu_additem(1, 0, "\r[1]. \wARMAMENTO^n")

			M_SwitchGlobalBool(BO_DiseableExitButton)
		}
		case ARMAMENT_MAIN_MENU:
		{
			oldmenu_create("HM_Armament", "\yARMAMENTO")

			//oldmenu_additem(1, 0, "\r[1]. \yARSENAL DE ARMAS")
			oldmenu_additem(2, 0, "\r[2]. \wINDUSTRIA ARMAMENTÍSTICA^n")

			M_SwitchGlobalBool(BO_DiseableExitButton)
		}
		case ARMAMENT_INDUSTRY_MENU:
		{
			oldmenu_create("HM_ArmamentIndustry", "\yINDUSTRIA ARMAMENTÍSTICA")

			oldmenu_additem(1, 0, "\r[1]. \wCREAR ARMA^n")

			M_SwitchGlobalBool(BO_DiseableExitButton)
		}
	}

	if (M_IsBoolActive(BO_DiseableExitButton))
		oldmenu_additem(0, MENU_EXIT, "\r[0]. SALIR.")

	oldmenu_display(I_Player, I_MenuType)
}

// Menus callbacks
public HM_Main(const I_Player, const I_Item, const I_Value, const I_Page)
{
	if (I_Value == MENU_EXIT)
		return;

	switch (I_Item)
	{
		case 1: ShowMenu(I_Player, ARMAMENT_MAIN_MENU)
	}
}

public HM_Armament(const I_Player, const I_Item, const I_Value, const I_Page)
{
	if (I_Value == MENU_EXIT)
		return;

	switch (I_Item)
	{
		case 2: ShowMenu(I_Player, ARMAMENT_INDUSTRY_MENU)
	}
}

public HM_ArmamentIndustry(const I_Player, const I_Item, const I_Value, const I_Page)
{
	if (I_Value == MENU_EXIT)
		return;
}

/*======================================================================
			PUBLIC & PRIVATE FUNCTIONS
======================================================================*/

// Public functions
public ChooseRoundMod()
	StartRound(MODE_NONE)

public HideHUDs(const I_Player)
{
	if (!M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ALIVE], I_Player))
		return;

	message_begin(MSG_ONE, A_GlobalVars[GA_CACHE_MESSAGES][MESSAGE_HIDEWEAPON], _, I_Player)
	write_byte(HIDE_HUDS)
	message_end()

	message_begin(MSG_ONE, A_GlobalVars[GA_CACHE_MESSAGES][MESSAGE_CROSSHAIR], _, I_Player)
	write_byte(0)
	message_end()
}

public SetUserTeamMSG(I_User)
{
	message_begin(MSG_ALL, A_GlobalVars[GA_CACHE_MESSAGES][MESSAGE_TEAMINFO])
	write_byte(I_User)
	write_string(C_CsTeamNames[GetUserTeam(I_User)])
	message_end()
}

public BalanceTeams()
{
	static I_PlayersPlaying;
	I_PlayersPlaying = GetCount(COUNT_PLAYING_PLAYERS)

	if (I_PlayersPlaying < 2)
		return;

	static I_Player, A_PlayerTeam[33], I_CurrentTTs, I_MaxTTs;
	I_MaxTTs = (I_PlayersPlaying/2)
	I_CurrentTTs = 0

	for (I_Player = 1; I_Player <= A_GlobalVars[GI_MAX_PLAYERS]; I_Player++)
	{
		if (!M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ALIVE], I_Player))
			continue;

		A_PlayerTeam[I_Player] = GetUserTeam(I_Player)

		remove_task(I_Player)
		SetUserTeam(I_Player, TEAM_COUNTER_TERRORIST)
		A_PlayerTeam[I_Player] = TEAM_COUNTER_TERRORIST
	}

	while (I_CurrentTTs < I_MaxTTs)
	{
		if (++I_Player > A_GlobalVars[GI_MAX_PLAYERS])
			I_Player = 1

		if (!M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ALIVE], I_Player))
			continue;

		if (A_PlayerTeam[I_Player] != TEAM_COUNTER_TERRORIST)
			continue;

		if (random_num(0, 1))
		{
			SetUserTeam(I_Player, TEAM_TERRORIST)
			A_PlayerTeam[I_Player] = TEAM_TERRORIST
			I_CurrentTTs++
		}
	}
}

public RespawnPlayer(const I_Player)
{
	if (!M_HasPlayerBit(I_PlayerBitVars[BIP_IS_CONNECTED], I_Player) || M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ALIVE], I_Player))
		return;

	ExecuteHamB(Ham_CS_RoundRespawn, I_Player)
	M_ClearPlayerBit(I_PlayerBitVars[BIP_RESPAWN_AS_ZOMBIE], I_Player)

	switch (A_GlobalVars[GA_CACHE_CVARS][CVAR_RESPAWN_AS])
	{
		case 1: M_SetPlayerBit(I_PlayerBitVars[BIP_RESPAWN_AS_ZOMBIE], I_Player)
		case 3: if (random_num(0, 1)) M_SetPlayerBit(I_PlayerBitVars[BIP_RESPAWN_AS_ZOMBIE], I_Player)
	}

	ExecuteHamB(Ham_CS_RoundRespawn, I_Player)
}

public SendTeamInfoChatColor(const I_Player)
{
	if (!M_HasPlayerBit(I_PlayerBitVars[BIP_IS_CONNECTED], I_Player))
		return;

	for (new I; I < 3; I++)
	{
		message_begin(MSG_ONE, A_GlobalVars[GA_CACHE_MESSAGES][MESSAGE_TEAMINFO], _, I_Player)
		write_byte((I+CHAT_COLOR_GREY))
		write_string(C_CsTeamNames[I])
		message_end()
	}
}

#if defined PlayWithBots
public RegisterHamsForBots(const I_Bot)
{
	if (M_HasGlobalBit(I_GlobalBitVars, BIG_REGISTER_HAMS_BOTS))
		return;

	RegisterHamFromEntity(Ham_Spawn, I_Bot, "HAM_PLAYER_Spawn_Post", true)
	RegisterHamFromEntity(Ham_TraceAttack, I_Bot, "HAM_PLAYER_TraceAttack_Pre")
	RegisterHamFromEntity(Ham_TakeDamage, I_Bot, "HAM_PLAYER_TakeDamage_Pre")
	RegisterHamFromEntity(Ham_Killed, I_Bot, "HAM_PLAYER_Killed_Post", true)
	M_SetGlobalBit(I_GlobalBitVars, BIG_REGISTER_HAMS_BOTS)
}
#endif

// Private functions
StartRound(const I_ModeType, I_PlayerSelected = 0)
{
	static I_AlivePlayers;
	I_AlivePlayers = GetCount(COUNT_ALIVE_PLAYERS)

	if (I_AlivePlayers < 1)
	{
		set_task(2.0, "ChooseRoundMod", TASK_CHOOSE_ROUND_MOD)
		return;
	}

	static I_Players;

	/*==========	MODE INFECTION	==========*/
	if (I_ModeType == MODE_NONE)
		I_PlayerSelected = GetRandomAlive()

	ZombieMe(I_PlayerSelected, CLASS_FIRST_ZOMBIE)

	for (I_Players = 1; I_Players <= A_GlobalVars[GI_MAX_PLAYERS]; I_Players++)
	{
		if (!M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ALIVE], I_Players) || M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ZOMBIE], I_Players))
			continue;

		if (GetUserTeam(I_Players) != TEAM_COUNTER_TERRORIST)
		{
			remove_task(I_Players)
			SetUserTeam(I_Players, TEAM_COUNTER_TERRORIST)
			UpdateUserTeam(I_Players)
		}
	}

	set_dhudmessage(0, 255, 0, -1.0, 0.2, 0, 0.0, 3.0, 1.0, 1.0)
	show_dhudmessage(0, "==========================^n! %s ES EL PRIMER ZOMBIE !^n==========================", A_PlayerVars[I_PlayerSelected][PSZ_CLIENT_NAME])
	/*==========	MODE INFECTION	==========*/


	M_SetGlobalBit(I_GlobalBitVars, BIG_START_GAME_ROUND)
}

ZombieMe(const I_Player, const I_ZombieType, const I_Infector = 0, const bool:WasRespawn = false)
{
	strip_user_weapons(I_Player)
	give_item(I_Player, "weapon_knife")
	cs_set_user_armor(I_Player, 0, CS_ARMOR_NONE)

	if (I_Infector)
	{
		SendDeahMessage(I_Player, I_Infector)
		FixPlayerAttribute(I_Player)
		UpdateScore(I_Player, _, _, I_Infector)
	}

	switch (I_ZombieType)
	{
		case CLASS_FIRST_ZOMBIE:
		{
			set_user_health(I_Player, 800)
			SendInfectionEffects(I_Player, EFFECT_FIRST_ZOMBIE)
		}
		case CLASS_ZOMBIE:
		{
			set_user_health(I_Player, 500)
			SendInfectionEffects(I_Player)
		}
	}

	if (WasRespawn)
		SendInfectionEffects(I_Player, EFFECT_RESPAWN_ZOMBIE)

	M_SetPlayerBit(I_PlayerBitVars[BIP_IS_ZOMBIE], I_Player)
	A_PlayerVars[I_Player][PI_CLASS] = I_ZombieType

	SetUserTeam(I_Player, TEAM_TERRORIST)
	UpdatePlayerLight(I_Player, C_LightStyleValues[ZOMBIE_THIS_LIGHT])
	cs_set_user_nvg(I_Player, true)
}

SendInfectionEffects(const I_Player, const I_EffectType = EFFECT_ZOMBIE)
{
	static Float:F_Origin[3];
	entity_get_vector(I_Player, EV_VEC_origin, F_Origin)

	switch (I_EffectType)
	{
		case EFFECT_FIRST_ZOMBIE:
		{
			message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
			write_byte(TE_IMPLOSION)
			engfunc(EngFunc_WriteCoord, F_Origin[0])
			engfunc(EngFunc_WriteCoord, F_Origin[1])
			engfunc(EngFunc_WriteCoord, F_Origin[2])
			write_byte(128)
			write_byte(20)
			write_byte(3)
			message_end()
		}
		case EFFECT_RESPAWN_ZOMBIE:
		{
			message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
			write_byte(TE_TELEPORT)
			engfunc(EngFunc_WriteCoord, F_Origin[0])
			engfunc(EngFunc_WriteCoord, F_Origin[1])
			engfunc(EngFunc_WriteCoord, F_Origin[2])
			message_end()
		}
	}

	message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
	write_byte(TE_LAVASPLASH)
	engfunc(EngFunc_WriteCoord, F_Origin[0])
	engfunc(EngFunc_WriteCoord, F_Origin[1])
	engfunc(EngFunc_WriteCoord, F_Origin[2])
	message_end()
}

FixPlayerAttribute(const I_Player)
{
	message_begin(MSG_ALL, A_GlobalVars[GA_CACHE_MESSAGES][MESSAGE_SCOREATTRIB])
	write_byte(I_Player)
	write_byte(0)
	message_end()
}

UpdateUserTeam(const I_User)
{
	static Float:F_CurrentTime, Float:F_ChangeTeamTime;
	F_CurrentTime = get_gametime()

	if ((F_CurrentTime-F_ChangeTeamTime) >= 0.1)
	{
		set_task(0.1, "SetUserTeamMSG", I_User)
		F_ChangeTeamTime = (F_CurrentTime+0.1)
	}
	else
	{
		set_task(((F_ChangeTeamTime+0.1)-F_CurrentTime), "SetUserTeamMSG", I_User)
		F_ChangeTeamTime = (F_ChangeTeamTime+0.1)
	}
}

GetCountDownProperties(&I_LastCall, &Float:F_XPosition, &Float:F_YPosition, A_Color[3])
{
	if (I_LastCall >= 10)
		I_LastCall = 0

	F_XPosition = -1.0
	F_YPosition = 0.03+(I_LastCall*0.03)

	switch (random_num(0, 5))
	{
		case 5: A_Color = { 255, 255, 255 }
		case 4: A_Color = { 0, 255, 255 }
		case 3: A_Color = { 255, 0, 255 }
		case 2: A_Color = { 255, 255, 0 }
		case 1: A_Color = { 255, 0, 255 }
		default: A_Color = { 0, 255, 255 }
	}
}

GetCount(const I_CountType)
{
	static I_Team, I;
	new I_Count;

	switch (I_CountType)
	{
		case COUNT_ALIVE_PLAYERS:
		{
			for (I = 1; I <= A_GlobalVars[GI_MAX_PLAYERS]; I++)
			{
				if (!M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ALIVE], I))
					continue;

				I_Count++
			}
		}
		case COUNT_PLAYING_PLAYERS:
		{
			for (I = 1; I <= A_GlobalVars[GI_MAX_PLAYERS]; I++)
			{
				if (!M_HasPlayerBit(I_PlayerBitVars[BIP_IS_CONNECTED], I))
					continue;

				I_Team = GetUserTeam(I)

				if (I_Team != TEAM_SPECTATOR && I_Team != TEAM_UNASSIGNED)
					I_Count++
			}
		}
		case COUNT_HUMANS:
		{
			for (I = 1; I <= A_GlobalVars[GI_MAX_PLAYERS]; I++)
			{
				if (!M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ALIVE], I))
					continue;

				if (!M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ZOMBIE], I))
					I_Count++
			}
		}

	}
	return I_Count;
}

GetRandomAlive()
{
	new A_Players[32], I_Num;
	get_players(A_Players, I_Num, "a")
	return A_Players[random(I_Num)];
}

ReplaceWeaponModels(const I_Player, const I_WeaponID)
{
	if (I_WeaponID == CSW_KNIFE)
	{
		entity_set_string(I_Player, EV_SZ_weaponmodel, "")
		return;
	}
}

UpdatePlayerNVG(const I_Player, const I_Duration = 0, const I_HoldTime = 0, const I_Flags = FFADE_IN, A_Color[3] = { 0, 0, 0 }, I_Alpha = 0)
{
	for (new i; i < sizeof (A_Color); i++)
	{
		if (A_Color[i] > 255)
			A_Color[i] = 255
	}

	if (I_Alpha > 255)
		I_Alpha = 255

	message_begin(MSG_ONE, A_GlobalVars[GA_CACHE_MESSAGES][MESSAGE_SCREENFADE], _, I_Player)
	write_short(I_Duration)
	write_short(I_HoldTime)
	write_short(I_Flags)
	write_byte(A_Color[0])
	write_byte(A_Color[1])
	write_byte(A_Color[2])
	write_byte(I_Alpha)
	message_end()
}

ResetPlayerVars(const I_Player)
{
	M_ClearPlayerBit(I_PlayerBitVars[BIP_IS_ALIVE], I_Player)
	M_ClearPlayerBit(I_PlayerBitVars[BIP_IS_ZOMBIE], I_Player)
	M_ClearPlayerBit(I_PlayerBitVars[BIP_RESPAWN_AS_ZOMBIE], I_Player)

	A_PlayerVars[I_Player][PI_CLASS] = CLASS_HUMAN
	A_PlayerVars[I_Player][PI_CURRENT_HEALTH] = A_PlayerVars[I_Player][PI_CURRENT_ARMOR] = 0
}

bool:IsValidEntity(const I_Entity)
	return bool:is_valid_ent(I_Entity);

bool:IsAvailableRespawn(const I_Player)
{
	if (!A_GlobalVars[GA_CACHE_CVARS][CVAR_RESPAWN])
		return false;

	if ((M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ZOMBIE], I_Player) && !A_GlobalVars[GA_CACHE_CVARS][CVAR_RESPAWN_ZOMBIES]) ||
	(!M_HasPlayerBit(I_PlayerBitVars[BIP_IS_ZOMBIE], I_Player) && !A_GlobalVars[GA_CACHE_CVARS][CVAR_RESPAWN_HUMANS]))
		return false;

	switch (A_GlobalVars[GI_CURRENT_ROUND_MODE])
	{
		case MODE_INFECTION: if (!A_GlobalVars[GA_CACHE_CVARS][CVAR_INFECTION_RESPAWN]) return false;
	}

	return true;
}

Float:GetCurrentTime()
	return get_gametime();

/*==================================================
			STOCKS
==================================================*/


stock GetUserTeam(const I_User)
{
	if (pev_valid(I_User) != OFFSET_PRIVATE_DATA)
		return TEAM_UNASSIGNED;

	return get_pdata_int(I_User, OFFSET_CS_TEAM, OFFSET_CBASEPLAYER);
}

stock SetUserTeam(const I_User, const I_Team)
{
	if (pev_valid(I_User) != OFFSET_PRIVATE_DATA)
		return;

	set_pdata_int(I_User, OFFSET_CS_TEAM, I_Team, OFFSET_CBASEPLAYER);
	UpdateUserTeam(I_User)
}

stock SendDeahMessage(const I_Player, const I_Attacker, const bool:IsHeadShot = false, const WeaponName[] = "infection")
{
	message_begin(MSG_ALL, A_GlobalVars[GA_CACHE_MESSAGES][MESSAGE_DEATHMSG])
	write_byte(I_Attacker)
	write_byte(I_Player)
	write_byte(IsHeadShot)
	write_string(WeaponName)
	message_end()
}

stock UpdateScore(const I_Player, const I_PlayerFrags = 0, const I_PlayerDeaths = 1, const I_Attacker, const I_AttackerFrags = 1, const I_AttackerDeaths = 0)
{
	static I_NewFrags, I_NewDeaths;

	if (I_Player)
	{
		I_NewFrags = (get_user_frags(I_Player)+I_PlayerFrags)
		set_user_frags(I_Player, I_NewFrags)

		I_NewDeaths = (cs_get_user_deaths(I_Player)+I_PlayerDeaths)
		cs_set_user_deaths(I_Player, I_NewDeaths)
	}

	if (I_Attacker)
	{
		I_NewFrags = (get_user_frags(I_Attacker)+I_AttackerFrags)
		set_user_frags(I_Attacker, I_NewFrags)

		I_NewDeaths = (cs_get_user_deaths(I_Attacker)+I_AttackerDeaths)
		cs_set_user_deaths(I_Attacker, I_NewDeaths)
	}
}

stock UpdatePlayerLight(const I_Player, const SZ_LightValue[])
{
	message_begin(MSG_ONE, SVC_LIGHTSTYLE, _, I_Player)
	write_byte(0)
	write_string(SZ_LightValue)
	message_end()
}

stock SendPrint(const I_Target = 0, const I_ColorChat, const SZ_Text[], any:...)
{
	static SZ_Message[190];
	vformat(SZ_Message, charsmax(SZ_Message), SZ_Text, 4)
	replace_all(SZ_Message, charsmax(SZ_Message), "!y", "^1")
	replace_all(SZ_Message, charsmax(SZ_Message), "!color", "^3")
	replace_all(SZ_Message, charsmax(SZ_Message), "!g", "^4")

	message_begin((I_Target ? MSG_ONE : MSG_BROADCAST), A_GlobalVars[GA_CACHE_MESSAGES][MESSAGE_SAYTEXT], _, I_Target)
	write_byte((I_ColorChat ? I_ColorChat : 33))
	write_string(SZ_Message)
	message_end()
}

/*=========================================================================================================*/

/*
public StartMode(Mode, Id)
{
	static PlayersNum;
	PlayersNum = GetCount(COUNT_ALIVES)

	if (PlayersNum < 1)
	{
		set_task(2.0, "ChooseModeStart", TASK_START_MODE)
		return;
	}

	static PlayerId, Zombies, MaxZombies, ModeChance;
	GVars[G_NEW_ROUND] = false
	ModeChance = BASE_num(1, get_pcvar_num(GVars[G_CVARS][CVAR_MODES_CHANCE]))

	if ((get_pcvar_num(GVars[G_CVARS][CVAR_MULTI]) && ModeChance == get_pcvar_num(GVars[G_CVARS][CVAR_MULTI_CHANCE]) && PlayersNum >= get_pcvar_num(GVars[G_CVARS][CVAR_MULTI_MIN_PLAYERS]) && GVars[G_LAST_MODE] != MODE_MULTI) || Mode == MODE_MULTI)
	{
		GVars[G_LAST_MODE] = GVars[G_CURRENT_MODE] = MODE_MULTI
		Zombies = 0
		MaxZombies = (PlayersNum/4)

		while (Zombies < MaxZombies)
		{
			if (++Id > GVars[G_MAX_PLAYERS])
				Id = 1

			if (!PVars[Id][P_IS_ALIVE] || PVars[Id][P_CLASS] >= ZOMBIE)
				continue;

			if (BASE_num(0, 1))
			{
				Zombieme(Id, _, _, _, 1)
				Zombies++
			}
		}

		for (Id = 1; Id <= GVars[G_MAX_PLAYERS]; Id++)
		{
			if (!PVars[Id][P_IS_ALIVE] || PVars[Id][P_CLASS] >= ZOMBIE)
				continue;

			if (GetUserTeam(Id) != TEAM_COUNTER_TERRORIST)
			{
				remove_task(Id+TASK_CHANGE_TEAM)
				SetUserTeam(Id, TEAM_COUNTER_TERRORIST)
				UpdateUserTeam(Id)
			}
		}

		set_dhudmessage(0, 255, 0, -1.0, 0.2, 0, 0.0, 3.0, 1.0, 1.0)
		show_dhudmessage(0, "======================^n¡ MODO INFECCIÓN MÚLTIPLE !^n======================")
		PlaySound(REGISTER_SOUNDS[MULTI_MODE])
	}
	else if ((get_pcvar_num(GVars[G_CVARS][CVAR_SWARM]) && ModeChance == get_pcvar_num(GVars[G_CVARS][CVAR_SWARM_CHANCE]) && PlayersNum >= get_pcvar_num(GVars[G_CVARS][CVAR_SWARM_MIN_PLAYERS]) && GVars[G_LAST_MODE] != MODE_SWARM) || Mode == MODE_SWARM)
	{
		GVars[G_LAST_MODE] = GVars[G_CURRENT_MODE] = MODE_SWARM

		if (!GetCount(COUNT_ALIVE_TTS))
		{
			Id = GetRandomAlive(BASE_num(1, PlayersNum))
			remove_task(Id+TASK_CHANGE_TEAM)
			SetUserTeam(Id, TEAM_TERRORIST)
			UpdateUserTeam(Id)
		}
		else if (!GetCount(COUNT_ALIVE_CTS))
		{
			Id = GetRandomAlive(BASE_num(1, PlayersNum))
			remove_task(Id+TASK_CHANGE_TEAM)
			SetUserTeam(Id, TEAM_COUNTER_TERRORIST)
			UpdateUserTeam(Id)
		}

		for (Id = 1; Id <= GVars[G_MAX_PLAYERS]; Id++)
		{
			if (!PVars[Id][P_IS_ALIVE])
				continue;

			if (GetUserTeam(Id) != TEAM_TERRORIST)
				continue;

			Zombieme(Id, _, _, _, 1)
		}

		set_dhudmessage(0, 255, 0, -1.0, 0.2, 0, 0.0, 3.0, 1.0, 1.0)
		show_dhudmessage(0, "===============^n¡ MODO SWARM !^n===============")
		PlaySound(REGISTER_SOUNDS[SWARM_MODE])
	}
	else if ((get_pcvar_num(GVars[G_CVARS][CVAR_SURVIVOR]) && ModeChance == get_pcvar_num(GVars[G_CVARS][CVAR_SURVIVOR_CHANCE]) && PlayersNum >= get_pcvar_num(GVars[G_CVARS][CVAR_SURVIVOR_MIN_PLAYERS]) && GVars[G_LAST_MODE] != MODE_SURVIVOR) || Mode == MODE_SURVIVOR)
	{
		GVars[G_LAST_MODE] = GVars[G_CURRENT_MODE] = MODE_SURVIVOR

		if (Mode == MODE_NONE)
			Id = GetRandomAlive(BASE_num(1, PlayersNum))

		PlayerId = Id
		Humanme(Id, 1)

		for (Id = 1; Id <= GVars[G_MAX_PLAYERS]; Id++)
		{
			if (!PVars[Id][P_IS_ALIVE])
				continue;

			if (PVars[Id][P_CLASS] == SURVIVOR || PVars[Id][P_CLASS] >= ZOMBIE)
				continue;

			Zombieme(Id, _, _, _, 1)
		}

		set_dhudmessage(0, 0, 255, -1.0, 0.2, 0, 0.0, 3.0, 1.0, 1.0)
		show_dhudmessage(0, "======================^n¡ MODO SURVIVOR !^n%s ES EL SURVIVOR^n======================", PVars[PlayerId][P_PLAYER_NAME])
		PlaySound(REGISTER_SOUNDS[SURVIVOR_MODE])
	}
	else if ((get_pcvar_num(GVars[G_CVARS][CVAR_SNIPER]) && ModeChance == get_pcvar_num(GVars[G_CVARS][CVAR_SNIPER_CHANCE]) && PlayersNum >= get_pcvar_num(GVars[G_CVARS][CVAR_SNIPER_MIN_PLAYERS]) && GVars[G_LAST_MODE] != MODE_SNIPER) || Mode == MODE_SNIPER)
	{
		GVars[G_LAST_MODE] = GVars[G_CURRENT_MODE] = MODE_SNIPER

		if (Mode == MODE_NONE)
			Id = GetRandomAlive(BASE_num(1, PlayersNum))

		PlayerId = Id
		Humanme(Id, 2)

		for (Id = 1; Id <= GVars[G_MAX_PLAYERS]; Id++)
		{
			if (!PVars[Id][P_IS_ALIVE])
				continue;

			if (PVars[Id][P_CLASS] == SNIPER || PVars[Id][P_CLASS] >= ZOMBIE)
				continue;

			Zombieme(Id, _, _, _, 1)
		}

		set_dhudmessage(0, 0, 255, -1.0, 0.2, 0, 0.0, 3.0, 1.0, 1.0)
		show_dhudmessage(0, "======================^n¡ MODO SNIPER !^n%s ES EL SNIPER^n======================", PVars[PlayerId][P_PLAYER_NAME])
	}
	else if ((get_pcvar_num(GVars[G_CVARS][CVAR_NEMESIS]) && ModeChance == get_pcvar_num(GVars[G_CVARS][CVAR_NEMESIS_CHANCE]) && PlayersNum >= get_pcvar_num(GVars[G_CVARS][CVAR_NEMESIS_MIN_PLAYERS]) && GVars[G_LAST_MODE] != MODE_NEMESIS) || Mode == MODE_NEMESIS)
	{
		GVars[G_LAST_MODE] = GVars[G_CURRENT_MODE] = MODE_NEMESIS

		if (Mode == MODE_NONE)
			Id = GetRandomAlive(BASE_num(1, PlayersNum))

		PlayerId = Id
		Zombieme(Id, _, 1)

		for (Id = 1; Id <= GVars[G_MAX_PLAYERS]; Id++)
		{
			if (!PVars[Id][P_IS_ALIVE] || PVars[Id][P_CLASS] >= ZOMBIE)
				continue;

			if (GetUserTeam(Id) != TEAM_COUNTER_TERRORIST)
			{
				remove_task(Id+TASK_CHANGE_TEAM)
				SetUserTeam(Id, TEAM_COUNTER_TERRORIST)
				UpdateUserTeam(Id)
			}
		}

		set_dhudmessage(255, 0, 0, -1.0, 0.2, 0, 0.0, 3.0, 1.0, 1.0)
		show_dhudmessage(0, "======================^n¡ MODO NEMESIS !^n%s ES EL NEMESIS^n======================", PVars[PlayerId][P_PLAYER_NAME])
		PlaySound(REGISTER_SOUNDS[NEMESIS_MODE])
	}
	else if ((get_pcvar_num(GVars[G_CVARS][CVAR_PLAGUE]) && ModeChance == get_pcvar_num(GVars[G_CVARS][CVAR_PLAGUE_CHANCE]) && PlayersNum >= get_pcvar_num(GVars[G_CVARS][CVAR_PLAGUE_MIN_PLAYERS]) && GVars[G_LAST_MODE] != MODE_PLAGUE) || Mode == MODE_PLAGUE)
	{
		GVars[G_LAST_MODE] = GVars[G_CURRENT_MODE] = MODE_PLAGUE

		static MaxSurvivors, Survivors, Nemesis, MaxNemesis;
		MaxSurvivors = get_pcvar_num(GVars[G_CVARS][CVAR_PLAGUE_SURV_NUM])
		MaxNemesis = get_pcvar_num(GVars[G_CVARS][CVAR_PLAGUE_NEM_NUM])
		Survivors = Nemesis = 0

		while (Survivors < MaxSurvivors)
		{
			Id = GetRandomAlive(BASE_num(1, PlayersNum))

			if (PVars[Id][P_CLASS] == SURVIVOR)
				continue;

			Humanme(Id, 1)
			Survivors++
			set_user_health(Id, floatround((float(get_user_health(Id))*get_pcvar_num(GVars[G_CVARS][CVAR_PLAGUE_SURV_MULTI_HP]))))
		}

		while (Nemesis < MaxNemesis)
		{
			Id = GetRandomAlive(BASE_num(1, PlayersNum))

			if (PVars[Id][P_CLASS] == SURVIVOR || PVars[Id][P_CLASS] == NEMESIS)
				continue;

			Zombieme(Id, _, 1)
			Nemesis++
			set_user_health(Id, floatround((float(get_user_health(Id))*get_pcvar_num(GVars[G_CVARS][CVAR_PLAGUE_NEM_MULTI_HP]))))
		}

		MaxZombies = ((PlayersNum-(get_pcvar_num(GVars[G_CVARS][CVAR_PLAGUE_SURV_NUM])+get_pcvar_num(GVars[G_CVARS][CVAR_PLAGUE_NEM_NUM])))/2)
		Zombies = 0

		while (Zombies < MaxZombies)
		{
			if (++Id > GVars[G_MAX_PLAYERS])
				Id = 1

			if (!PVars[Id][P_IS_ALIVE] || PVars[Id][P_CLASS] >= ZOMBIE || PVars[Id][P_CLASS] == SURVIVOR)
				continue;

			if (BASE_num(0, 1))
			{
				Zombieme(Id, _, _, _, 1)
				Zombies++
			}
		}

		for (Id = 1; Id <= GVars[G_MAX_PLAYERS]; Id++)
		{
			if (!PVars[Id][P_IS_ALIVE] || PVars[Id][P_CLASS] >= ZOMBIE || PVars[Id][P_CLASS] == SURVIVOR)
				continue;

			if (GetUserTeam(Id) != TEAM_COUNTER_TERRORIST)
			{
				remove_task(Id+TASK_CHANGE_TEAM)
				SetUserTeam(Id, TEAM_COUNTER_TERRORIST)
				UpdateUserTeam(Id)
			}
		}

		set_dhudmessage(255, 0, 0, -1.0, 0.2, 0, 0.0, 3.0, 1.0, 1.0)
		show_dhudmessage(0, "================^n¡ MODO PLAGUE !^n================")
		PlaySound(REGISTER_SOUNDS[PLAGUE_MODE])
	}
	else
	{
		GVars[G_LAST_MODE] = GVars[G_CURRENT_MODE] = MODE_INFECTION

		if (Mode == MODE_NONE)
			Id = GetRandomAlive(BASE_num(1, PlayersNum))

		PlayerId = Id
		emit_sound(Id, CHAN_VOICE, REGISTER_SOUNDS[BASE_num(ZOMBIE_COMING1, ZOMBIE_COMING3)], 1.0, ATTN_NORM, 0, PITCH_NORM)
		Zombieme(Id)

		for (Id = 1; Id <= GVars[G_MAX_PLAYERS]; Id++)
		{
			if (!PVars[Id][P_IS_ALIVE] || PVars[Id][P_CLASS] >= ZOMBIE)
				continue;

			if (GetUserTeam(Id) != TEAM_COUNTER_TERRORIST)
			{
				remove_task(Id+TASK_CHANGE_TEAM)
				SetUserTeam(Id, TEAM_COUNTER_TERRORIST)
				UpdateUserTeam(Id)
			}
		}

		set_dhudmessage(0, 255, 0, -1.0, 0.2, 0, 0.0, 3.0, 1.0, 1.0)
		show_dhudmessage(0, "==========================^n! %s ES EL PRIMER ZOMBIE !^n==========================", PVars[PlayerId][P_PLAYER_NAME])
	}
}
*/