//#define USING_SQL
#define ENTRY_XP			100

#define ENABLE_GRENADE			1
#define ENABLE_FLASHBANG_1		1
#define ENABLE_FLASHBANG_2		1
#define ENABLE_SMOKEGRENADE		1
#define ENABLE_TERR_HEALTH		1
#define ENABLE_CT_HEALTH		1
#define ENABLE_TERR_ARMOR		1
#define ENABLE_CT_ARMOR			1
#define ENABLE_TERR_RESPAWN		1
#define ENABLE_CT_RESPAWN		1
#define ENABLE_TERR_NOFALL		1
#define ENABLE_CT_NOFALL		1
#define ENABLE_TERR_DMG			1
#define ENABLE_CT_DMG			1
#define ENABLE_TERR_REGENERATION	1
#define ENABLE_CT_REGENERATION		1
#define ENABLE_TERR_INVISIBILITY	0
#define ENABLE_CT_INVISIBILITY		0

// The maximum level for each ability

#define MAXLEVEL_GRENADE		8
#define MAXLEVEL_FLASHBANG_1		4
#define MAXLEVEL_FLASHBANG_2		4
#define MAXLEVEL_SMOKEGRENADE		4
#define MAXLEVEL_TERR_HEALTH		10
#define MAXLEVEL_CT_HEALTH		8
#define MAXLEVEL_TERR_ARMOR		9
#define MAXLEVEL_CT_ARMOR		9
#define MAXLEVEL_TERR_RESPAWN		2
#define MAXLEVEL_CT_RESPAWN		2
#define MAXLEVEL_TERR_NOFALL		9
#define MAXLEVEL_CT_NOFALL		9
#define MAXLEVEL_TERR_DMG		2
#define MAXLEVEL_CT_DMG			2
#define MAXLEVEL_TERR_REGENERATION	4
#define MAXLEVEL_CT_REGENERATION	5
#define MAXLEVEL_TERR_INVISIBILITY	8
#define MAXLEVEL_CT_INVISIBILITY	6

// The xp amount required to buy the first level

#define FIRST_XP_GRENADE		100
#define FIRST_XP_FLASHBANG_1		100
#define FIRST_XP_FLASHBANG_2		100
#define FIRST_XP_SMOKEGRENADE		100
#define FIRST_XP_TERR_HEALTH		200
#define FIRST_XP_CT_HEALTH		300
#define FIRST_XP_TERR_ARMOR		200
#define FIRST_XP_CT_ARMOR		300
#define FIRST_XP_TERR_RESPAWN		3000
#define FIRST_XP_CT_RESPAWN		6000
#define FIRST_XP_TERR_NOFALL		400
#define FIRST_XP_CT_NOFALL		500
#define FIRST_XP_TERR_DMG		3000
#define FIRST_XP_CT_DMG			3500
#define FIRST_XP_TERR_REGENERATION	2700
#define FIRST_XP_CT_REGENERATION	2700
#define FIRST_XP_TERR_INVISIBILITY	5000
#define FIRST_XP_CT_INVISIBILITY	5000

// The maximum chance possible for this ability (happens when player has maximum level)

#define CHANCE_MAX_GRENADE		100
#define CHANCE_MAX_FLASHBANG_1		100
#define CHANCE_MAX_FLASHBANG_2		100
#define CHANCE_MAX_SMOKEGRENADE		100
#define CHANCE_MAX_TERR_RESPAWN		50
#define CHANCE_MAX_CT_RESPAWN		50
#define CHANCE_MAX_TERR_NOFALL		80
#define CHANCE_MAX_CT_NOFALL		80
#define CHANCE_MAX_CT_DMG		50
#define CHANCE_MAX_TERR_DMG		50

#include <amxmodx>
#include <amxmisc>
#include <cstrike>
#include < fakemeta >
#include <hamsandwich>
#include <fun>
#include <regex>
#include <hlsdk_const>
#include <colorchat>

#if defined USING_SQL
#include <sqlx>

new Handle:g_sql_tuple;
#else
#include <nvault>

new g_vault;
#endif

new const VERSION[] =	"0.0.1";

#pragma semicolon 1

enum _:Grenades
{
	NADE_HE,
	NADE_FL1,
	NADE_FL2,
	NADE_SM
};

new const g_nade_enabled[Grenades] =
{
	ENABLE_GRENADE,
	ENABLE_FLASHBANG_1,
	ENABLE_FLASHBANG_2,
	ENABLE_SMOKEGRENADE
};

new const g_any_nade_enabled = ENABLE_GRENADE + ENABLE_FLASHBANG_1 + ENABLE_FLASHBANG_2 + ENABLE_SMOKEGRENADE;

new const g_nade_names[Grenades][] =
{
	"HE Grenade",
	"Flashbang #1",
	"Flashbang #2",
	"Frost Nade"
};

new const g_nade_classnames[Grenades][] =
{
	"weapon_hegrenade",
	"weapon_flashbang",
	"weapon_flashbang",
	"weapon_smokegrenade"
};

new const g_nade_maxlevels[Grenades] =
{
	MAXLEVEL_GRENADE,
	MAXLEVEL_FLASHBANG_1,
	MAXLEVEL_FLASHBANG_2,
	MAXLEVEL_SMOKEGRENADE
};

new const g_nade_first_xp[Grenades] =
{
	FIRST_XP_GRENADE,
	FIRST_XP_FLASHBANG_1,
	FIRST_XP_FLASHBANG_2,
	FIRST_XP_SMOKEGRENADE
};

new const g_nade_max_chance[Grenades] =
{
	CHANCE_MAX_GRENADE,
	CHANCE_MAX_FLASHBANG_1,
	CHANCE_MAX_FLASHBANG_2,
	CHANCE_MAX_SMOKEGRENADE
};

new const g_team_names[CsTeams][] =
{
	"Spectator",
	"Terrorist",
	"Counter-Terrorist",
	"Spectator"
};

new const g_health_enabled[CsTeams] =
{
	0,
	ENABLE_TERR_HEALTH,
	ENABLE_CT_HEALTH,
	0
};

new const g_any_health_enabled = ENABLE_TERR_HEALTH + ENABLE_CT_HEALTH;

new iHealth[ 33 ];

new const g_health_names[CsTeams][] =
{
	"",
	"T Extra Health",
	"CT Extra Health",
	""
};

new const g_health_maxamount[CsTeams] =
{
	0,
	MAXLEVEL_TERR_HEALTH * 10,
	MAXLEVEL_CT_HEALTH * 10,
	0
};

new const g_health_maxlevels[CsTeams] =
{
	0,
	MAXLEVEL_TERR_HEALTH,
	MAXLEVEL_CT_HEALTH,
	0
};

new const g_health_first_xp[CsTeams] =
{
	0,
	FIRST_XP_TERR_HEALTH,
	FIRST_XP_CT_HEALTH,
	0
};

new const g_armor_enabled[CsTeams] =
{
	0,
	ENABLE_TERR_ARMOR,
	ENABLE_CT_ARMOR,
	0
};

new const g_any_armor_enabled = ENABLE_TERR_ARMOR + ENABLE_CT_ARMOR;

new const g_armor_names[CsTeams][] =
{
	"",
	"T Armor",
	"CT Armor",
	""
};

new const g_armor_maxamount[CsTeams] =
{
	0,
	225,
	225,
	0
};

new const g_armor_maxlevels[CsTeams] =
{
	0,
	MAXLEVEL_TERR_ARMOR,
	MAXLEVEL_CT_ARMOR,
	0
};

new const g_armor_first_xp[CsTeams] =
{
	0,
	FIRST_XP_TERR_ARMOR,
	FIRST_XP_CT_ARMOR,
	0
};

new const g_respawn_enabled[CsTeams] =
{
	0,
	ENABLE_TERR_RESPAWN,
	ENABLE_CT_RESPAWN,
	0
};

new const g_any_respawn_enabled = ENABLE_TERR_RESPAWN + ENABLE_CT_RESPAWN;

new const g_respawn_names[CsTeams][] =
{
	"",
	"T Respawn Chance",
	"CT Respawn Chance",
	""
};

new const g_respawn_maxlevels[CsTeams] =
{
	0,
	MAXLEVEL_TERR_RESPAWN,
	MAXLEVEL_CT_RESPAWN,
	0
};

new const g_respawn_first_xp[CsTeams] =
{
	0,
	FIRST_XP_TERR_RESPAWN,
	FIRST_XP_CT_RESPAWN,
	0
};

new const g_respawn_max_chance[CsTeams] =
{
	0,
	CHANCE_MAX_TERR_RESPAWN,
	CHANCE_MAX_CT_RESPAWN,
	0
};
///////////////////////////////////////////
new const g_nofall_enabled[CsTeams] =
{
	0,
	ENABLE_TERR_NOFALL,
	ENABLE_CT_NOFALL,
	0
};

new const g_any_nofall_enabled = ENABLE_TERR_NOFALL + ENABLE_CT_NOFALL;

new const g_nofall_names[CsTeams][] =
{
	"",
	"T Fall Damage Reducer",
	"CT Fall Damage Reducer",
	""
};

new const g_nofall_maxlevels[CsTeams] =
{
	0,
	MAXLEVEL_TERR_NOFALL,
	MAXLEVEL_CT_NOFALL,
	0
};

new const g_nofall_first_xp[CsTeams] =
{
	0,
	FIRST_XP_TERR_NOFALL,
	FIRST_XP_CT_NOFALL,
	0
};

new const g_nofall_max_chance[CsTeams] =
{
	0,
	CHANCE_MAX_TERR_NOFALL,
	CHANCE_MAX_CT_NOFALL,
	0
};
/////////////////////////////////////
new const g_dmg_enabled[CsTeams] =
{
	0,
	ENABLE_TERR_DMG,
	ENABLE_CT_DMG,
	0
};

new const g_any_dmg_enabled = ENABLE_TERR_DMG + ENABLE_CT_DMG;

new const g_dmg_names[CsTeams][] =
{
	"",
	"T Increase Damage",
	"CT Increase Damage",
	""
};

new const g_dmg_maxlevels[CsTeams] =
{
	0,
	MAXLEVEL_TERR_DMG,
	MAXLEVEL_CT_DMG,
	0
};

new const g_dmg_first_xp[CsTeams] =
{
	0,
	FIRST_XP_TERR_DMG,
	FIRST_XP_CT_DMG,
	0
};
new const g_dmg_max_chance[CsTeams] =
{
	0,
	CHANCE_MAX_TERR_DMG,
	CHANCE_MAX_CT_DMG,
	0
};

new const g_regeneration_enabled[CsTeams] =
{
	0,
	ENABLE_TERR_REGENERATION,
	ENABLE_CT_REGENERATION,
	0
};

new const g_any_regeneration_enabled = ENABLE_TERR_REGENERATION + ENABLE_CT_REGENERATION;

new const g_regeneration_names[CsTeams][] =
{
	"",
	"T Regeneration",
	"CT Regeneration",
	""
};

new const g_regeneration_maxamount[CsTeams] =
{
	0,
	MAXLEVEL_TERR_REGENERATION * 10,
	MAXLEVEL_CT_REGENERATION * 10,
	0
};

new const g_regeneration_maxlevels[CsTeams] =
{
	0,
	MAXLEVEL_TERR_REGENERATION,
	MAXLEVEL_CT_REGENERATION,
	0
};

new const g_regeneration_first_xp[CsTeams] =
{
	0,
	FIRST_XP_TERR_REGENERATION,
	FIRST_XP_CT_REGENERATION,
	0
};

new const g_invisibility_enabled[CsTeams] =
{
	0,
	ENABLE_TERR_INVISIBILITY,
	ENABLE_CT_INVISIBILITY,
	0
};

new const g_any_invisibility_enabled = ENABLE_TERR_INVISIBILITY + ENABLE_CT_INVISIBILITY;

new const g_invisibility_names[CsTeams][] =
{
	"",
	"T Invisibility",
	"CT Invisibility",
	""
};

new const g_invisibility_maxamount[CsTeams] =
{
	0,
	200,
	150,
	0
};

new const g_invisibility_maxlevels[CsTeams] =
{
	0,
	MAXLEVEL_TERR_INVISIBILITY,
	MAXLEVEL_CT_INVISIBILITY,
	0
};

new const g_invisibility_first_xp[CsTeams] =
{
	0,
	FIRST_XP_TERR_INVISIBILITY,
	FIRST_XP_CT_INVISIBILITY,
	0
};

#define ANY_ABILITY_ENABLED (g_any_nade_enabled || g_any_health_enabled || g_any_armor_enabled || g_any_respawn_enabled || g_any_nofall_enabled || g_any_dmg_enabled || g_any_regeneration_enabled || g_any_invisibility_enabled)

#define DAMAGE_ALPHA_RESET		6
#define TASK_ID_RESET			4163

#define IN_MOVEMENT			(IN_FORWARD|IN_MOVELEFT|IN_MOVERIGHT|IN_BACK)

new g_authid[33][35];
new g_xp[33];

new cacheUserName[ 33 ];

new g_first_time[33];
#if defined USING_SQL
new g_loaded_data[33];
#endif

new g_used_revive[33];

new g_nade_level[33][Grenades];
new g_armor_level[33][CsTeams];
new g_respawn_level[33][CsTeams];
new g_health_level[33][CsTeams];
new g_nofall_level[33][CsTeams];
new g_dmg_level[33][CsTeams];
new g_regeneration_level[ 33 ][ CsTeams ];
new g_invisibility_level[ 33 ][ CsTeams ];

new g_alpha[ 33 ];
new g_moving[ 33 ];
new g_stop_alpha[ 33 ];
new g_interval[ 33 ];

new cvar_xp_suicide;
new cvar_xp_kill;
new cvar_xp_headshot;
new cvar_xp_grenade;
new cvar_xp_survive;
new cvar_xp_win;
new cvar_spawn_nade_delay;

new const cfgfile_name[ ] = "hnsxp_cvars";

new bool:g_grenade_give_round[ 33 ];
new bool:iRoundStarted;

new g_first_client;
new g_max_clients;

#define VIP_FLAG	ADMIN_LEVEL_E
new bool:iAdmin[ 33 ];

native bm_player_stealth_duration( client );

#if defined USING_SQL
public plugin_precache()
{
	g_sql_tuple = SQL_MakeStdTuple();

	SQL_ThreadQuery(g_sql_tuple, "QueryCreateTable", "CREATE TABLE IF NOT EXISTS `hns_xp` ( `name` VARCHAR(32) NOT NULL, `authid` VARCHAR(35) NOT NULL, `data` VARCHAR(256) NOT NULL );" );
}

public QueryCreateTable(failstate, Handle:query, error[], errnum, data[], size, Float:queuetime)
{
	if( failstate == TQUERY_CONNECT_FAILED
	|| failstate == TQUERY_QUERY_FAILED )
	{
		set_fail_state(error);
	}
}
#endif

// Happy Hour
/*new hh_start, hh_end;
new bool:iHappyHourStarted;*/

public plugin_init()
{
	register_plugin("HideNSeek XP Mod", VERSION, "Exolent");

	register_clcmd("say /xp", "CmdMainMenu");
	register_clcmd("say /exp", "CmdMainMenu");

	register_clcmd( "give_xp", "cmdGiveFunction" );
	register_clcmd( "give_xp_all", "cmdGiveAllFunction" );
	register_clcmd( "remove_xp", "cmdRemoveFunction" );

	register_concmd("hnsxp_give_xp", "CmdGiveXP", ADMIN_RCON, "<nick, #userid, authid> <xp>");
	register_concmd("hnsxp_remove_xp", "CmdRemoveXP", ADMIN_RCON, "<nick, #userid, authid> <xp>");
	register_concmd("hnsxp_giveall", "CmdGiveAllXP", ADMIN_RCON, "<xp>");

	register_event("DeathMsg", "EventDeathMsg", "a");
	register_event("TextMsg", "EventRoundRestart", "a", "2&#Game_C", "2&#Game_w");

	register_logevent( "EventRoundStart", 2, "1=Round_Start" );
	register_logevent("EventRoundEnd", 2, "1=Round_End");

	RegisterHam(Ham_Spawn, "player", "FwdPlayerSpawn", 1);
	RegisterHam(Ham_Killed, "player", "FwdPlayerDeath", 1);
	RegisterHam(Ham_TakeDamage, "player", "FwdPlayerDamage");

	register_forward(FM_CmdStart, "FwdCmdStart");
	register_forward(FM_AddToFullPack, "FwdAddToFullPack", 1);

	cvar_xp_suicide = register_cvar("hnsxp_xp_suicide", "5");
	cvar_xp_kill = register_cvar("hnsxp_xp_kill", "40");
	cvar_xp_headshot = register_cvar("hnsxp_xp_headshot", "80");
	cvar_xp_grenade = register_cvar("hnsxp_xp_grenade", "100");
	cvar_xp_survive = register_cvar("hnsxp_xp_survive", "30");
	cvar_xp_win = register_cvar("hnsxp_xp_win", "60");
	cvar_spawn_nade_delay = register_cvar("hnsxp_spawn_nade_delay", "4");

	/*hh_start = register_cvar( "hnsxp_hh_start", "17" );
	hh_end = register_cvar( "hnsxp_hh_end", "05" );*/

	#if !defined USING_SQL
	g_vault = nvault_open("hnsxp");
	#endif

	g_first_client = 1;
	g_max_clients = get_maxplayers();

	//iHappyHourStarted = false;

	set_task( 1.0, "taskLoadConfigurationFile" );
}

#if !defined USING_SQL
public plugin_end()
{
	nvault_close(g_vault);
}
#endif

public plugin_natives()
{
	register_library("hns_xp");
	register_native("hnsxp_get_user_xp", "_get_xp");
	register_native("hnsxp_set_user_xp", "_set_xp");

	register_native( "hnsxp_get_user_health", "_get_health" );
}

public _get_xp(plugin, params)
{
	return g_xp[get_param(1)];
}

public _set_xp(plugin, params)
{
	new client = get_param(1);
	g_xp[client] = max(0, get_param(2));
	Save(client);
	return g_xp[client];
}

public _get_health(plugin, params) { return iHealth[get_param(1)]; }

public client_authorized(client)
{
	iAdmin[ client ] = ( get_user_flags( client ) & VIP_FLAG ) ? true : false;

	if( !is_user_bot(client) && !is_user_hltv(client) )
	{
		get_user_name(client, g_authid[client], sizeof(g_authid[]) - 1);
		Load(client);
	}
}

public client_disconnect(client)
{
	Save(client);

	iAdmin[ client ] = false;

	g_alpha[client] = 255;
	g_moving[client] = 0;
	remove_task(TASK_ID_RESET + client);

	g_authid[client][0] = 0;
	g_first_time[client] = 0;
	#if defined USING_SQL
	g_loaded_data[client] = 0;
	#endif
	g_used_revive[client] = 0;
}

public client_putinserver( client )
{
	if( iRoundStarted ) g_grenade_give_round[ client ] = true;
}

public CmdMainMenu(client)
{
	ShowMainMenu(client);
}

public CmdGiveAllXP( client, level, cid )
{
	if( !cmd_access( client, level, cid, 2 ) ) return PLUGIN_HANDLED;

	new arg[ 32 ];
	read_argv( 1, arg, charsmax( arg ) );

	if( str_to_num( arg ) <= 0 ) return PLUGIN_HANDLED;

	new iPlayers[ 32 ], iNum;
	get_players( iPlayers, iNum, "ch" );

	for( new i; i < iNum; i++ )
	{
		g_xp[ iPlayers[i] ] += str_to_num( arg );
		BlindPlayer( iPlayers[i], 1.0, 1.0, 0, 255, 0, 120 );
		Save( iPlayers[i] );
	}

	new name[ 33 ];
	get_user_name( client, name, charsmax( name ) );

	ColorChat( 0, GREEN, "[BetterPlay]^1 ADMIN:^3 %s^1 give^4 %d^1 XP to^3 All Players.", name, str_to_num( arg ) );

	return PLUGIN_HANDLED;
}

public CmdGiveXP(client, level, cid)
{
	if( !cmd_access(client, level, cid, 3) ) return PLUGIN_HANDLED;

	static arg[35];
	read_argv(1, arg, charsmax( arg ) );

	new target = cmd_target(client, arg, CMDTARGET_NO_BOTS);
	if( !target ) return PLUGIN_HANDLED;

	if( !IsUserAuthorized(target) )
	{
		console_print(client, "Target has not authorized with the server.");
		return PLUGIN_HANDLED;
	}

	read_argv(2, arg, sizeof(arg) - 1);
	new xp = str_to_num(arg);

	if( xp <= 0 )
	{
		console_print(client, "XP must be a value greater than 0!");
		if( xp < 0 )
		{
			console_print(client, "Use hnsxp_remove_xp instead.");
		}
		return PLUGIN_HANDLED;
	}

	g_xp[target] += xp;
	BlindPlayer( target, 1.0, 1.0, 0, 255, 0, 120 );

	Save(target);

	static name[2][32];
	get_user_name(client, name[0], sizeof(name[]) - 1);
	get_user_name(target, name[1], sizeof(name[]) - 1);

	ColorChat(0, GREEN, "^4[BetterPlay] ^3%s ^1gave ^4%i ^1XP to ^3%s.", name[0], xp, name[1]);

	return PLUGIN_HANDLED;
}

public CmdRemoveXP(client, level, cid)
{
	if( !cmd_access(client, level, cid, 3) ) return PLUGIN_HANDLED;

	static arg[35];
	read_argv(1, arg, charsmax( arg ) );

	new target = cmd_target(client, arg, CMDTARGET_NO_BOTS);
	if( !target ) return PLUGIN_HANDLED;

	if( !IsUserAuthorized(target) )
	{
		console_print(client, "Target has not authorized with the server.");
		return PLUGIN_HANDLED;
	}

	read_argv(2, arg, sizeof(arg) - 1);
	new xp = str_to_num(arg);

	if( xp <= 0 )
	{
		console_print(client, "XP must be a value greater than 0!");
		if( xp < 0 )
		{
			console_print(client, "Use hnsxp_give_xp instead.");
		}
		return PLUGIN_HANDLED;
	}

	g_xp[target] -= xp;
	BlindPlayer( target, 1.0, 1.0, 255, 0, 0, 120 );

	Save(target);

	static name[2][32];
	get_user_name(client, name[0], sizeof(name[]) - 1);
	get_user_name(target, name[1], sizeof(name[]) - 1);

	ColorChat(0, GREEN, "^4[BetterPlay] ^3%s ^1removed ^4%i ^1XP from ^3%s.", name[0], xp, name[1]);

	return PLUGIN_HANDLED;
}

public EventDeathMsg()
{
	new killer = read_data(1);
	new victim = read_data(2);

	if( (g_first_client <= killer <= g_max_clients) && victim != killer )
	{
		if( IsUserAuthorized(killer) )
		{
			if( is_user_connected( killer ) && is_user_alive( killer ) )
			{
				new CsTeams:team = cs_get_user_team( killer );
				new regeneration = g_regeneration_maxamount[ team ] * g_regeneration_level[ killer ][ team ] / g_regeneration_maxlevels[ team ];

				if( regeneration )
				{
					set_user_health( killer, get_user_health( killer ) + regeneration );
					BlindPlayer( killer, 0.8, 0.8, 255, 0, 0, 100 );
				}
			}

			new weapon[ 20 ], name[ 33 ];
			read_data( 4, weapon, sizeof( weapon ) - 1 );
			get_user_name( victim, name, charsmax( name ) );

			/*new iTime[ 3 ]
			get_time( "%H", iTime, charsmax( iTime ) );

			new get_hour = str_to_num( iTime );
			new get_start = get_pcvar_num( hh_start );
			new get_end = get_pcvar_num( hh_end );

			if( get_start < get_end ? ( get_start <= get_hour && get_hour < get_end ) : ( get_start <= get_hour || get_hour < get_end ) )
			{
				// regular kill
				new xp = get_pcvar_num(cvar_xp_kill) * 2;

				if( read_data(3) )
				{
					// headshot kill
					xp += get_pcvar_num(cvar_xp_headshot) * 2;
				}
				else
				{
					if( contain(weapon, "grenade") >= 0 )
					{
						// grenade kill (or frostnade)
						xp += get_pcvar_num(cvar_xp_grenade) * 2;
					}
				}

				new reward;
				if( iAdmin[ killer ] )
				{
					reward = xp + xp;
				}
				else
				{
					reward = xp;
				}

				g_xp[killer] += reward;

				new msg[ 128 ];
				iAdmin[ killer ] ? formatex( msg, sizeof( msg ) - 1, " (Bonus:^3 %d^4 XP^1 for^4 VIP^3 Users^1)", xp ) : formatex( msg, sizeof( msg ) - 1, " (buy^3 VIP^1 to get^4 more^3 XP^1)" );

				ColorChat(killer, GREEN, "^4[BetterPlay] ^1You gained ^3%i ^1XP for killing ^4%s^1 (^3happyhour^1)%s", reward, name, msg );
			}
			else
			{*/
			// regular kill
			new xp = get_pcvar_num(cvar_xp_kill);

			if( read_data(3) )
			{
				// headshot kill
				xp += get_pcvar_num(cvar_xp_headshot);
			}
			else
			{
				if( contain(weapon, "grenade") >= 0 )
				{
					// grenade kill (or frostnade)
					xp += get_pcvar_num(cvar_xp_grenade);
				}
			}

			new reward;
			if( iAdmin[ killer ] )
			{
				reward = xp + xp;
			}
			else
			{
				reward = xp;
			}

			g_xp[killer] += reward;

			new msg[ 128 ];
			iAdmin[ killer ] ? formatex( msg, sizeof( msg ) - 1, " (Bonus:^3 %d^4 XP^1 for^4 VIP^3 Users^1)", xp ) : formatex( msg, sizeof( msg ) - 1, " (buy^3 VIP^1 to get^4 more^3 XP^1)" );

			ColorChat(killer, GREEN, "^4[BetterPlay] ^1You gained ^3%i ^1XP for killing ^4%s^1!%s", reward, name, msg );
			//}

			Save(killer);
		}
	}
	else if( IsUserAuthorized(victim) )
	{
		// victim died of map causes or killed self
		new xp = get_pcvar_num(cvar_xp_suicide);

		g_xp[victim] -= xp;

		ColorChat(victim, GREEN, "^4[BetterPlay] ^1You lost ^3%i ^1XP!", xp);

		Save(victim);
	}
}

public EventRoundRestart( )
{
	//remove_task(1234);
	remove_task(1223);
	arrayset( g_grenade_give_round, false, charsmax( g_grenade_give_round ) );
}

public EventRoundStart( )
{
	for( new client = g_first_client; client <= g_max_clients; client++ )
	{
		if( is_user_alive( client ) && is_user_connected( client ) )
		{
			set_task( get_pcvar_float( cvar_spawn_nade_delay ), "TaskGiveNades", client );
			set_task( 1.0, "taskSet", client );
		}
	}

	iRoundStarted = true;

	/*new iTime[ 3 ], iHour;
	get_time( "%H", iTime, charsmax( iTime ) );
	iHour = str_to_num( iTime );

	if( !iHappyHourStarted )
	{
		if( iHour == get_pcvar_num( hh_start ) )
		{
			iHappyHourStarted = true;

			ColorChat( 0, GREEN, "[BetterPlay]^3 Happy Hour^1 Stared!" );
			ColorChat( 0, GREEN, "[BetterPlay]^3 All players^1 will gain^4 double XP^3 now!" );
		}
	}
	else
	{
		if( iHour == get_pcvar_num( hh_end ) )
		{
			iHappyHourStarted = false;

			ColorChat( 0, GREEN, "[BetterPlay]^3 Happy Hour^1 Ended!" );
			ColorChat( 0, GREEN, "[BetterPlay]^3 All players^1 will gain^4 normal XP^3 now!" );
		}
	}*/
}

public taskSet( client ) { if( is_user_connected( client ) ) { g_grenade_give_round[ client ] = true; } }

public TaskGiveNades( client )
{
	if( !is_user_connected( client ) || !is_user_alive( client ) ) return PLUGIN_HANDLED;

	new CsTeams:team = cs_get_user_team(client);
	if( team == CS_TEAM_T )
	{
		static percent;
		for( new i = 0; i < Grenades; i++ )
		{
			if( g_nade_enabled[i] )
			{
				percent = g_nade_max_chance[i] * g_nade_level[client][i] / g_nade_maxlevels[i];
				if( percent > 0 && (percent == 100 || random_num(1, 100) <= percent) )
				{
					give_item(client, g_nade_classnames[i]);
					if( percent < 100 ) ColorChat( client, GREEN, "[BetterPlay]^1 You received your^3 %s^1! ^3(^4%i%%^1 chance^3)", g_nade_names[i], percent);
				}
			}
		}
	}

	return PLUGIN_CONTINUE;
}

public EventRoundEnd()
{
	new hider, seeker, hider_alive;
	arrayset( g_grenade_give_round, false, charsmax( g_grenade_give_round ) );
	iRoundStarted = false;

	for( new i = g_first_client; i <= g_max_clients; i++ )
	{
		if( is_user_connected(i) )
		{
			switch( cs_get_user_team(i) )
			{
				case CS_TEAM_CT:
				{
					if( !seeker )
					{
						seeker = i;
					}
				}
				case CS_TEAM_T:
				{
					if( !hider )
					{
						hider = i;

						if( !hider_alive && is_user_alive(i) )
						{
							hider_alive = i;
						}
					}
				}
			}

			if( seeker && hider && hider_alive )
			{
				break;
			}
		}
	}

	if( !hider || !seeker )
	{
		return;
	}

	new CsTeams:winner = CS_TEAM_CT;

	if( hider_alive )
	{
		winner = CS_TEAM_T;

		new survive = get_pcvar_num(cvar_xp_survive);
		for( new client = g_first_client; client <= g_max_clients; client++ )
		{
			if( IsUserAuthorized(client) && is_user_alive(client) && cs_get_user_team(client) == CS_TEAM_T )
			{
				g_xp[client] += survive;
				Save(client);

				ColorChat(client, GREEN, "^4[BetterPlay] ^1You gained ^3%i ^1XP for surviving!", survive);
			}
		}
	}

	new win = get_pcvar_num(cvar_xp_win);
	for( new client = g_first_client; client <= g_max_clients; client++ )
	{
		if( IsUserAuthorized(client) && is_user_alive(client) && cs_get_user_team(client) == winner )
		{
			g_xp[client] += win;
			Save(client);

			ColorChat(client, GREEN, "^4[BetterPlay] ^1You gained ^3%i ^1XP for winning the round!", win);
		}
	}
}

public FwdPlayerSpawn(client)
{
	if( is_user_alive(client) )
	{
		new CsTeams:team = cs_get_user_team(client);
		if( team == CS_TEAM_T || team == CS_TEAM_CT )
		{
			if( g_first_time[client] )
			{
				ColorChat(client, GREEN, "^4[BetterPlay] ^1It is your first time playing this HideNSeek XP mod, so you are rewarded with %i XP!", ENTRY_XP);
				ColorChat(client, GREEN, "^4[BetterPlay] ^1You earn XP based upon your gameplay, and you can buy more levels in the menu.");
				ColorChat(client, GREEN, "^4[BetterPlay] ^1Type ^3/xp ^1to view what you can get!");

				g_first_time[client] = 0;
			}
			else
			{
				if( g_health_enabled[team] )
				{
					iHealth[ client ] = g_health_maxamount[team] * g_health_level[client][team] / g_health_maxlevels[team];

					if( iHealth[ client ] )
					{
						set_user_health(client, get_user_health(client) + iHealth[ client ] );
						ColorChat( client, GREEN, "[BetterPlay]^1 You got^3 %i HP^1 for having^3 %s^1 Level^4 %i^1!", iHealth[ client ], g_health_names[ team ], g_health_level[ client ][ team ] );
					}
				}

				if( g_armor_enabled[team] )
				{
					new armorvalue = g_armor_maxamount[team] * g_armor_level[client][team] / g_armor_maxlevels[team];
					if( armorvalue == 0 )
					{
						cs_set_user_armor(client, armorvalue, CS_ARMOR_NONE);
					}
					else if( armorvalue < 100 )
					{
						cs_set_user_armor(client, armorvalue, CS_ARMOR_KEVLAR);
					}
					else
					{
						cs_set_user_armor(client, armorvalue, CS_ARMOR_VESTHELM);
					}
				}

				if( g_invisibility_enabled[ team ] )
				{
					new alpha = g_invisibility_maxamount[ team ] * g_invisibility_level[ client ][ team ] / g_invisibility_maxlevels[ team ];

					g_alpha[client] = 255 - alpha;
					g_moving[client] = 1;
					remove_task(TASK_ID_RESET + client);
				}

				if( g_grenade_give_round[ client ] ) set_task( 1.0, "TaskGiveNades", client );
			}
		}
	}
}

public FwdPlayerDeath(client, killer, shouldgib)
{
	if( !g_used_revive[client] )
	{
		new CsTeams:team = cs_get_user_team(client);
		if( team == CS_TEAM_T || team == CS_TEAM_CT )
		{
			if( g_respawn_enabled[team] )
			{
				new percent = g_respawn_max_chance[team] * g_respawn_level[client][team] / g_respawn_maxlevels[team];
				if( random_num(1, 100) <= percent )
				{
					if( HasTeammateAlive(client, team) && team != CS_TEAM_SPECTATOR )
					{
						set_task(1.0, "TaskRespawn", client);
						g_used_revive[client] = 1;

						ColorChat(client, GREEN, "^4[BetterPlay] ^1You have been respawned! ^4(%i%% chance)", percent);
					}
				}
			}
		}
	}

	g_alpha[client] = 255;
	g_moving[client] = 0;
	remove_task(TASK_ID_RESET + client);
}

public FwdPlayerDamage(client, inflictor, attacker, Float:damage, damagebits)
{
	if( is_user_alive(client) && is_user_connected( client ) )
	{
		new CsTeams:team = cs_get_user_team(client);
		if( team == CS_TEAM_T || team == CS_TEAM_CT )
		{
			if( damagebits & DMG_FALL )
			{
				if( g_nofall_enabled[team] )
				{
					new percent = g_nofall_max_chance[team] * g_nofall_level[client][team] / g_nofall_maxlevels[team];
					new Float:reduction = float(floatround((damage * float(percent) / 100.0), floatround_floor));

					SetHamParamFloat(4, damage - reduction);

					if( percent > 0 )
					{
						set_hudmessage( 0, 127, 255, -1.0, 0.35, 0, 3.0, 3.0, 0.1, 0.2, 4 );
						show_hudmessage( client, "Fall Damage Reducer^nLevel %i^n^nInitial Damage: %.1f^nDamage Taken: %.1f", g_nofall_level[ client ][ team ], damage, ( damage - reduction ) );
					}
				}
			}

			if( g_invisibility_enabled[ team ] )
			{
				new alpha = g_invisibility_maxamount[ team ] * g_invisibility_level[ client ][ team ] / g_invisibility_maxlevels[ team ];

				if( alpha > 0 )
				{
					g_alpha[client] = 255;
					g_interval[client] = 0;
					g_stop_alpha[client] = alpha;

					remove_task(TASK_ID_RESET + client);
					set_task(1.0, "TaskResetAlpha", (TASK_ID_RESET + client));
				}
			}
		}
	}

	if( is_user_alive( attacker ) && is_user_connected( attacker ) )
	{
		new CsTeams:team = cs_get_user_team(attacker);
		if( team == CS_TEAM_T || team == CS_TEAM_CT )
		{
			if( g_dmg_enabled[ team ] )
			{
				new percent = g_dmg_max_chance[ team ] * g_dmg_level[ attacker ][ team ] / g_dmg_maxlevels[ team ];
				if( ( 1 <= attacker <= g_max_clients ) && random_num( 1, 100 ) <= percent )
				{
					SetHamParamFloat( 4, damage * ( float( percent ) / 39.0 ) );
				}
			}
		}
	}
}

public RemoveXPInvisibility( client )
{
	new CsTeams:team = cs_get_user_team(client);
	if( team == CS_TEAM_T || team == CS_TEAM_CT )
	{
		if( g_invisibility_enabled[ team ] )
		{
			new alpha = g_invisibility_maxamount[ team ] * g_invisibility_level[ client ][ team ] / g_invisibility_maxlevels[ team ];

			if( alpha > 0 )
			{
				g_alpha[client] = 255;
				g_interval[client] = 0;
				g_stop_alpha[client] = alpha;

				remove_task(TASK_ID_RESET + client);

				new iTime = bm_player_stealth_duration( client );
				set_task(float(iTime), "TaskResetAlpha", (TASK_ID_RESET + client));
			}
		}
	}
}

public TaskRespawn(client)
{
	if( !is_user_connected( client ) ) return PLUGIN_HANDLED;

	new CsTeams:team = cs_get_user_team( client );
	if( team == CS_TEAM_T || team == CS_TEAM_CT )
	{
		ExecuteHamB(Ham_CS_RoundRespawn, client);
	}

	return PLUGIN_CONTINUE;
}

HasTeammateAlive(client, CsTeams:team)
{
	for( new i = g_first_client; i <= g_max_clients; i++ )
	{
		if( i == client ) continue;

		if( is_user_alive(i) && cs_get_user_team(i) == team )
		{
			return 1;
		}
	}

	return 0;
}

public TaskResetAlpha(taskid)
{
	new client = taskid - TASK_ID_RESET;

	if( ++g_interval[client] <= DAMAGE_ALPHA_RESET )
	{
		g_alpha[client] = 255 - g_stop_alpha[ client ] * g_interval[ client ] / DAMAGE_ALPHA_RESET;

		if( g_interval[client] < DAMAGE_ALPHA_RESET )
		{
			set_task(1.0, "TaskResetAlpha", (TASK_ID_RESET + client));
		}
	}
}

public FwdCmdStart(client, uc_handle, random_seed)
{
	if( is_user_alive(client) )
	{
		new buttons = get_uc(uc_handle, UC_Buttons);
		g_moving[client] = ( buttons & IN_MOVEMENT || (buttons & IN_JUMP) && !(pev(client, pev_oldbuttons) & IN_JUMP) );
	}
}

public FwdAddToFullPack(es, e, ent, host, host_flags, player, pSet)
{
	if( player )
	{
		if( g_alpha[ent] != 255 && cs_get_user_team(ent) != cs_get_user_team(host) )
		{
			set_es(es, ES_RenderMode, kRenderTransAdd);
			set_es(es, ES_RenderAmt, g_alpha[ent] / (g_moving[ent] + 1));
		}
	}
}

ShowMainMenu(client)
{
	static title[128];
	formatex(title, sizeof(title) - 1, "[BetterPlay XP Mod]^nMain Menu^n^nYour XP: \w%i^n\yPage\d:\r", g_xp[client]);
	new menu = menu_create(title, "MenuMain");

	new iText[ 64 ];
	formatex( iText, sizeof( iText ) - 1, "\yHelp%s", get_user_flags( client ) & ADMIN_RCON ? "" : "^n" );
	menu_additem(menu, iText, "*");

	if( get_user_flags( client ) & ADMIN_RCON )
	{
		menu_additem( menu, "\yAdmin \wMenu^n", "1");
	}
	if( g_any_nade_enabled )
	{
		menu_additem(menu, "\yGrenades \wMenu", "2");
	}
	if( g_any_health_enabled )
	{
		menu_additem(menu, "\yHealth \wMenu", "3");
	}
	if( g_any_armor_enabled )
	{
		menu_additem(menu, "\yArmor \wMenu", "4");
	}
	if( g_any_respawn_enabled )
	{
		menu_additem(menu, "\yRespawn \wMenu", "5");
	}
	if( g_any_nofall_enabled )
	{
		menu_additem(menu, "\yFall Damage \wMenu", "6");
	}
	if( g_any_dmg_enabled )
	{
		menu_additem( menu, "\yIncrease Damage \wMenu", "7");
	}

	if( g_any_regeneration_enabled )
	{
		menu_additem( menu, "\yRegeneration \wMenu", "8");
	}

	if( g_any_invisibility_enabled )
	{
		menu_additem( menu, "\yInvisibility \wMenu^n", "9");
	}

	if( ANY_ABILITY_ENABLED )
	{
		menu_additem(menu, "\yPlayer \wInfo", "=", ADMIN_IMMUNITY);
	}

	menu_display(client, menu);
}

public MenuMain(client, menu, item)
{
	if( item == MENU_EXIT )
	{
		menu_destroy(menu);
		return;
	}

	static _access, info[4], callback;
	menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
	menu_destroy(menu);

	switch( info[0] )
	{
		case '*':
		{
			static motd[2500];
			new len = formatex(motd, sizeof(motd) - 1,	"<body style=^"background-color:#030303; color:#FF8F00^">");
			len += format(motd[len], sizeof(motd) - len - 1,	"<p align=^"center^">");
			len += format(motd[len], sizeof(motd) - len - 1,	"HideNSeek XP Mod is an experienced based addon for HideNSeek.<br>");
			len += format(motd[len], sizeof(motd) - len - 1,	"Players earn experience points by how well they play the game.<br>");
			len += format(motd[len], sizeof(motd) - len - 1,	"<br>");
			len += format(motd[len], sizeof(motd) - len - 1,	"<table border=0>");
			len += format(motd[len], sizeof(motd) - len - 1,	"<tr><th>Action</th><th>XP</th></tr>");
			len += format(motd[len], sizeof(motd) - len - 1,	"<tr><td>Kill</td><td>+%i</td></tr>", get_pcvar_num(cvar_xp_kill));
			len += format(motd[len], sizeof(motd) - len - 1,	"<tr><td>Grenade</td><td>+%i</td></tr>", get_pcvar_num(cvar_xp_grenade));
			len += format(motd[len], sizeof(motd) - len - 1,	"<tr><td>Headshot</td><td>+%i</td></tr>", get_pcvar_num(cvar_xp_headshot));
			len += format(motd[len], sizeof(motd) - len - 1,	"<tr><td>Suicide</td><td>-%i</td></tr>", get_pcvar_num(cvar_xp_suicide));
			len += format(motd[len], sizeof(motd) - len - 1,	"<tr><td>Survive as a T</td><td>+%i</td></tr>", get_pcvar_num(cvar_xp_survive));
			len += format(motd[len], sizeof(motd) - len - 1,	"<tr><td>Win Round</td><td>+%i</td></tr>", get_pcvar_num(cvar_xp_win));
			len += format(motd[len], sizeof(motd) - len - 1,	"</table>");
			len += format(motd[len], sizeof(motd) - len - 1,	"With these XP points, you can buy upgrades.<br>");
			len += format(motd[len], sizeof(motd) - len - 1,	"For a list of these upgrades, type /xp again and view the other menus inside.");
			len += format(motd[len], sizeof(motd) - len - 1,	"</p>");
			len += format(motd[len], sizeof(motd) - len - 1,	"</body>");

			show_motd(client, motd, "HideNSeek XP Mod Info");
		}
		case '1':
		{
			ShowAdminMenu(client);
		}
		case '2':
		{
			ShowGrenadesMenu(client);
		}
		case '3':
		{
			ShowHealthMenu(client);
		}
		case '4':
		{
			ShowArmorMenu(client);
		}
		case '5':
		{
			ShowRespawnMenu(client);
		}
		case '6':
		{
			ShowNoFallMenu(client);
		}
		case '7':
		{
			ShowDamageMenu(client);
		}
		case '8':
		{
			ShowRegenerationMenu( client );
		}
		case '9':
		{
			ShowInvisibilityMenu( client );
		}
		case '=':
		{
			ShowPlayerMenu(client);
		}
	}
}

ShowAdminMenu( client )
{
	new title[ 128 ];
	formatex( title, sizeof( title ) - 1, "[BetterPlay XP Mod]^nAdmin Menu^n^nYour XP: \w%i", g_xp[ client ] );
	new menu = menu_create( title, "AdminMenuHandler" );

	menu_additem( menu, "\wGive \rXP \dto \yPlayer", "1", 0 );
	menu_additem( menu, "\wGive \rXP \dto \yAll \wPlayers", "2", 0 );
	menu_additem( menu, "\wRemove \rXP \dfrom \yPlayer", "3", 0 );

	menu_setprop( menu, MPROP_EXIT, MEXIT_ALL );
	menu_display( client, menu, 0 );

	return PLUGIN_HANDLED;
}

public AdminMenuHandler( client, menu, item )
{
	if( item == MENU_EXIT )
	{
		menu_destroy( menu );
		ShowMainMenu(client);
		return PLUGIN_HANDLED;
	}

	new iData[ 6 ], iName[ 63 ], iAccess, iCallback;
	menu_item_getinfo( menu, item, iAccess, iData, charsmax( iData ), iName, charsmax( iName ), iCallback );

	switch( str_to_num( iData ) )
	{
		case 1: CmdGiveMenu( client );
		case 2: client_cmd( client, "messagemode give_xp_all" );
		case 3: CmdRemoveMenu( client );
	}

	menu_destroy( menu );
	return PLUGIN_HANDLED;
}

CmdGiveMenu( client )
{
	new title[ 128 ];
	formatex( title, sizeof( title ) - 1, "[BetterPlay XP Mod]^nAdmin Menu^n^nYour XP: \w%i^n\rGive \yMenu", g_xp[ client ] );
	new menu = menu_create( title, "CmdGiveMenuHandler" );

	new iPlayers[ 32 ], iNum, tempid[ 10 ], iName[ 33 ];
	get_players( iPlayers, iNum, "ch" );

	for( new i; i < iNum; i++ )
	{
		new plr = iPlayers[ i ];

		num_to_str( plr, tempid, charsmax( tempid ) );
		get_user_name( plr, iName, charsmax( iName ) );

		menu_additem( menu, iName, tempid, 0 );
	}

	menu_setprop( menu, MPROP_EXIT, MEXIT_ALL );
	menu_display( client, menu );
}

public CmdGiveMenuHandler( client, menu, item )
{
	if( item == MENU_EXIT )
	{
		menu_destroy( menu );
		ShowMainMenu(client);
		return PLUGIN_HANDLED;
	}

	new iData[ 6 ], iName[ 63 ], iAccess, iCallback;
	menu_item_getinfo( menu, item, iAccess, iData, charsmax( iData ), iName, charsmax( iName ), iCallback );

	get_user_name( str_to_num( iData ), cacheUserName, charsmax( cacheUserName ) );
	client_cmd( client, "messagemode give_xp" );

	menu_destroy( menu );
	return PLUGIN_HANDLED;
}

CmdRemoveMenu( client )
{
	new title[ 128 ];
	formatex( title, sizeof( title ) - 1, "[BetterPlay XP Mod]^nAdmin Menu^n^nYour XP: \w%i^n\rRemove \yMenu", g_xp[ client ] );
	new menu = menu_create( title, "CmdRemoveMenuHandler" );

	new iPlayers[ 32 ], iNum, tempid[ 10 ], iName[ 33 ];
	get_players( iPlayers, iNum, "ch" );

	for( new i; i < iNum; i++ )
	{
		new plr = iPlayers[ i ];

		num_to_str( plr, tempid, charsmax( tempid ) );
		get_user_name( plr, iName, charsmax( iName ) );

		menu_additem( menu, iName, tempid, 0 );
	}

	menu_setprop( menu, MPROP_EXIT, MEXIT_ALL );
	menu_display( client, menu );
}

public CmdRemoveMenuHandler( client, menu, item )
{
	if( item == MENU_EXIT )
	{
		menu_destroy( menu );
		ShowMainMenu(client);
		return PLUGIN_HANDLED;
	}

	new iData[ 6 ], iName[ 63 ], iAccess, iCallback;
	menu_item_getinfo( menu, item, iAccess, iData, charsmax( iData ), iName, charsmax( iName ), iCallback );

	get_user_name( str_to_num( iData ), cacheUserName, charsmax( cacheUserName ) );
	client_cmd( client, "messagemode remove_xp" );

	menu_destroy( menu );
	return PLUGIN_HANDLED;
}

ShowGrenadesMenu(client)
{
	static title[128];
	formatex(title, sizeof(title) - 1, "[BetterPlay XP Mod]^nGrenades Menu^n^nNote: \wGrenade abilities are for \rT's Only!\y^n^nYour XP: \w%i", g_xp[client]);
	new menu = menu_create(title, "MenuGrenades");
	new callback = menu_makecallback("CallbackGrenades");

	menu_additem(menu, "\yHelp", "*", _, callback);

	static level, xp, percent, item[128], info[4];
	for( new i = 0; i < Grenades; i++ )
	{
		if( g_nade_enabled[i] )
		{
			level = g_nade_level[client][i] + 1;
			percent = g_nade_max_chance[i] * level / g_nade_maxlevels[i];

			if( g_nade_level[client][i] < g_nade_maxlevels[i] )
			{
				xp = g_nade_first_xp[i] * (1 << (level - 1));
				formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i%%) \r[\w%i XP\r]", g_nade_names[i], level, percent, xp);
			}
			else
			{
				formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i%%) \r[\wMaxed Out!\r]", g_nade_names[i], level, percent);
			}

			num_to_str(i, info, sizeof(info) - 1);

			menu_additem(menu, item, info, _, callback);
		}
	}

	menu_display(client, menu);
}

public MenuGrenades(client, menu, item)
{
	if( item == MENU_EXIT )
	{
		menu_destroy(menu);
		ShowMainMenu(client);
		return;
	}

	static _access, info[4], callback;
	menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
	menu_destroy(menu);

	if( info[0] == '*' )
	{
		static motd[2500];
		new len = formatex(motd, sizeof(motd) - 1,	"<body style=^"background-color:#030303; color:#FF8F00^">");
		len += format(motd[len], sizeof(motd) - len - 1,	"<p align=^"center^">");
		len += format(motd[len], sizeof(motd) - len - 1,	"The Grenades ability for the XP Mod is for Terrorists only.<br>");
		len += format(motd[len], sizeof(motd) - len - 1,	"The Grenades ability contains the HE Grenade, 2 Flashbangs, and Frost Nade.<br>");
		len += format(motd[len], sizeof(motd) - len - 1,	"These are the grenades you are given when you receive the your items after the hide timer ends.<br>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<br>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<table>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th></th>");
		for( new i = 0; i < Grenades; i++ )
		{
			if( g_nade_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<th>%s</th>", g_nade_names[i]);
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Chance Intervals</th>");
		for( new i = 0; i < Grenades; i++ )
		{
			if( g_nade_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i%%</td>", (g_nade_max_chance[i] / g_nade_maxlevels[i]));
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Max Level</th>");
		for( new i = 0; i < Grenades; i++ )
		{
			if( g_nade_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i</td>", g_nade_maxlevels[i]);
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Max Chance</th>");
		for( new i = 0; i < Grenades; i++ )
		{
			if( g_nade_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i%%</td>", g_nade_max_chance[i]);
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</table>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</p>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</body>");

		show_motd(client, motd, "XP Grenades Info");
	}
	else
	{
		new upgrade = str_to_num(info);

		new level = g_nade_level[client][upgrade] + 1;
		new xp = g_nade_first_xp[upgrade] * (1 << (level - 1));
		new percent = g_nade_max_chance[upgrade] * level / g_nade_maxlevels[upgrade];

		g_xp[client] -= xp;
		g_nade_level[client][upgrade] = level;

		Save(client);

		BlindPlayer( client, 1.0, 1.0, 255, 255, 0, 120 );

		ColorChat(client, GREEN, "^4[BetterPlay] ^1You bought ^3%s ^1Level ^4%i ^4(%i%%) ^1for ^3%i ^1XP!", g_nade_names[upgrade], level, percent, xp);
	}

	ShowGrenadesMenu(client);
}

public CallbackGrenades(client, menu, item)
{
	static _access, info[4], callback;
	menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);

	if( info[0] == '*' ) return ITEM_ENABLED;

	new upgrade = str_to_num(info);
	if( g_nade_level[client][upgrade] == g_nade_maxlevels[upgrade] )
	{
		return ITEM_DISABLED;
	}

	new xp = g_nade_first_xp[upgrade] * (1 << g_nade_level[client][upgrade]);
	if( g_xp[client] < xp )
	{
		return ITEM_DISABLED;
	}

	return ITEM_ENABLED;
}

ShowHealthMenu(client)
{
	static title[128];
	formatex(title, sizeof(title) - 1, "[BetterPlay XP Mod]^nHealth Menu^n^nYour XP: \w%i", g_xp[client]);
	new menu = menu_create(title, "MenuHealth");
	new callback = menu_makecallback("CallbackHealth");

	menu_additem(menu, "\yHelp", "*", _, callback);

	static level, xp, amount, item[128], info[4];
	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		if( g_health_enabled[i] )
		{
			level = g_health_level[client][i] + 1;
			amount = g_health_maxamount[i] * level / g_health_maxlevels[i];

			if( g_health_level[client][i] < g_health_maxlevels[i] )
			{
				xp = g_health_first_xp[i] * (1 << (level - 1));
				formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i HP) \r[\w%i XP\r]", g_health_names[i], level, amount, xp);
			}
			else
			{
				formatex(item, sizeof(item) - 1, "\w%s: \yLevel %i (%i HP) \r[\wMaxed Out!\r]", g_health_names[i], level, amount);
			}

			num_to_str(_:i, info, sizeof(info) - 1);

			menu_additem(menu, item, info, _, callback);
		}
	}

	menu_display(client, menu);
}

public MenuHealth(client, menu, item)
{
	if( item == MENU_EXIT )
	{
		menu_destroy(menu);
		ShowMainMenu(client);
		return;
	}

	static _access, info[4], callback;
	menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
	menu_destroy(menu);

	if( info[0] == '*' )
	{
		static motd[2500];
		new len = formatex(motd, sizeof(motd) - 1,	"<body style=^"background-color:#030303; color:#FF8F00^">");
		len += format(motd[len], sizeof(motd) - len - 1,	"<p align=^"center^">");
		len += format(motd[len], sizeof(motd) - len - 1,	"The Health ability is the amount of HP that is added to your spawn health.<br>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<br>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<table>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th></th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_health_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<th>%s</th>",g_team_names[i]);
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Health Intervals</th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_health_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i</td>", (g_health_maxamount[i] / g_health_maxlevels[i]));
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Max Level</th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_health_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i</td>", g_health_maxlevels[i]);
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Max Health</th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_health_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i</td>", g_health_maxamount[i]);
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</table>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</p>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</body>");

		show_motd(client, motd, "XP Health Info");
	}
	else
	{
		new CsTeams:upgrade = CsTeams:str_to_num(info);

		new level = g_health_level[client][upgrade] + 1;
		new xp = g_health_first_xp[upgrade] * (1 << (level - 1));
		new amount = g_health_maxamount[upgrade] * level / g_health_maxlevels[upgrade];

		g_xp[client] -= xp;
		g_health_level[client][upgrade] = level;

		Save(client);

		BlindPlayer( client, 1.0, 1.0, 255, 255, 0, 120 );

		ColorChat(client, GREEN, "^4[BetterPlay] ^1You bought ^3%s ^1Level ^4%i ^4(%i HP) ^1for ^3%i ^1XP!", g_health_names[upgrade], level, amount, xp);
	}

	ShowHealthMenu(client);
}

public CallbackHealth(client, menu, item)
{
	static _access, info[4], callback;
	menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);

	if( info[0] == '*' ) return ITEM_ENABLED;

	new CsTeams:upgrade = CsTeams:str_to_num(info);
	if( g_health_level[client][upgrade] == g_health_maxlevels[upgrade] )
	{
		return ITEM_DISABLED;
	}

	new xp = g_health_first_xp[upgrade] * (1 << g_health_level[client][upgrade]);
	if( g_xp[client] < xp )
	{
		return ITEM_DISABLED;
	}

	return ITEM_ENABLED;
}

ShowArmorMenu(client)
{
	static title[128];
	formatex(title, sizeof(title) - 1, "[BetterPlay XP Mod]^nArmor Menu^n^nYour XP: \w%i", g_xp[client]);
	new menu = menu_create(title, "MenuArmor");
	new callback = menu_makecallback("CallbackArmor");

	menu_additem(menu, "\yHelp", "*", _, callback);

	static level, xp, amount, item[128], info[4];
	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		if( g_armor_enabled[i] )
		{
			level = g_armor_level[client][i] + 1;
			amount = g_armor_maxamount[i] * level / g_armor_maxlevels[i];

			if( g_armor_level[client][i] < g_armor_maxlevels[i] )
			{
				xp = g_armor_first_xp[i] * (1 << (level - 1));
				formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i AP) \r[\w%i XP\r]", g_armor_names[i], level, amount, xp);
			}
			else
			{
				formatex(item, sizeof(item) - 1, "\w%s: \yLevel %i (%i AP) \r[\wMaxed Out!\r]", g_armor_names[i], level, amount);
			}

			num_to_str(_:i, info, sizeof(info) - 1);

			menu_additem(menu, item, info, _, callback);
		}
	}

	menu_display(client, menu);
}

public MenuArmor(client, menu, item)
{
	if( item == MENU_EXIT )
	{
		menu_destroy(menu);
		ShowMainMenu(client);
		return;
	}

	static _access, info[4], callback;
	menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
	menu_destroy(menu);

	if( info[0] == '*' )
	{
		static motd[2500];
		new len = formatex(motd, sizeof(motd) - 1,	"<body style=^"background-color:#030303; color:#FF8F00^">");
		len += format(motd[len], sizeof(motd) - len - 1,	"<p align=^"center^">");
		len += format(motd[len], sizeof(motd) - len - 1,	"The Armor ability is the amount of AP that given to you at spawn.<br>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<br>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<table>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th></th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_armor_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<th>%s</th>",g_team_names[i]);
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Armor Intervals</th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_armor_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i</td>", (g_armor_maxamount[i] / g_armor_maxlevels[i]));
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Max Level</th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_armor_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i</td>", g_armor_maxlevels[i]);
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Max Armor</th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_armor_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i</td>", g_armor_maxamount[i]);
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</table>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</p>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</body>");

		show_motd(client, motd, "XP Armor Info");
	}
	else
	{
		new CsTeams:upgrade = CsTeams:str_to_num(info);

		new level = g_armor_level[client][upgrade] + 1;
		new xp = g_armor_first_xp[upgrade] * (1 << (level - 1));
		new amount = g_armor_maxamount[upgrade] * level / g_armor_maxlevels[upgrade];

		g_xp[client] -= xp;
		g_armor_level[client][upgrade] = level;

		Save(client);

		BlindPlayer( client, 1.0, 1.0, 255, 255, 0, 120 );

		ColorChat(client, GREEN, "^4[BetterPlay] ^1You bought ^3%s ^1Level ^4%i (%i AP) ^1for ^3%i ^1XP!", g_armor_names[upgrade], level, amount, xp);
	}

	ShowArmorMenu(client);
}

public CallbackArmor(client, menu, item)
{
	static _access, info[4], callback;
	menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);

	if( info[0] == '*' ) return ITEM_ENABLED;

	new CsTeams:upgrade = CsTeams:str_to_num(info);
	if( g_armor_level[client][upgrade] == g_armor_maxlevels[upgrade] )
	{
		return ITEM_DISABLED;
	}

	new xp = g_armor_first_xp[upgrade] * (1 << g_armor_level[client][upgrade]);
	if( g_xp[client] < xp )
	{
		return ITEM_DISABLED;
	}

	return ITEM_ENABLED;
}

ShowRespawnMenu(client)
{
	static title[128];
	formatex(title, sizeof(title) - 1, "[BetterPlay XP Mod]^nRespawn Menu^n^nYour XP: \w%i", g_xp[client]);
	new menu = menu_create(title, "MenuRespawn");
	new callback = menu_makecallback("CallbackRespawn");

	menu_additem(menu, "\yHelp", "*", _, callback);

	static level, xp, percent, item[128], info[4];
	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		if( g_respawn_enabled[i] )
		{
			level = g_respawn_level[client][i] + 1;
			percent = g_respawn_max_chance[i] * level / g_respawn_maxlevels[i];

			if( g_respawn_level[client][i] < g_respawn_maxlevels[i] )
			{
				xp = g_respawn_first_xp[i] * (1 << (level - 1));
				formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i%%) \r[\w%i XP\r]", g_respawn_names[i], level, percent, xp);
			}
			else
			{
				formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i%%) \r[\wMaxed Out!\r]", g_respawn_names[i], level, percent);
			}

			num_to_str(_:i, info, sizeof(info) - 1);

			menu_additem(menu, item, info, _, callback);
		}
	}

	menu_display(client, menu);
}

public MenuRespawn(client, menu, item)
{
	if( item == MENU_EXIT )
	{
		menu_destroy(menu);
		ShowMainMenu(client);
		return;
	}

	static _access, info[4], callback;
	menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
	menu_destroy(menu);

	if( info[0] == '*' )
	{
		static motd[2500];
		new len = formatex(motd, sizeof(motd) - 1,	"<body style=^"background-color:#030303; color:#FF8F00^">");
		len += format(motd[len], sizeof(motd) - len - 1,	"<p align=^"center^">");
		len += format(motd[len], sizeof(motd) - len - 1,	"The Respawn ability is chance to be respawned when you die.<br>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<br>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<table>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th></th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_respawn_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<th>%s</th>",g_team_names[i]);
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Chance Intervals</th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_respawn_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i%%</td>", (g_respawn_max_chance[i] / g_respawn_maxlevels[i]));
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Max Level</th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_respawn_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i</td>", g_respawn_maxlevels[i]);
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Max Chance</th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_respawn_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i%%</td>", g_respawn_max_chance[i]);
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</table>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</p>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</body>");

		show_motd(client, motd, "XP Respawn Info");
	}
	else
	{
		new CsTeams:upgrade = CsTeams:str_to_num(info);

		new level = g_respawn_level[client][upgrade] + 1;
		new xp = g_respawn_first_xp[upgrade] * (1 << (level - 1));
		new percent = g_respawn_max_chance[upgrade] * level / g_respawn_maxlevels[upgrade];

		g_xp[client] -= xp;
		g_respawn_level[client][upgrade] = level;

		Save(client);

		BlindPlayer( client, 1.0, 1.0, 255, 255, 0, 120 );

		ColorChat(client, GREEN, "^4[BetterPlay] ^1You bought ^3%s ^1Level ^4%i (%i%%) ^1for ^3%i ^1XP!", g_respawn_names[upgrade], level, percent, xp);
	}

	ShowRespawnMenu(client);
}

public CallbackRespawn(client, menu, item)
{
	static _access, info[4], callback;
	menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);

	if( info[0] == '*' ) return ITEM_ENABLED;

	new CsTeams:upgrade = CsTeams:str_to_num(info);
	if( g_respawn_level[client][upgrade] == g_respawn_maxlevels[upgrade] )
	{
		return ITEM_DISABLED;
	}

	new xp = g_respawn_first_xp[upgrade] * (1 << g_respawn_level[client][upgrade]);
	if( g_xp[client] < xp || g_respawn_level[client][upgrade] == g_respawn_maxlevels[upgrade] )
	{
		return ITEM_DISABLED;
	}

	return ITEM_ENABLED;
}

ShowNoFallMenu(client)
{
	static title[128];
	formatex(title, sizeof(title) - 1, "[BetterPlay XP Mod]^nFall Damage Menu^n^nYour XP: \w%i", g_xp[client]);
	new menu = menu_create(title, "MenuNoFall");
	new callback = menu_makecallback("CallbackNoFall");

	menu_additem(menu, "\yHelp", "*", _, callback);

	static level, xp, percent, item[128], info[4];
	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		if( g_nofall_enabled[i] )
		{
			level = g_nofall_level[client][i] + 1;
			percent = g_nofall_max_chance[i] * level / g_nofall_maxlevels[i];

			if( g_nofall_level[client][i] < g_nofall_maxlevels[i] )
			{
				xp = g_nofall_first_xp[i] * (1 << (level - 1));
				formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i%%) \r[\w%i XP\r]", g_nofall_names[i], level, percent, xp);
			}
			else
			{
				formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i%%) \r[\wMaxed Out!\r]", g_nofall_names[i], level, percent);
			}

			num_to_str(_:i, info, sizeof(info) - 1);

			menu_additem(menu, item, info, _, callback);
		}
	}

	menu_display(client, menu);
}

public MenuNoFall(client, menu, item)
{
	if( item == MENU_EXIT )
	{
		menu_destroy(menu);
		ShowMainMenu(client);
		return;
	}

	static _access, info[4], callback;
	menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
	menu_destroy(menu);

	if( info[0] == '*' )
	{
		static motd[2500];
		new len = formatex(motd, sizeof(motd) - 1,	"<body style=^"background-color:#030303; color:#FF8F00^">");
		len += format(motd[len], sizeof(motd) - len - 1,	"<p align=^"center^">");
		len += format(motd[len], sizeof(motd) - len - 1,	"The Fall Damage ability reduces the amount of damage inflicted from falling.<br>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<br>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<table>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th></th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_nofall_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<th>%s</th>",g_team_names[i]);
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Reduction Intervals</th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_nofall_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i%%</td>", (g_nofall_max_chance[i] / g_nofall_maxlevels[i]));
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Max Level</th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_nofall_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i</td>", g_nofall_maxlevels[i]);
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Max Chance</th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_nofall_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i%%</td>", g_nofall_max_chance[i]);
			}
		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</table>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</p>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</body>");

		show_motd(client, motd, "XP Fall Damage Info");
	}
	else
	{
		new CsTeams:upgrade = CsTeams:str_to_num(info);

		new level = g_nofall_level[client][upgrade] + 1;
		new xp = g_nofall_first_xp[upgrade] * (1 << (level - 1));
		new percent = g_nofall_max_chance[upgrade] * level / g_nofall_maxlevels[upgrade];

		g_xp[client] -= xp;
		g_nofall_level[client][upgrade] = level;

		Save(client);

		BlindPlayer( client, 1.0, 1.0, 255, 255, 0, 120 );

		ColorChat(client, GREEN, "^4[BetterPlay] ^1You bought ^3%s ^1Level ^4%i (%i%%) ^1for ^3%i ^1XP!", g_nofall_names[upgrade], level, percent, xp);
	}

	ShowNoFallMenu(client);
}

public CallbackNoFall(client, menu, item)
{
	static _access, info[4], callback;
	menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);

	if( info[0] == '*' ) return ITEM_ENABLED;

	new CsTeams:upgrade = CsTeams:str_to_num(info);
	if( g_nofall_level[client][upgrade] == g_nofall_maxlevels[upgrade] )
	{
		return ITEM_DISABLED;
	}

	new xp = g_nofall_first_xp[upgrade] * (1 << g_nofall_level[client][upgrade]);
	if( g_xp[client] < xp || g_nofall_level[client][upgrade] == g_nofall_maxlevels[upgrade] )
	{
		return ITEM_DISABLED;
	}

	return ITEM_ENABLED;
}

ShowDamageMenu(client)
{
	static title[128];
	formatex(title, sizeof(title) - 1, "[BetterPlay XP Mod]^nIncrease Damage Menu^n^nYour XP: \w%i", g_xp[client]);
	new menu = menu_create(title, "InsuredMenu");
	new callback = menu_makecallback("Callbackdamage");

	static level, xp, percent, item[128], info[4];
	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		level = g_dmg_level[client][i] + 1;
		percent = g_dmg_max_chance[i] * level / g_dmg_maxlevels[i];

		if( g_dmg_level[client][i] < g_dmg_maxlevels[i] )
		{
			xp = g_dmg_first_xp[i] * (1 << (level - 1));
			formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i%%) \r[\w%i XP\r]", g_dmg_names[i], level, percent, xp);
		}
		else
		{
			formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i%%) \r[\wMaxed Out!\r]", g_dmg_names[i], level, percent);
		}

		num_to_str(_:i, info, sizeof(info) - 1);

		menu_additem(menu, item, info, _, callback);
	}

	menu_display(client, menu);
}

public InsuredMenu(client, menu, item)
{
	if( item == MENU_EXIT )
	{
		menu_destroy(menu);
		ShowMainMenu(client);
		return;
	}

	static _access, info[4], callback;
	menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
	menu_destroy(menu);

	if( info[0] == '*' )
	{
		static motd[2500];
		new len = formatex(motd, sizeof(motd) - 1,	"<body style=^"background-color:#030303; color:#FF8F00^">");
		len += format(motd[len], sizeof(motd) - len - 1,	"<p align=^"center^">");
		len += format(motd[len], sizeof(motd) - len - 1,	"The Respawn ability is chance to be respawned when you die.<br>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<br>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<table>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th></th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{

				len += format(motd[len], sizeof(motd) - len - 1,	"<th>%s</th>",g_team_names[i]);

		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Chance Intervals</th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{

				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i%%</td>", (g_respawn_max_chance[i] / g_respawn_maxlevels[i]));

		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Max Level</th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{

				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i</td>", g_respawn_maxlevels[i]);

		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"<th>Max Chance</th>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{

				len += format(motd[len], sizeof(motd) - len - 1,	"<td>%i%%</td>", g_respawn_max_chance[i]);

		}
		len += format(motd[len], sizeof(motd) - len - 1,	"</tr>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</table>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</p>");
		len += format(motd[len], sizeof(motd) - len - 1,	"</body>");

		show_motd(client, motd, "XP Respawn Info");
	}
	else
	{
		new CsTeams:upgrade = CsTeams:str_to_num(info);

		new level = g_dmg_level[client][upgrade] + 1;
		new xp = g_dmg_first_xp[upgrade] * (1 << (level - 1));
		new percent = g_dmg_max_chance[upgrade] * level / g_dmg_maxlevels[upgrade];

		g_xp[client] -= xp;
		g_dmg_level[client][upgrade] = level;

		Save(client);

		BlindPlayer( client, 1.0, 1.0, 255, 255, 0, 120 );

		ColorChat(client,GREEN, "^4[BetterPlay] ^1You bought ^3%s ^1Level ^4%i (%i%%) ^1for ^3%i ^1XP!", g_dmg_names[upgrade], level, percent, xp);
	}

	ShowDamageMenu(client);
}

public Callbackdamage(client, menu, item)
{
	static _access, info[4], callback;
	menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);

	if( info[0] == '*' ) return ITEM_ENABLED;

	new CsTeams:upgrade = CsTeams:str_to_num(info);
	if( g_dmg_level[client][upgrade] == g_dmg_maxlevels[upgrade] )
	{
		return ITEM_DISABLED;
	}

	new xp = g_dmg_first_xp[upgrade] * (1 << g_dmg_level[client][upgrade]);
	if( g_xp[client] < xp || g_dmg_level[client][upgrade] == g_dmg_maxlevels[upgrade] )
	{
		return ITEM_DISABLED;
	}

	return ITEM_ENABLED;
}

ShowRegenerationMenu(client)
{
	static title[128];
	formatex(title, sizeof(title) - 1, "[BetterPlay XP Mod]^nRegeneration Menu^n^nYour XP: \w%i", g_xp[client]);
	new menu = menu_create(title, "MenuRegeneration");
	new callback = menu_makecallback("CallbackRegeneration");

	menu_additem(menu, "\yHelp", "*", _, callback);

	static level, xp, amount, item[128], info[4];
	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		if( g_regeneration_enabled[i] )
		{
			level = g_regeneration_level[client][i] + 1;
			amount = g_regeneration_maxamount[i] * level / g_regeneration_maxlevels[i];

			if( g_regeneration_level[client][i] < g_regeneration_maxlevels[i] )
			{
				xp = g_regeneration_first_xp[i] * (1 << (level - 1));
				formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i HP) \r[\w%i XP\r]", g_regeneration_names[i], level, amount, xp);
			}
			else
			{
				formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i HP) \r[\wMaxed Out!\r]", g_regeneration_names[i], g_regeneration_level[client][i], g_regeneration_maxamount[i] * g_regeneration_level[client][i] / g_regeneration_maxlevels[i] );
			}

			num_to_str(_:i, info, sizeof(info) - 1);

			menu_additem(menu, item, info, _, callback);
		}
	}

	menu_display(client, menu);
}

public MenuRegeneration(client, menu, item)
{
	if( item == MENU_EXIT )
	{
		menu_destroy(menu);
		ShowMainMenu(client);
		return;
	}

	static _access, info[4], callback;
	menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
	menu_destroy(menu);

	if( info[0] == '*' )
	{
		ShowRegenerationMenu( client );
	}
	else
	{
		new CsTeams:upgrade = CsTeams:str_to_num(info);

		new level = g_regeneration_level[client][upgrade] + 1;
		new xp = g_regeneration_first_xp[upgrade] * (1 << (level - 1));
		new amount = g_regeneration_maxamount[upgrade] * level / g_regeneration_maxlevels[upgrade];

		g_xp[client] -= xp;
		g_regeneration_level[client][upgrade] = level;

		Save(client);

		BlindPlayer( client, 1.0, 1.0, 255, 255, 0, 120 );

		ColorChat(client, GREEN, "^4[BetterPlay] ^1You bought ^3%s ^1Level ^4%i ^4(%i HP) ^1for ^3%i ^1XP!", g_regeneration_names[upgrade], level, amount, xp);
	}

	ShowRegenerationMenu(client);
}

public CallbackRegeneration(client, menu, item)
{
	static _access, info[4], callback;
	menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);

	if( info[0] == '*' ) return ITEM_ENABLED;

	new CsTeams:upgrade = CsTeams:str_to_num(info);
	if( g_regeneration_level[client][upgrade] == g_regeneration_maxlevels[upgrade] )
	{
		return ITEM_DISABLED;
	}

	new xp = g_regeneration_first_xp[upgrade] * (1 << g_regeneration_level[client][upgrade]);
	if( g_xp[client] < xp )
	{
		return ITEM_DISABLED;
	}

	return ITEM_ENABLED;
}

ShowInvisibilityMenu(client)
{
	static title[128];
	formatex(title, sizeof(title) - 1, "[BetterPlay XP Mod]^nInvisibility Menu^n^nYour XP: \w%i", g_xp[client]);
	new menu = menu_create(title, "MenuInvisibility");
	new callback = menu_makecallback("CallbackInvisibility");

	menu_additem(menu, "\yHelp", "*", _, callback);

	static level, xp, item[128], info[4];
	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		if( g_invisibility_enabled[i] )
		{
			level = g_invisibility_level[client][i] + 1;

			if( g_invisibility_level[client][i] < g_invisibility_maxlevels[i] )
			{
				xp = g_invisibility_first_xp[i] * (1 << (level - 1));
				formatex(item, sizeof(item) - 1, "%s: \yLevel %i \r[\w%i XP\r]", g_invisibility_names[i], level, xp);
			}
			else
			{
				formatex(item, sizeof(item) - 1, "%s: \yLevel %i \r[\wMaxed Out!\r]", g_invisibility_names[i], g_invisibility_level[client][i] );
			}

			num_to_str(_:i, info, sizeof(info) - 1);

			menu_additem(menu, item, info, _, callback);
		}
	}

	menu_display(client, menu);
}

public MenuInvisibility(client, menu, item)
{
	if( item == MENU_EXIT )
	{
		menu_destroy(menu);
		ShowMainMenu(client);
		return;
	}

	static _access, info[4], callback;
	menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
	menu_destroy(menu);

	if( info[0] == '*' )
	{
		ShowInvisibilityMenu( client );
	}
	else
	{
		new CsTeams:upgrade = CsTeams:str_to_num(info);

		new level = g_invisibility_level[client][upgrade] + 1;
		new xp = g_invisibility_first_xp[upgrade] * (1 << (level - 1));

		g_xp[client] -= xp;
		g_invisibility_level[client][upgrade] = level;

		Save(client);

		BlindPlayer( client, 1.0, 1.0, 255, 255, 0, 120 );

		ColorChat(client, GREEN, "^4[BetterPlay] ^1You bought ^3%s ^1Level ^4%i ^1for ^3%i ^1XP!", g_invisibility_names[upgrade], level, xp);
	}

	ShowInvisibilityMenu(client);
}

public CallbackInvisibility(client, menu, item)
{
	static _access, info[4], callback;
	menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);

	if( info[0] == '*' ) return ITEM_ENABLED;

	new CsTeams:upgrade = CsTeams:str_to_num(info);
	if( g_invisibility_level[client][upgrade] == g_invisibility_maxlevels[upgrade] )
	{
		return ITEM_DISABLED;
	}

	new xp = g_invisibility_first_xp[upgrade] * (1 << g_invisibility_level[client][upgrade]);
	if( g_xp[client] < xp )
	{
		return ITEM_DISABLED;
	}

	return ITEM_ENABLED;
}

ShowPlayerMenu(client)
{
	new menu = menu_create("Player Info Menu", "MenuPlayer");

	new name[32], authid[35];
	for( new i = 1; i <= g_max_clients; i++ )
	{
		if( !is_user_connected(i) ) continue;

		get_user_name(i, name, sizeof(name) - 1);
		get_user_ip(i, authid, sizeof(authid) - 1);

		menu_additem(menu, name, authid);
	}

	menu_display(client, menu);
}

public MenuPlayer(client, menu, item)
{
	if( item == MENU_EXIT )
	{
		menu_destroy(menu);
		ShowMainMenu(client);
		return;
	}

	static _access, authid[35], callback;
	menu_item_getinfo(menu, item, _access, authid, sizeof(authid) - 1, _, _, callback);
	menu_destroy(menu);

	new player = find_player("d", authid);
	if( !is_user_connected(player) )
	{
		ShowMainMenu(client);
		return;
	}

	new name[32];
	get_user_name(player, name, sizeof(name) - 1);

	static motd[2500];
	new len = copy(motd, sizeof(motd) - 1, "<html>");
	len += format(motd[len], sizeof(motd) - len - 1, "<b><font size=^"4^">Name:</font></b> %s<br><br>", name);
	len += format(motd[len], sizeof(motd) - len - 1, "<b><font size=^"4^">XP:</font></b> %i<br><br>", g_xp[player]);
	if( g_any_nade_enabled )
	{
		len += format(motd[len], sizeof(motd) - len - 1, "<b><font size=^"4^">Grenades Levels:</font></b><br>");
		for( new i = 0; i < Grenades; i++ )
		{
			if( g_nade_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1, "<b>%s:</b> %i/%i<br>", g_nade_names[i], g_nade_level[player][i], g_nade_maxlevels[i]);
			}
		}
	}
	if( g_any_health_enabled )
	{
		len += format(motd[len], sizeof(motd) - len - 1, "<br><b><font size=^"4^">Health Levels:</font></b><br>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_health_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1, "<b>%s:</b> %i/%i (%i/%i HP)<br>",\
					g_health_names[i], g_health_level[player][i], g_health_maxlevels[i],\
					(g_health_maxamount[i] * g_health_level[player][i] / g_health_maxlevels[i]), g_health_maxamount[i]);
			}
		}
	}
	if( g_any_armor_enabled )
	{
		len += format(motd[len], sizeof(motd) - len - 1, "<br><b><font size=^"4^">Armor Levels:</font></b><br>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_armor_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1, "<b>%s:</b> %i/%i (%i/%i AP)<br>",\
					g_armor_names[i], g_armor_level[player][i], g_armor_maxlevels[i],\
					(g_armor_maxamount[i] * g_armor_level[player][i] / g_armor_maxlevels[i]), g_armor_maxamount[i]);
			}
		}
	}
	if( g_any_respawn_enabled )
	{
		len += format(motd[len], sizeof(motd) - len - 1, "<br><b><font size=^"4^">Respawn Levels:</font></b><br>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_respawn_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1, "<b>%s:</b> %i/%i (%i/%i %%)<br>",\
					g_respawn_names[i], g_respawn_level[player][i], g_respawn_maxlevels[i],\
					(g_respawn_max_chance[i] * g_respawn_level[player][i] / g_respawn_maxlevels[i]), g_respawn_max_chance[i]);
			}
		}
	}
	if( g_any_nofall_enabled )
	{
		len += format(motd[len], sizeof(motd) - len - 1, "<br><b><font size=^"4^">Fall Damage Levels:</font></b><br>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_nofall_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1, "<b>%s:</b> %i/%i (%i/%i %%)<br>",\
					g_nofall_names[i], g_nofall_level[player][i], g_nofall_maxlevels[i],\
					(g_nofall_max_chance[i] * g_nofall_level[player][i] / g_nofall_maxlevels[i]), g_nofall_max_chance[i]);
			}
		}
	}
	if( g_any_dmg_enabled )
	{
		len += format(motd[len], sizeof(motd) - len - 1, "<br><b><font size=^"4^">Increase Damage Levels:</font></b><br>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_dmg_enabled[ i ] )
			{
				len += format(motd[len], sizeof(motd) - len - 1, "<b>%s:</b> %i/%i (%i/%i %%)<br>",\
					g_dmg_names[i], g_dmg_level[player][i], g_dmg_maxlevels[i],\
					(g_dmg_max_chance[i] * g_respawn_level[player][i] / g_dmg_maxlevels[i]), g_dmg_max_chance[i]);
			}
		}
	}
	if( g_any_regeneration_enabled )
	{
		len += format(motd[len], sizeof(motd) - len - 1, "<br><b><font size=^"4^">Regeneration Levels:</font></b><br>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_regeneration_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1, "<b>%s:</b> %i/%i (%i/%i HP)<br>",\
					g_regeneration_names[i], g_regeneration_level[player][i], g_regeneration_maxlevels[i],\
					(g_regeneration_maxamount[i] * g_regeneration_level[player][i] / g_regeneration_maxlevels[i]), g_regeneration_maxamount[i]);
			}
		}
	}
	if( g_any_invisibility_enabled )
	{
		len += format(motd[len], sizeof(motd) - len - 1, "<br><b><font size=^"4^">Invisibility Levels:</font></b><br>");
		for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
		{
			if( g_invisibility_enabled[i] )
			{
				len += format(motd[len], sizeof(motd) - len - 1, "<b>%s:</b> %i/%i<br>", g_invisibility_names[i], g_invisibility_level[player][i], g_invisibility_maxlevels[i] );
			}
		}
	}

	len += format(motd[len], sizeof(motd) - len - 1, "</html>");

	show_motd(client, motd, "BetterPlay XP Mod Info");

	ShowPlayerMenu(client);
}

public cmdGiveFunction( client )
{
	if( !( get_user_flags( client ) & ADMIN_RCON ) ) return PLUGIN_HANDLED;

	new arg[ 32 ];
	read_argv( 1, arg, charsmax( arg ) );

	if( !is_str_num( arg ) )
	{
		ColorChat( client, GREEN, "[BetterPlay]^1 Invalid input,^3 please try^4 again^1." );
		client_cmd( client, "messagemode give_xp" );

		return PLUGIN_HANDLED;
	}

	client_cmd( client, "hnsxp_give_xp ^"%s^" %d", cacheUserName, str_to_num( arg ) );
	return PLUGIN_HANDLED;
}

public cmdGiveAllFunction( client )
{
	if( !( get_user_flags( client ) & ADMIN_RCON ) ) return PLUGIN_HANDLED;

	new arg[ 32 ];
	read_argv( 1, arg, charsmax( arg ) );

	if( !is_str_num( arg ) )
	{
		ColorChat( client, GREEN, "[BetterPlay]^1 Invalid input,^3 please try^4 again^1." );
		client_cmd( client, "messagemode give_xp_all" );

		return PLUGIN_HANDLED;
	}

	client_cmd( client, "hnsxp_giveall %d", str_to_num( arg ) );
	return PLUGIN_HANDLED;
}

public cmdRemoveFunction( client )
{
	if( !( get_user_flags( client ) & ADMIN_RCON ) ) return PLUGIN_HANDLED;

	new arg[ 32 ];
	read_argv( 1, arg, charsmax( arg ) );

	if( !is_str_num( arg ) )
	{
		ColorChat( client, GREEN, "[BetterPlay]^1 Invalid input,^3 please try^4 again^1." );
		client_cmd( client, "messagemode remove" );

		return PLUGIN_HANDLED;
	}

	client_cmd( client, "hnsxp_remove_xp ^"%s^" %d", cacheUserName, str_to_num( arg ) );
	return PLUGIN_HANDLED;
}

BlindPlayer( index, Float:fDuration, Float:fHoldTime, cRed, cGreen, cBlue, cAlpha )
{
	message_begin( MSG_ONE_UNRELIABLE, get_user_msgid( "ScreenFade" ), { 0, 0, 0 }, index );

	write_short( floatround( 4096.0 * fDuration, floatround_round ) );
	write_short( floatround( 4096.0 * fHoldTime, floatround_round ) );
	write_short( 4096 );

	write_byte( cRed );
	write_byte( cGreen );
	write_byte( cBlue );
	write_byte( cAlpha );

	message_end( );
}

public taskLoadConfigurationFile( )
{
	new file[ 124 ], dir[ 124 ];
	get_configsdir( dir, charsmax( dir ) );
	formatex( file, charsmax( file ), "%s/%s.cfg", dir, cfgfile_name );

	if( file_exists( file ) )
	{
		server_cmd( "exec %s", file );
		server_exec( );
	}
	else
	{
		CreateCFGFile( file );
		log_amx( "%s.cfg is not found in configs folder. File is created...", cfgfile_name );
	}
}

CreateCFGFile( const file[ ] )
{
	new i = fopen( file, "wt" );

	fprintf( i, "// HidenSeek XP Mod v%s^n", VERSION );
	fprintf( i, "// Original plugin by: Exolent^n" );
	fprintf( i, "// Edit by: Smiley^n^n" );

	fprintf( i, "// Default Cvars^n" );
	fprintf( i, "hnsxp_xp_kill %i^n", get_pcvar_num( cvar_xp_kill ) );
	fprintf( i, "hnsxp_xp_headshot %i^n", get_pcvar_num( cvar_xp_headshot ) );
	fprintf( i, "hnsxp_xp_grenade %i^n", get_pcvar_num( cvar_xp_grenade ) );
	fprintf( i, "hnsxp_xp_suicide %i^n", get_pcvar_num( cvar_xp_suicide ) );
	fprintf( i, "hnsxp_xp_survive %i^n", get_pcvar_num( cvar_xp_survive ) );
	fprintf( i, "hnsxp_xp_win %i^n", get_pcvar_num( cvar_xp_win ) );
	fprintf( i, "hnsxp_xp_spawn_nade_delay %i^n^n", get_pcvar_num( cvar_spawn_nade_delay ) );

	/*fprintf( i, "// HNSXP Happy Hour^n" );
	fprintf( i, "hnsxp_hh_start %i^n", get_pcvar_num( hh_start ) );
	fprintf( i, "hnsxp_hh_end %i", get_pcvar_num( hh_end ) );*/

	fclose( i );
}

IsUserAuthorized(client)
{
	return g_authid[client][0] != 0;
}

Load(client)
{
	#if defined USING_SQL
	static query[128];
	formatex(query, sizeof(query) - 1, "SELECT `data` FROM `hns_xp` WHERE `authid` = '%s';", g_authid[client]);

	static data[2];
	data[0] = client;

	SQL_ThreadQuery(g_sql_tuple, "QueryLoadData", query, data, sizeof(data));
	#else
	static data[512], timestamp;
	if( nvault_lookup(g_vault, g_authid[client], data, sizeof(data) - 1, timestamp) )
	{
		ParseLoadData(client, data);
		return;
	}
	else
	{
		NewUser(client);
	}
	#endif
}

#if defined USING_SQL
public QueryLoadData(failstate, Handle:query, error[], errnum, data[], size, Float:queuetime)
{
	if( failstate == TQUERY_CONNECT_FAILED
	|| failstate == TQUERY_QUERY_FAILED )
	{
		set_fail_state(error);
	}
	else
	{
		if( SQL_NumResults(query) )
		{
			static sqldata[256];
			SQL_ReadResult(query, 0, sqldata, sizeof(sqldata) - 1);
			ParseLoadData(data[0], sqldata);
		}
		else
		{
			NewUser(data[0]);
		}
	}
}
#endif

ParseLoadData(client, data[512])
{
	static num[512];
	strbreak(data, num, sizeof(num) - 1, data, sizeof(data) - 1);

	g_xp[client] = str_to_num(num);

	for( new i = 0; i < Grenades; i++ )
	{
		strbreak(data, num, sizeof(num) - 1, data, sizeof(data) - 1);
		g_nade_level[client][i] = clamp(str_to_num(num), 0, g_nade_maxlevels[i]);
	}

	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		strbreak(data, num, sizeof(num) - 1, data, sizeof(data) - 1);
		g_armor_level[client][i] = clamp(str_to_num(num), 0, g_armor_maxlevels[i]);
	}

	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		strbreak(data, num, sizeof(num) - 1, data, sizeof(data) - 1);
		g_respawn_level[client][i] = clamp(str_to_num(num), 0, g_respawn_maxlevels[i]);
	}

	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		strbreak(data, num, sizeof(num) - 1, data, sizeof(data) - 1);
		g_health_level[client][i] = clamp(str_to_num(num), 0, g_health_maxlevels[i]);
	}

	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		strbreak(data, num, sizeof(num) - 1, data, sizeof(data) - 1);
		g_nofall_level[client][i] = clamp(str_to_num(num), 0, g_nofall_maxlevels[i]);
	}

	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		strbreak(data, num, sizeof(num) - 1, data, sizeof(data) - 1);
		g_dmg_level[client][i] = clamp(str_to_num(num), 0, g_dmg_maxlevels[i]);
	}

	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		strbreak(data, num, sizeof(num) - 1, data, sizeof(data) - 1);
		g_regeneration_level[client][i] = clamp(str_to_num(num), 0, g_regeneration_maxlevels[i]);
	}

	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		strbreak(data, num, sizeof(num) - 1, data, sizeof(data) - 1);
		g_invisibility_level[client][i] = clamp(str_to_num(num), 0, g_invisibility_maxlevels[i]);
	}

	#if defined USING_SQL
	g_loaded_data[client] = 1;
	#endif
}

NewUser(client)
{
	g_first_time[client] = 1;

	g_xp[client] = ENTRY_XP;
	arrayset(g_nade_level[client], 0, sizeof(g_nade_level[]));
	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		g_armor_level[client][i] = 0;
		g_respawn_level[client][i] = 0;
		g_health_level[client][i] = 0;
		g_nofall_level[client][i] = 0;
		g_dmg_level[client][i] = 0;
		g_regeneration_level[ client ][ i ] = 0;
		g_invisibility_level[ client ][ i ] = 0;
	}
}

Save(client)
{
	if( !IsUserAuthorized(client) ) return;

	static data[512];
	new len = formatex(data, sizeof(data) - 1, "%i", g_xp[client]);

	for( new i = 0; i < Grenades; i++ )
	{
		len += formatex(data[len], sizeof(data) - len - 1, " %i", g_nade_level[client][i]);
	}

	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		len += formatex(data[len], sizeof(data) - len - 1, " %i", g_armor_level[client][i]);
	}

	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		len += formatex(data[len], sizeof(data) - len - 1, " %i", g_respawn_level[client][i]);
	}

	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		len += formatex(data[len], sizeof(data) - len - 1, " %i", g_health_level[client][i]);
	}

	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		len += formatex(data[len], sizeof(data) - len - 1, " %i", g_nofall_level[client][i]);
	}

	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		len += formatex(data[len], sizeof(data) - len - 1, " %i", g_dmg_level[client][i]);
	}

	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		len += formatex(data[len], sizeof(data) - len - 1, " %i", g_regeneration_level[client][i]);
	}

	for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
	{
		len += formatex(data[len], sizeof(data) - len - 1, " %i", g_invisibility_level[client][i]);
	}

	#if defined USING_SQL
	static name[32];
	get_user_name(client, name, sizeof(name) - 1);

	static query[512];
	if( g_loaded_data[client] )
	{
		formatex(query, sizeof(query) - 1, "UPDATE `hns_xp` SET `name` = '%s', `data` = '%s' WHERE `authid` = '%s';", name, data, g_authid[client]);
	}
	else
	{
		formatex(query, sizeof(query) - 1, "INSERT INTO `hns_xp` ( `name`, `authid`, `data` ) VALUES ( '%s', '%s', '%s' );", name, g_authid[client], data);
	}

	SQL_ThreadQuery(g_sql_tuple, "QuerySaveData", query);
	#else
	nvault_set(g_vault, g_authid[client], data);
	#endif
}

#if defined USING_SQL
public QuerySaveData(failstate, Handle:query, error[], errnum, data[], size, Float:queuetime)
{
	if( failstate == TQUERY_CONNECT_FAILED
	|| failstate == TQUERY_QUERY_FAILED )
	{
		set_fail_state(error);
	}
}
#endif
/* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
*{\\ rtf1\\ ansi\\ deff0{\\ fonttbl{\\ f0\\ fnil Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ lang1026\\ f0\\ fs16 \n\\ par }
*/