#include <amxmodx>
#include <amxmisc>
#include <cstrike>
#include <fakemeta>
#include <fakemeta_util>
#include <engine>
#include <fun>
#include <nvault>
#include <sqlx>

#pragma semicolon 1

#define PLUGIN_NAME		"Naruto Mod"
#define PLUGIN_VERSION		"1.0"
#define PLUGIN_AUTHOR		"ds811888"
#define PLUGIN_TAG		"[Naruto Mod]:"
#define PLUGIN_VAULT		"Naruto"

// Defines
#define MAXPLAYERS	32

#define KEYS (1<<0)|(1<<1)|(1<<2)|(1<<3)|(1<<4)|(1<<5)|(1<<6)|(1<<7)|(1<<8)|(1<<9)

#define TEAM_SPEC			0
#define TEAM_T				1
#define TEAM_CT				2

#define CS_ARMOR_NONE			0
#define CS_ARMOR_KEVLAR 		1
#define CS_ARMOR_VESTHELM 		2

#define GENERIC				0
#define BURN				8
#define FREEZE				16
#define SHOCK				256
#define ENERGYBEAM			1024

#define DEFAULT_MAX_HEALTH		100
#define DEFAULT_MAX_ARMOUR		100

//---------------------------------------------------------------------

#define SAVE_NONE			0
#define SAVE_VAULT			1
#define SAVE_DB				2

#define NARUTO_SQL_HOST			"localhost"
#define NARUTO_SQL_USER			"root"
#define NARUTO_SQL_PASSWORD 		"password"
#define NARUTO_SQL_DATABASE 		"Naruto"
#define NARUTO_SQL_TYPE	 		"0"
#define NARUTO_SQL_TABLE	 	"players"

#define DB_MYSQL			0
#define DB_SQLITE			1

#define SQLITE_SYNC_OFF			0
#define SQLITE_SYNC_NORMAL		1
#define SQLITE_SYNC_FULL		2

//---------------------------------------------------------------------

#define CLASS_NONE			0
#define CLASS_DEATHGOD			1
#define CLASS_HOLLOW 			2

#define NARUTO_ADMIN_FLAG 		ADMIN_CVAR

#define NARUTO_HUD_PLAYER		3
#define NARUTO_HUD_STATUS		4

#define NARUTO_MAX_CLASSES 		3
#define NARUTO_MAX_LEVELS 		10
#define NARUTO_MAX_ITEMS 		3

#define NARUTO_START_SPIRIT_POWER	30
#define NARUTO_MAXIMUM_SPIRIT_POWER	250

#define NARUTO_START_LEVEL 		1
#define NARUTO_START_SKILLPOINTS 	3
#define NARUTO_START_ATTRIBUTEPOINTS 	5
#define NARUTO_AP_PER_LEVEL 		5
#define NARUTO_SP_PER_LEVEL 		3
#define NARUTO_SPR_PER_LEVEL		130

#define NARUTO_RESKILL_COST		1600

//---------------------------------------------------------------------

#define NARUTO_MAX_SOUNDS		4

#define NARUTO_SOUND_LEVELUP		0
#define NARUTO_SOUND_WLIGHT		1
#define NARUTO_SOUND_IRING		2
#define NARUTO_SOUND_CERO		3

//---------------------------------------------------------------------

#define NARUTO_XP_MIN_PLAYERS		"2"
#define NARUTO_XP_SHARE_RADIUS		"750"

#define NARUTO_XP_SUICIDE 		"9"
#define NARUTO_XP_KILL 			"8"
#define NARUTO_XP_TEAMKILL 		"18"
#define NARUTO_XP_ASSIST 		"3"
#define NARUTO_XP_HEADSHOT 		"4"
#define NARUTO_XP_SKILL			"2"
#define NARUTO_XP_NEGATION 		"1"
#define NARUTO_XP_PLANT 		"10"
#define NARUTO_XP_DEFUSE 		"20"
#define NARUTO_XP_EXPLODE 		"10"
#define NARUTO_XP_ROUND 		"6"

#define NARUTO_XP_BOMBER 		"10"
#define NARUTO_XP_PLANTER 		"5"
#define NARUTO_XP_DEFUSER 		"2"

#define NARUTO_XP_LONG_TERM		"1.0"
#define NARUTO_XP_SHORT_TERM		"5.0"

//---------------------------------------------------------------------

#define NARUTO_TASK_SPIRITRELEASE	0
#define NARUTO_TASK_SPIRIT		32
#define NARUTO_TASK_CERO		64
#define NARUTO_TASK_BLOSSOMS		96
#define NARUTO_TASK_STING		128
#define NARUTO_TASK_VBURNING		160
#define NARUTO_TASK_IRING		192

#define NARUTO_TASK_BUYTIME		224

#define NARUTO_TASK_GIGAI		256
#define NARUTO_TASK_INJECTION		288

//---------------------------------------------------------------------

#define NARUTO_MAX_SKILLS		6

#define P_SKILL_1			0
#define P_SKILL_2			1
#define P_SKILL_3			2
#define P_SKILL_4			3
#define P_SKILL_5			4
#define P_SKILL_6			5
#define P_SKILL_7			6

//---------------------------------------------------------------------

#define NARUTO_ITEM_1_COST		6655
#define NARUTO_ITEM_2_COST		3350
#define NARUTO_ITEM_3_COST		2120

//---------------------------------------------------------------------

#define NARUTO_SKILL_NEGATION_HEALTH		40
#define NARUTO_SKILL_NEGATION_TIME		1.2
#define NARUTO_SKILL_CERO_CHARGE_TIME		2.0
#define NARUTO_SKILL_CERO_DISCHARGE_TIME	5.5

//---------------------------------------------------------------------

#define NARUTO_SKILL_NOVICE_REQ_LEVEL	1
#define NARUTO_SKILL_NORMAL_REQ_LEVEL	3
#define NARUTO_SKILL_GREATER_REQ_LEVEL	5
#define NARUTO_SKILL_MASTER_REQ_LEVEL	7

#define NARUTO_SKILL_NOVICE_MAXLEVEL	5
#define NARUTO_SKILL_NORMAL_MAXLEVEL	10
#define NARUTO_SKILL_GREATER_MAXLEVEL	15
#define NARUTO_SKILL_MASTER_MAXLEVEL	20

#define NARUTO_SKILL_NOVICE_DAMAGE	10.0
#define NARUTO_SKILL_NORMAL_DAMAGE	15.0
#define NARUTO_SKILL_GREATER_DAMAGE	30.0
#define NARUTO_SKILL_MASTER_DAMAGE	75.0

#define NARUTO_SKILL_NOVICE_CD		15.0
#define NARUTO_SKILL_NORMAL_CD		20.0
#define NARUTO_SKILL_GREATER_CD		25.0
#define NARUTO_SKILL_MASTER_CD		30.0

#define	NARUTO_SKILL_NOVICE_COST	10
#define NARUTO_SKILL_NORMAL_COST	20
#define NARUTO_SKILL_GREATER_COST	75
#define NARUTO_SKILL_MASTER_COST	250

#define	NARUTO_SKILL_NOVICE_FROSTED	150.0
#define NARUTO_SKILL_NORMAL_FROSTED	120.0
#define NARUTO_SKILL_GREATER_FROSTED	80.0
#define NARUTO_SKILL_MASTER_FROSTED	50.0

#define	NARUTO_SKILL_NOVICE_FR_TIME	2.0
#define NARUTO_SKILL_NORMAL_FR_TIME	4.0
#define NARUTO_SKILL_GREATER_FR_TIME	6.0
#define NARUTO_SKILL_MASTER_FR_TIME	8.0

#define	NARUTO_SKILL_NOVICE_STUNNED	0.2
#define NARUTO_SKILL_NORMAL_STUNNED	0.5
#define NARUTO_SKILL_GREATER_STUNNED	0.8
#define NARUTO_SKILL_MASTER_STUNNED	1.2

#define NARUTO_SKILL_NOVICE_CHANCE	16
#define NARUTO_SKILL_NORMAL_CHANCE	7
#define NARUTO_SKILL_GREATER_CHANCE	4
#define NARUTO_SKILL_MASTER_CHANCE	2

// End Defines


// News

new amxx_config_dir[64],amxx_base_dir[64],amxx_data_dir[64];
new g_msg_screen_fade,g_sprite_lightning,g_msg_death_msg,g_msg_bartime;
new g_sprite_beam,g_sprite_smoke,g_msg_screen_shake,g_sprite_explosion;
new g_msg_status_icon,g_sprite_shockwave,g_sprite_streak,g_sprite_pflare;
new g_sprite_burning,g_sprite_gwave;

//---------------------------------------------------------------------

new nt_gamename;

new g_player_class[MAXPLAYERS+1]=0;
new g_player_experience[MAXPLAYERS+1]=0;
new g_player_level[MAXPLAYERS+1]=NARUTO_START_LEVEL;
new g_player_skillpoints[MAXPLAYERS+1]=NARUTO_START_SKILLPOINTS;
new g_player_attributepoints[MAXPLAYERS+1]=NARUTO_START_ATTRIBUTEPOINTS;
new g_player_spirit[MAXPLAYERS+1]=NARUTO_START_SPIRIT_POWER;
new g_player_max_health[MAXPLAYERS+1];
new g_player_max_armour[MAXPLAYERS+1];
new g_player_max_spirit[MAXPLAYERS+1]=NARUTO_MAXIMUM_SPIRIT_POWER;
new g_player_next_level[NARUTO_MAX_LEVELS+1]={0,200,400,800,1600,3200,6400,12800,25600,51200,9999999};
new g_player_current_skill[MAXPLAYERS+1]=0;
new g_player_volcanic_flame[MAXPLAYERS+1]=0;
new g_player_frosted[MAXPLAYERS+1]=0;
new g_player_stunned[MAXPLAYERS+1]=0;
new g_player_death_stinged[MAXPLAYERS+1]=0;
new g_player_statusicon[MAXPLAYERS+1][64];
new g_player_damage_dealt[MAXPLAYERS+1][MAXPLAYERS+1];
new g_player_endurance[MAXPLAYERS+1]=0;
new g_player_item[MAXPLAYERS+1]=0;

new g_player_planter;
new g_player_defuser;
new g_player_bomber;

new g_sql_string[256];
new g_sql_table[64];
new g_sql_error[256];

//---------------------------------------------------------------------

new Handle:g_sql_tuple;
new Handle:g_sql_connect;
new Handle:g_sql_query;

//---------------------------------------------------------------------

new g_skill[MAXPLAYERS+1][64];
new g_sound[MAXPLAYERS+1][64];

//---------------------------------------------------------------------

new Float:g_player_last_event[MAXPLAYERS+1][64];
new Float:g_player_athletic[MAXPLAYERS+1]=0.0;
new Float:g_player_acrobatic[MAXPLAYERS+1]=1.0;

//---------------------------------------------------------------------

new Float:g_item_color_red[4]={
				0.0, //None
				255.0,  //Gigai
				0.0, //Injection
				0.0}; //Mantle

new Float:g_item_color_green[4]={
				0.0, //None
				0.0, //Gigai
				255.0, //Injection
				0.0}; //Mantle

new Float:g_item_color_blue[4]={
				0.0, //None
				0.0, //Gigai
				0.0, //Injection
				255.0}; //Mantle

//---------------------------------------------------------------------

new const g_naruto_classes[NARUTO_MAX_CLASSES][]={"None","Ming","Hollow"};
new const g_item_names[NARUTO_MAX_ITEMS+1][]={"None","Gigai","Injection","Brown Mantle"};

//---------------------------------------------------------------------

//Death God skill names
new const g_dg_skill_names[NARUTO_MAX_SKILLS][]={
						"White Lightning",
						"Shine Brightly (passive)",
						"Ice Ring",
						"Restrain (passive)",
						"Cherry Blossoms",
						"Death Sting (passive)"};
//Posetive Death God client commands
new const g_dg_skill_p_cmds[NARUTO_MAX_SKILLS][]={
						"bm_wlight",
						"",
						"bm_icering",
						"",
						"bm_cherry",
						""};
//Negative Death God client commands
new const g_dg_skill_n_cmds[NARUTO_MAX_SKILLS][]={
						"",
						"",
						"",
						"",
						"",
						""};
//Hollow skill names				
new const g_hw_skill_names[NARUTO_MAX_SKILLS][]={
						"Devour Soul (passive)",
						"Hollow Bullet",
						"Negation (passive)",
						"Cero",
						"Steel Skin (passive)",
						"Volcanic Flame"};
//Posetive Hollow client commands
new const g_hw_skill_p_cmds[NARUTO_MAX_SKILLS][]={
						"",
						"bm_hbullet",
						"",
						"+bm_cero",
						"",
						"bm_flame"};
//Negative Hollow client commands
new const g_hw_skill_n_cmds[NARUTO_MAX_SKILLS][]={
						"",
						"",
						"",
						"-bm_cero",
						"",
						""};
		
//---------------------------------------------------------------------

new const html_header[] = "<html><head><link href='naruto.css' rel='stylesheet' type='text/css' /></head><body>";
new const html_footer[] = "</body></html>";

//---------------------------------------------------------------------

new bool:g_player_first_spawn[MAXPLAYERS+1]=true;
new bool:g_restart_attempt[MAXPLAYERS+1];
new bool:g_player_negation_used[MAXPLAYERS+1];
new bool:g_player_negating[MAXPLAYERS+1];
new bool:g_player_spirit_releasing[MAXPLAYERS+1];
new bool:g_player_cero_charged[MAXPLAYERS+1];
new bool:g_player_class_selected[MAXPLAYERS+1];
new bool:g_player_skill_reseted[MAXPLAYERS+1];
new bool:g_player_character_reseted[MAXPLAYERS+1];
new bool:g_player_in_skill[MAXPLAYERS+1];
new bool:g_player_zoomed[MAXPLAYERS+1];
new bool:g_player_frozen[MAXPLAYERS+1];
new bool:g_player_burning[MAXPLAYERS+1];
new bool:g_player_died_by_skill[MAXPLAYERS+1];
new bool:g_player_use[MAXPLAYERS+1];
new bool:g_player_item_in_use[MAXPLAYERS+1];

new bool:g_event_freeze_time;
new bool:g_event_buy_time;
new bool:g_event_round_end;
new bool:g_event_planted;

new bool:g_database_initialized;
new bool:g_sql_available;

//---------------------------------------------------------------------

new cvar_sql_host;
new cvar_sql_user;
new cvar_sql_password;
new cvar_sql_database;
new cvar_sql_type;
new cvar_sql_table;

new cvar_naruto;
new cvar_savexp;
new cvar_xp_suicide;
new cvar_xp_kill;
new cvar_xp_teamkill;
new cvar_xp_assist;
new cvar_xp_headshot;
new cvar_xp_skill;
new cvar_xp_negation;
new cvar_xp_plant;
new cvar_xp_explode;
new cvar_xp_defuse;
new cvar_xp_round;
new cvar_xp_bomber;
new cvar_xp_planter;
new cvar_xp_defuser;
new cvar_xp_long_term;
new cvar_xp_short_term;
new cvar_xp_minplayers;
new cvar_xp_share_radius;

//---------------------------------------------------------------------

new Float:g_cs_speed_vip = 227.0;

new Float:g_cs_weapon_speed[31] =
{
	0.0,
	250.0,      // CSW_P228
	0.0,
	260.0,      // CSW_SCOUT
	250.0,      // CSW_HEGRENADE
	240.0,      // CSW_XM1014
	250.0,      // CSW_C4
	250.0,      // CSW_MAC10
	240.0,      // CSW_AUG
	250.0,      // CSW_SMOKEGRENADE
	250.0,      // CSW_ELITE
	250.0,      // CSW_FIVESEVEN
	250.0,      // CSW_UMP45
	210.0,      // CSW_SG550
	240.0,      // CSW_GALI
	240.0,      // CSW_FAMAS
	250.0,      // CSW_USP
	250.0,      // CSW_GLOCK18
	210.0,      // CSW_AWP
	250.0,      // CSW_MP5NAVY
	220.0,      // CSW_M249
	230.0,      // CSW_M3
	230.0,      // CSW_M4A1
	250.0,      // CSW_TMP
	210.0,      // CSW_G3SG1
	250.0,      // CSW_FLASHBANG
	250.0,      // CSW_DEAGLE
	235.0,      // CSW_SG552
	221.0,      // CSW_AK47
	250.0,      // CSW_KNIFE
	245.0       // CSW_P90
};

new Float:g_cs_weapon_speed_zoom[31] =
{
	0.0,
	0.0,
	0.0,
	220.0,      // CSW_SCOUT
	0.0,
	0.0,
	0.0,
	0.0,
	240.0,      // CSW_AUG
	0.0,
	0.0,
	0.0,
	0.0,
	150.0,      // CSW_SG550
	0.0,
	0.0,
	0.0,
	0.0,
	150.0,      // CSW_AWP
	0.0,
	0.0,
	0.0,
	0.0,
	0.0,
	150.0,      // CSW_G3SG1
	0.0,
	0.0,
	235.0,      // CSW_SG552
	0.0,
	0.0,
	0.0
};

// End News


// plugins

public plugin_modules()
{
	require_module("cstrike");
	require_module("fun");
	require_module("fakemeta");
	require_module("engine");
	require_module("nvault");
	require_module("mysql");
	require_module("sqlite");
}

public plugin_init()
{
	//plugin
	register_plugin(PLUGIN_NAME,PLUGIN_VERSION,PLUGIN_AUTHOR);
	
	//dictionary's
	register_dictionary("naruto.txt");
	
	//cvar's
	cvar_naruto=register_cvar("sv_naruto","1");
	cvar_savexp=register_cvar("sv_savexp","0");

	nt_gamename = register_cvar( "nt_gamename", "Naruto Mod v1.0" ); 
	register_forward( FM_GetGameDescription, "GameDesc" ); 
	
	cvar_sql_host=register_cvar("bm_sql_host",NARUTO_SQL_HOST);
	cvar_sql_user=register_cvar("bm_sql_user",NARUTO_SQL_USER);
	cvar_sql_password=register_cvar("bm_sql_password",NARUTO_SQL_PASSWORD);
	cvar_sql_database=register_cvar("bm_sql_database",NARUTO_SQL_DATABASE);
	cvar_sql_type=register_cvar("bm_sql_type",NARUTO_SQL_TYPE);
	cvar_sql_table=register_cvar("bm_sql_table",NARUTO_SQL_TABLE);
	
	cvar_xp_minplayers=register_cvar("bm_xp_minplayers",NARUTO_XP_MIN_PLAYERS);
	cvar_xp_share_radius=register_cvar("bm_xp_share",NARUTO_XP_SHARE_RADIUS);
	
	cvar_xp_suicide=register_cvar("bm_xp_suicide",NARUTO_XP_SUICIDE);
	cvar_xp_kill=register_cvar("bm_xp_kill",NARUTO_XP_KILL);
	cvar_xp_teamkill=register_cvar("bm_xp_teamkill",NARUTO_XP_TEAMKILL);
	cvar_xp_assist=register_cvar("bm_xp_assist",NARUTO_XP_ASSIST);
	cvar_xp_headshot=register_cvar("bm_xp_headshot",NARUTO_XP_HEADSHOT);
	cvar_xp_skill=register_cvar("bm_xp_skill",NARUTO_XP_SKILL);
	cvar_xp_negation=register_cvar("bm_xp_negation",NARUTO_XP_NEGATION);
	cvar_xp_plant=register_cvar("bm_xp_plant",NARUTO_XP_PLANT);
	cvar_xp_explode=register_cvar("bm_xp_explode",NARUTO_XP_DEFUSE);
	cvar_xp_defuse=register_cvar("bm_xp_defuse",NARUTO_XP_EXPLODE);
	cvar_xp_round=register_cvar("bm_xp_round",NARUTO_XP_ROUND);
	
	cvar_xp_bomber=register_cvar("bm_xp_bomber",NARUTO_XP_BOMBER);
	cvar_xp_planter=register_cvar("bm_xp_planter",NARUTO_XP_PLANTER);
	cvar_xp_defuser=register_cvar("bm_xp_defuser",NARUTO_XP_DEFUSER);

	cvar_xp_long_term=register_cvar("bm_xp_long_term",NARUTO_XP_LONG_TERM);
	cvar_xp_short_term=register_cvar("bm_xp_short_term",NARUTO_XP_SHORT_TERM);
	
	//clcmd's
	cvar_clcmd_init();
	
	//concmd's
	cvar_concmd_init();
	
	//srvcmd's
	cvar_srvcmd_init();
	
	//menu's
	register_menucmd(register_menuid("menu_main"),KEYS,"menu_handler_main");
	register_menucmd(register_menuid("menu_next"),KEYS,"menu_handler_next");
	
	register_menucmd(register_menuid("menu_info"),KEYS,"menu_handler_information");
	register_menucmd(register_menuid("menu_classes"),KEYS,"menu_handler_classes");
	register_menucmd(register_menuid("menu_attributes"),KEYS,"menu_handler_attributes");
	register_menucmd(register_menuid("menu_skills"),KEYS,"menu_handler_skills");
	register_menucmd(register_menuid("menu_items"),KEYS,"menu_handler_items");
	
	//forward's
	register_forward(FM_CmdStart,"fm_cmd_start");
		
	//event's
	register_event("ResetHUD","event_hud_reset","be");
	register_event("TextMsg","event_restart_attempt","a","2=#Game_will_restart_in");
	register_event("BarTime","event_bartime","be");
	register_event("SetFOV","event_zoom","be");
	register_event("CurWeapon","event_current_weapon","be","1=1");
	register_event("ItemPickup","event_item_pickup","be");
	
	//logevent's
	register_logevent("logevent_game",2,"0=World triggered");
	register_logevent("logevent_player",3,"1=triggered");
	register_logevent("logevent_objective_team",6,"2=triggered");
	
	//touch's
	register_touch("item_drop","player","item_drop_touch");
	register_touch("npc_gigai","player","item_gigai_touch");
	
	//user message's
	g_msg_screen_fade=get_user_msgid("ScreenFade");
	g_msg_death_msg=get_user_msgid("DeathMsg");
	g_msg_screen_shake=get_user_msgid("ScreenShake");
	g_msg_bartime=get_user_msgid("BarTime");
	g_msg_status_icon=get_user_msgid("StatusIcon");
	
	//misc
	get_configsdir(amxx_config_dir,63);
	get_basedir(amxx_base_dir,63);
	get_datadir(amxx_data_dir,63);
}

public plugin_precache()
{
	precache_generic("naruto.css");
	
	g_sprite_lightning=precache_model("sprites/lgtning.spr");
	g_sprite_beam=precache_model("sprites/laserbeam.spr");
	g_sprite_burning=precache_model("sprites/xfire.spr");
	g_sprite_smoke=precache_model("sprites/steam1.spr");
	g_sprite_explosion=precache_model("sprites/explode1.spr");
	g_sprite_shockwave=precache_model("sprites/shockwave.spr");
	g_sprite_streak=precache_model("sprites/streak.spr");
	g_sprite_pflare=precache_model("sprites/naruto/pflare.spr");
	g_sprite_gwave=precache_model("sprites/gwave1.spr");
	
	copy(g_sound[NARUTO_SOUND_LEVELUP],63,"naruto/levelup.wav");
	copy(g_sound[NARUTO_SOUND_WLIGHT],63,"naruto/white_lightning.wav");
	copy(g_sound[NARUTO_SOUND_IRING],63,"naruto/ice_ring.wav");
	copy(g_sound[NARUTO_SOUND_CERO],63,"naruto/cero.wav");
	
	for (new i = 0; i < NARUTO_MAX_SOUNDS; i++ )
	{
		precache_sound(g_sound[i]);
	}
	
	precache_model("models/sphere.mdl");

	return PLUGIN_CONTINUE;
}

public plugin_end()
{
	if(get_pcvar_num(cvar_naruto) != 1) return PLUGIN_CONTINUE;

	save_all_players();
	database_close();

	return PLUGIN_CONTINUE;
}

public print_hud_player(id)
{
	/*
	L_HUD_PLAYER:
	[Class: %s]^n\
	[Experience: %d/%d]^n\
	[Level: %d/%d]^n\
	[Attributepoints: %d]^n\
	[Skillpoints: %d]^n\
	[Spirit Power: %d/%d]^n\
	[Item: %s]
	:
	*/
	
	set_hudmessage(200,180,0,0.02,0.207,0, 0.0,4.9,0.0,0.0,NARUTO_HUD_PLAYER);
	show_hudmessage(id,"[Class: %s]^n\
	[Experience: %d/%d]^n\
	[Level: %d/%d]^n\
	[Attributepoints: %d]^n\
	[Skillpoints: %d]^n\
	[Spirit Power: %d/%d]^n\
	[Item: %s]",
	g_naruto_classes[g_player_class[id]],
	g_player_experience[id],
	g_player_next_level[g_player_level[id]],
	g_player_level[id],NARUTO_MAX_LEVELS,
	g_player_attributepoints[id],
	g_player_skillpoints[id],
	g_player_spirit[id],
	g_player_max_spirit[id],
	g_item_names[g_player_item[id]]);
}

public print_hud_status(id,const message[],...)
{
	static buffer_message[512];
	vformat(buffer_message,511,message,3);
	
	set_hudmessage(200,180,0,0.43,0.8,1, 0.0,3.0,0.0,0.0,NARUTO_HUD_STATUS);
	show_hudmessage(id,buffer_message);
}

public xp_get(xp)
{
	static Float:multiple,new_xp;
	
	if(get_pcvar_num(cvar_savexp) > 1) multiple=Float:get_pcvar_float(cvar_xp_long_term);
	else multiple=Float:get_pcvar_float(cvar_xp_short_term);
	
	new_xp=floatround(xp*multiple);
	
	new players[32],num_ts,num_ct;
	
	get_players(players,num_ts,"eh","TERRORIST");
	get_players(players,num_ct,"eh","CT");
	
	if(get_pcvar_num(cvar_xp_minplayers)/2 >= num_ts+num_ct)
	{
		new_xp=0;
	}
	
	return new_xp;
}

public xp_check(id)
{
	if(g_player_experience[id] < 0)
	{
		g_player_experience[id]=0;
	}
	
	static level_diffrent,level_old;
	new bool:level_down,bool:level_up;
	
	level_old = g_player_level[id];
	
	if(g_player_level[id]!=NARUTO_MAX_LEVELS)
	{
		for (new i = 0; i <= NARUTO_MAX_LEVELS; i++)
		{
			if (g_player_experience[id] >= g_player_next_level[g_player_level[id]])
			{
				g_player_level[id]=i;
				level_up=true;
			}
			else
			{
				break;
			}
		}
	}
	
	if(g_player_level[id] > 1)
	{
		for (new i=NARUTO_MAX_LEVELS; i >= g_player_level[id]; --i)
		{
			if(g_player_experience[id] < g_player_next_level[g_player_level[id]-1])
			{
				g_player_level[id]-=1;
				level_down=true;
			}
			else
			{
				break;
			}
		}
	}
	
	if(level_up || level_down) g_player_max_spirit[id]=NARUTO_MAXIMUM_SPIRIT_POWER+(g_player_level[id]*NARUTO_SPR_PER_LEVEL);
	
	if(level_up)
	{
		if(is_user_alive(id))
		{
			emit_sound(id,CHAN_STATIC,g_sound[NARUTO_SOUND_LEVELUP],VOL_NORM,ATTN_NORM,0,PITCH_NORM);
		}
		
		client_print(id,print_chat,"%L",id,"L_USER_LEVEL_UP",PLUGIN_TAG,g_player_level[id],NARUTO_SP_PER_LEVEL);

		level_diffrent=g_player_level[id]-level_old;
		g_player_skillpoints[id]+=level_diffrent*NARUTO_SP_PER_LEVEL;
		g_player_attributepoints[id]+=level_diffrent*NARUTO_AP_PER_LEVEL;
		menu_print_skills(id);
		level_up=false;
	}
	else if(level_down)
	{
		client_print(id,print_chat,"%L",id,"L_USER_LEVEL_DROP",PLUGIN_TAG,g_player_level[id]);
		
		g_player_skillpoints[id]=g_player_level[id]*NARUTO_SP_PER_LEVEL;
		g_player_attributepoints[id]=g_player_level[id]*NARUTO_AP_PER_LEVEL;
		reset_player_skills(id);
		reset_player_attributes(id);
		level_down=false;
	}
	
	return PLUGIN_CONTINUE;
}

public xp_set(id,amount)
{
	if(amount < 0) amount = 0;
	
	g_player_experience[id] = amount;
	
	xp_check(id);
	print_hud_player(id);
	
	return PLUGIN_CONTINUE;
}

public xp_win_round(team)
{
	new players[MAXPLAYERS],id;
	static xp,num;
	
	xp=xp_get(get_pcvar_num(cvar_xp_round));

	get_players(players,num,"ach");
	for(new i = 0; i < num; i++)
	{
		id=players[i];
		if (get_user_team(id) == team)
		{
			xp_set(id,g_player_experience[id]+xp);
			client_print(id,print_chat,"%s You have been awarded %d experience for winning the round!",PLUGIN_TAG,xp);
		}
	}
	
	return PLUGIN_CONTINUE;
}

public xp_share(id,xp,message[])
{
	new players[MAXPLAYERS],origin_victim[3],distance,xp_bonus;
	static origin[3],num,radius;
	
	get_user_origin(id,origin);
	radius=get_pcvar_num(cvar_xp_share_radius);
	
	get_players(players,num,"ach");
	for(new i = 0; i < num; i++)
	{
		if(get_user_team(id)!=get_user_team(players[i]) || id==players[i])
		{
			continue;
		}
		
		get_user_origin(players[i],origin_victim);
		distance = get_distance(origin,origin_victim);
		
		if(distance < radius)
		{
			xp_bonus=floatround(radius_calucation(origin,origin_victim,radius,xp/2.0,xp/1.5));
			client_print(players[i],print_chat,"%L",players[i],message,PLUGIN_TAG,xp_bonus);
			xp_set(players[i],g_player_experience[players[i]]+xp_bonus);
		}            
	}
	
	return PLUGIN_CONTINUE;
}


public spirit_check(id)
{
	if(g_player_spirit[id] > g_player_max_spirit[id])
	{
		g_player_spirit[id] = g_player_max_spirit[id];
	}
}

public spirit_set(id,amount)
{
	if(g_player_class[id] == 0) return PLUGIN_CONTINUE;
	
	if(amount < 0) amount = 0;
	
	g_player_spirit[id] = amount;
	
	spirit_check(id);
	print_hud_player(id);
	
	return PLUGIN_CONTINUE;
}

public spirit_regenerate()
{
	if(get_pcvar_num(cvar_naruto) != 1) return PLUGIN_CONTINUE;
	
	new players[MAXPLAYERS],bonus_spirit,id;
	static num;
	
	get_players(players,num,"ach");
	for (new i; i < num; ++i)
	{
		id=players[i];
		bonus_spirit = g_player_spirit[id] + 1*g_player_level[id];
		spirit_set(id,bonus_spirit);
	}
	
	return PLUGIN_CONTINUE;
}


public  bomb_planted(planter)
{
	if(get_pcvar_num(cvar_naruto) != 1) return PLUGIN_CONTINUE;
	
	static xp;
	xp=xp_get(get_pcvar_num(cvar_xp_plant));
	
	client_print(planter,print_chat,"%L",planter,"L_XP_PLANT",PLUGIN_TAG,xp);
	xp_set(planter,g_player_experience[planter]+xp);
	xp_share(planter,xp,"L_XP_SHARE_PLANT");
	
	g_event_planted=true;
	
	return PLUGIN_CONTINUE;
}

public  bomb_defused(defuser)
{
	if(get_pcvar_num(cvar_naruto) != 1) return PLUGIN_CONTINUE;
	
	static xp;
	xp=xp_get(get_pcvar_num(cvar_xp_defuse));
	
	client_print(defuser,print_chat,"%L",defuser,"L_XP_DEFUSE",PLUGIN_TAG,xp);
	xp_set(defuser,g_player_experience[defuser]+xp);
	xp_share(defuser,xp,"L_XP_SHARE_DEFUSE");
	
	return PLUGIN_CONTINUE;
}

public  bomb_explode(planter,defuser) 
{
	if(get_pcvar_num(cvar_naruto) != 1) return PLUGIN_CONTINUE;
	
	static xp;
	xp=xp_get(get_pcvar_num(cvar_xp_explode));
	
	client_print(planter,print_chat,"%L",planter,"L_XP_EXPLODE",PLUGIN_TAG,xp);
	xp_set(planter,g_player_experience[planter]+xp);
	
	return PLUGIN_CONTINUE;
}


public motd_help(id)
{
	static motd_header[64];
	new motd_body[2048],len;

	len += formatex(motd_body[len],2047-len,html_header);
	
	formatex(motd_header,63,"%L",id,"L_MOTD_TITLE_HELP",PLUGIN_NAME);
	
	len += formatex(motd_body[len],2047-len,"%L",id,"L_MOTD_HELP");

	len += formatex(motd_body[len],2047-len,html_footer);
	
	show_motd(id,motd_body,motd_header);
	
	return PLUGIN_HANDLED;
}

public motd_commands(id)
{
	static motd_header[64];
	new motd_body[2048],len;

	len += formatex(motd_body[len],2047-len,html_header);
	
	formatex(motd_header,63,"%L",id,"L_MOTD_TITLE_COMMANDS",PLUGIN_NAME);
	
	len += formatex(motd_body[len],2047-len,"%L",id,"L_MOTD_COMMANDS");

	len += formatex(motd_body[len],2047-len,html_footer);
	
	show_motd(id,motd_body,motd_header);
	
	return PLUGIN_HANDLED;
}

public motd_about(id)
{
	static motd_header[64];
	new motd_body[2048],len;

	len += formatex(motd_body[len],2047-len,html_header);
	
	formatex(motd_header,63,"%L",id,"L_MOTD_TITLE_ABOUT",PLUGIN_NAME);
	
	len += formatex(motd_body[len],2047-len,"%L",id,"L_MOTD_ABOUT",PLUGIN_NAME,PLUGIN_VERSION,PLUGIN_AUTHOR);

	len += formatex(motd_body[len],2047-len,html_footer);
	
	show_motd(id,motd_body,motd_header);
	
	return PLUGIN_HANDLED;
}

public motd_players(id)
{
	static num_ct,num_t,num_s,motd_header[64];
	new motd_body[1024],len,name[128],players_ct[MAXPLAYERS],players_t[MAXPLAYERS],players_s[MAXPLAYERS];

	len += formatex(motd_body[len],1023-len,html_header);
	
	formatex(motd_header,63,"%L",id,"L_MOTD_TITLE_PLAYERLIST",PLUGIN_NAME);
	
	get_players(players_ct,num_ct,"ceh","CT");
	get_players(players_t,num_t,"ceh","TERRORIST");
	get_players(players_s,num_s,"ceh","SPECTATOR");
	
	len += formatex(motd_body[len],1023-len,"<br /><br /><h2 class='ct'>Counter-Terrorist:</h2><ul>");
	
	new deathgod[]="<span class='deathgod'><li>";
	new hollow[]="<span class='hollow'><li>";
	
	for (new i; i < num_ct; ++i)
	{
		new v=players_ct[i];
		
		if(is_user_connected(v) && g_player_class[v] > 0)
		{
			get_user_name(v,name,127);
			
			replace(name,127,"<","&lt;");
			replace(name,127,">","&gt;");
			
			if(g_player_class[v] == 1) len += formatex(motd_body[len],1023-len,deathgod);
			else len += formatex(motd_body[len],1023-len,hollow);
			
			len += formatex(motd_body[len],1023-len,"%s, %s level %d</span></li>",name,g_naruto_classes[g_player_class[v]],g_player_level[v]);
		}
	}
	
	if(num_ct < 1) len += formatex(motd_body[len],1023-len,"%L",id,"L_MOTD_NO_PLAYERS");
	else len += formatex(motd_body[len],1023-len,"</ul>");
	
	len += formatex(motd_body[len],1023-len,"<br /><br /><h2 class='ts'>Terrorist:</h2><ul>");
	
	for (new i; i < num_t; ++i)
	{
		new v=players_t[i];
		
		if(is_user_connected(v) && g_player_class[v] > 0)
		{
			get_user_name(v,name,127);
			
			replace(name,127,"<","&lt;");
			replace(name,127,">","&gt;");
			
			if(g_player_class[v] == 1) len += formatex(motd_body[len],1023-len,deathgod);
			else len += formatex(motd_body[len],1023-len,hollow);
			
			len += formatex(motd_body[len],1023-len,"%s, %s level %d</span></li>",name,g_naruto_classes[g_player_class[v]],g_player_level[v]);
		}
	}
	
	if(num_t < 1) len += formatex(motd_body[len],1023-len,"%L",id,"L_MOTD_NO_PLAYERS");
	else len += formatex(motd_body[len],1023-len,"</ul>");
	
	len += formatex(motd_body[len],1023-len,"<br /><br /><h2 class='sp'>Spectator:</h2><ul>");
	
	for (new i; i < num_s; ++i)
	{
		new v=players_s[i];
		
		if(is_user_connected(v) && g_player_class[v] > 0)
		{
			get_user_name(v,name,127);
			
			replace(name,127,"<","&lt;");
			replace(name,127,">","&gt;");
			
			if(g_player_class[v] == 1) len += formatex(motd_body[len],1023-len,deathgod);
			else len += formatex(motd_body[len],1023-len,hollow);
			
			len += formatex(motd_body[len],1023-len,"%s, %s level %d</span></li>",name,g_naruto_classes[g_player_class[v]],g_player_level[v]);
		}
	}
	
	if(num_s < 1) len += formatex(motd_body[len],1023-len,"%L",id,"L_MOTD_NO_PLAYERS");
	else len += formatex(motd_body[len],1023-len,"</ul>");
	
	len += formatex(motd_body[len],1023-len,html_footer);
	
	show_motd(id,motd_body,motd_header);
	
	return PLUGIN_HANDLED;
}

public motd_skills(id)
{
	if(g_player_class[id]==CLASS_NONE) return PLUGIN_HANDLED;
	
	static motd_header[64];
	new motd_body[2048],len;
	
	formatex(motd_header,63,"%L",id,"L_MOTD_TITLE_SKILLS",PLUGIN_NAME);

	len += formatex(motd_body[len],2047-len,html_header);
	
	len += formatex(motd_body[len],1023-len,"%L",id,"L_MOTD_SKILLS");
	
	if(g_player_class[id]==CLASS_DEATHGOD)
	{
		len += formatex(motd_body[len],1023-len,"%L",id,"L_MOTD_SKILLS_DEATHGOD");
	}
	else if(g_player_class[id]==CLASS_HOLLOW)
	{
		len += formatex(motd_body[len],1023-len,"%L",id,"L_MOTD_SKILLS_HOLLOW");
	}
	
	len += formatex(motd_body[len],1023-len,html_footer);
	
	show_motd(id,motd_body,motd_header);
	
	return PLUGIN_HANDLED;
}

public motd_attributes(id)
{
	static motd_header[64];
	new motd_body[2048],len;

	len += formatex(motd_body[len],2047-len,html_header);
	
	formatex(motd_header,63,"%L",id,"L_MOTD_TITLE_ATTRIBUTES",PLUGIN_NAME);
	
	len += formatex(motd_body[len],2047-len,"%L",id,"L_MOTD_ATTRIBUTES");

	len += formatex(motd_body[len],2047-len,html_footer);
	
	show_motd(id,motd_body,motd_header);
	
	return PLUGIN_HANDLED;
}

public motd_items(id)
{
	static motd_header[64];
	new motd_body[2048],len;

	len += formatex(motd_body[len],2047-len,html_header);
	
	formatex(motd_header,63,"%L",id,"L_MOTD_TITLE_ITEMS",PLUGIN_NAME);
	
	len += formatex(motd_body[len],2047-len,"%L",id,"L_MOTD_ITEMS");

	len += formatex(motd_body[len],2047-len,html_footer);
	
	show_motd(id,motd_body,motd_header);
	
	return PLUGIN_HANDLED;
}

public motd_character(id)
{
	static motd_header[64],CsArmorType:armor_type,gravity;
	new motd_body[2048],len;

	len += formatex(motd_body[len],2047-len,html_header);
	
	formatex(motd_header,63,"%L",id,"L_MOTD_TITLE_CHARACTER",PLUGIN_NAME);
	
	gravity=floatround(get_cvar_num("sv_gravity")*get_user_gravity(id));
	
	len += formatex(motd_body[len],2047-len,"%L",id,"L_MOTD_CHARACTER_START",
	g_naruto_classes[g_player_class[id]],
	g_player_experience[id],
	g_player_next_level[g_player_level[id]],
	g_player_level[id],
	g_player_attributepoints[id],g_player_skillpoints[id],
	g_player_athletic[id],g_player_acrobatic[id],g_player_endurance[id],
	gravity,get_user_maxspeed(id),
	get_user_health(id),cs_get_user_armor(id,armor_type),g_player_spirit[id],
	g_player_max_health[id],g_player_max_armour[id],g_player_max_spirit[id],
	g_item_names[g_player_item[id]]);
	
	if(g_player_class[id] == 1)
	{
		len += formatex(motd_body[len],2047-len,"%L",id,"L_MOTD_CHARACTER_DG",
		g_skill[id][P_SKILL_1],
		g_skill[id][P_SKILL_2],
		g_skill[id][P_SKILL_3],
		g_skill[id][P_SKILL_4],
		g_skill[id][P_SKILL_5],
		g_skill[id][P_SKILL_6]);
	}
	else if(g_player_class[id] ==2)
	{
		len += formatex(motd_body[len],2047-len,"%L",id,"L_MOTD_CHARACTER_HW",
		g_skill[id][P_SKILL_1],
		g_skill[id][P_SKILL_2],
		g_skill[id][P_SKILL_3],
		g_skill[id][P_SKILL_4],
		g_skill[id][P_SKILL_5],
		g_skill[id][P_SKILL_6]);
	}
	
	len += formatex(motd_body[len],2047-len,"%L",id,"L_MOTD_CHARACTER_END");
	len += formatex(motd_body[len],2047-len,html_footer);
	
	show_motd(id,motd_body,motd_header);
	
	return PLUGIN_HANDLED;
}


public logevent_game()
{
	if(get_pcvar_num(cvar_naruto) != 1 || !get_playersnum()) return PLUGIN_CONTINUE;
	
	static log_action[32];
	read_logargv(1,log_action,64);
	
	if(equal(log_action,"Round_End"))
	{
		g_event_round_end=true;
		
		buy_time_over();
		
		new players[MAXPLAYERS],id;
		static num;
		
		get_players(players,num,"ch");

		for(new i = 0; i < num; i++)
		{
			id=players[i];
	
			g_player_first_spawn[id]=false;
			g_player_class_selected[id]=false;
			g_player_skill_reseted[id]=false;
			g_player_character_reseted[id]=false;
			g_player_negation_used[id]=false;
			
			save_player(id);
		}
	}
	else if(equal(log_action,"Round_Start"))
	{
		g_player_bomber=0;
		g_player_planter=0;
		g_player_defuser=0;
		g_event_planted=false;
		g_event_freeze_time=false;
		item_drop_remove();
	}
	else if (containi(log_action,"Restart_Round_") != -1)
	{
		g_event_round_end=true;
		
		buy_time_over();
		reset_player_all();
	}
	
	return PLUGIN_CONTINUE;
}

public logevent_player()
{
	if(get_pcvar_num(cvar_naruto) != 1 || !get_playersnum()) return PLUGIN_CONTINUE;
	
	static log_arg[64],log_action[64];
	new player_name[32],id;

	read_logargv(0,log_arg,63);
	read_logargv(2,log_action,63);
	parse_loguser(log_arg,player_name,31,id);

	id = get_user_index(player_name);
	
	if(!is_user_connected(id) || id == 0) 
	{
		return PLUGIN_CONTINUE;
	}
	
	if(equal(log_action,"Spawned_With_The_Bomb") || equal(log_action,"Got_The_Bomb"))
	{
		if(!g_player_first_spawn[id])
		{
			static xp;
			xp=xp_get(get_pcvar_num(cvar_xp_bomber));
			
			client_print(id,print_chat,"%L",id,"L_XP_SPAWN_BOMB",PLUGIN_TAG,xp);
			xp_set(id,g_player_experience[id]+xp);
		}
		g_player_bomber=id;
	}
	else if(equal(log_action,"Dropped_The_Bomb"))
	{
		if(!g_player_first_spawn[id])
		{
			static xp;
			xp=xp_get(get_pcvar_num(cvar_xp_bomber));
			
			client_print(id,print_chat,"%L",id,"L_XP_DROP_BOMB",PLUGIN_TAG,xp);
			xp_set(id,g_player_experience[id]-xp);
		}
		g_player_bomber=0;
	}
	
	return PLUGIN_CONTINUE;
}

public logevent_objective_team()
{
	if(get_pcvar_num(cvar_naruto) != 1 || !get_playersnum()) return PLUGIN_CONTINUE;
	
	static log_team[32],log_action[64];

	read_logargv(1,log_team,31);
	read_logargv(3,log_action,63);
	
	if(equal(log_action,"CTs_Win" ))
	{
		set_task(2.0,"xp_win_round",TEAM_CT);
	}
	else if(equal(log_action,"Terrorists_Win"))
	{
		set_task(2.0,"xp_win_round",TEAM_T);
	}
	
	return PLUGIN_CONTINUE;
}


public event_restart_attempt()
{
	if(get_pcvar_num(cvar_naruto) != 1 || !get_playersnum()) return PLUGIN_CONTINUE;
		
	new players[MAXPLAYERS];
	static num;
	
	get_players(players,num,"ah");
	for (new i; i < num; ++i)
	{
		g_restart_attempt[players[i]]=true;
	}
	
	return PLUGIN_CONTINUE;
}

public event_hud_reset(id)
{
	if(get_pcvar_num(cvar_naruto) != 1) return PLUGIN_CONTINUE;
	
	remove_status_icon(id);
	set_user_rendering(id);
	
	if(g_event_round_end)
	{
		g_event_round_end=false;
		g_event_freeze_time=true;
	}
	
	if(!g_event_buy_time)
	{
		g_event_buy_time = true;
		set_task(get_cvar_float("mp_buytime")*60.0,"buy_time_over",NARUTO_TASK_BUYTIME);
	}
	
	if(g_restart_attempt[id])
	{
		g_restart_attempt[id]=false;
		return PLUGIN_CONTINUE;
	}
	
	if(!task_exists(NARUTO_TASK_SPIRIT,0))
	{
		set_task(5.0,"spirit_regenerate",NARUTO_TASK_SPIRIT,"",0,"b");
		reset_player_all();
		database_init();
	}
	
	event_player_spawn(id);
	
	return PLUGIN_CONTINUE;
}

public event_first_spawn(id)
{
	client_print(id,print_chat,"%L",id,"L_GAME_WELCOME",PLUGIN_TAG);
	menu_print_classes(id);
}

public event_player_spawn(id)
{
	if(g_player_first_spawn[id])
	{
		event_first_spawn(id);
	}
	else if(g_player_class[id]==0)
	{
		menu_print_classes(id);
	}
	
	g_player_max_health[id]=DEFAULT_MAX_HEALTH;
	g_player_max_armour[id]=DEFAULT_MAX_ARMOUR;
	
	if(cs_get_user_vip(id))
	{
		g_player_max_armour[id]+=100;
	}
	
	if(g_skill[id][P_SKILL_5] > 0 && g_player_class[id] == 2)
	{
		static armor,CsArmorType:armor_type;
		armor=cs_get_user_armor(id,armor_type);
		if(armor < g_skill[id][P_SKILL_5]*15)
		{
			static armor_bonus;
			armor_bonus = g_skill[id][P_SKILL_5]*15;
			cs_set_user_armor(id,armor_bonus,armor_type);
			g_player_max_armour[id]+=armor_bonus;
		}
	}
	
	validate_gravity(id);
	set_user_health(id,g_player_max_health[id]+g_player_endurance[id]);
	
	restore_player(id);
	restore_cooldowns(id);
}

public event_bartime(id)
{
	if(get_pcvar_num(cvar_naruto) != 1) return PLUGIN_CONTINUE;

	new bartime = read_data(1);

	if (bartime == 3) g_player_planter=id;
	else if (bartime == 5 || bartime == 10) g_player_defuser=id;
	else if (bartime == 0)
	{
		if (id == g_player_planter) g_player_planter=0;

		if (id == g_player_defuser) g_player_defuser=0;
	}
	
	return PLUGIN_CONTINUE;
}

public event_zoom(id)
{
	if(get_pcvar_num(cvar_naruto) != 1) return PLUGIN_CONTINUE;

	if (read_data(1) < 90)
	{
		g_player_zoomed[id] = true;
	}
	else
	{
		g_player_zoomed[id] = false;
	}

	return PLUGIN_CONTINUE;
}

public event_current_weapon(id)
{
	if(get_pcvar_num(cvar_naruto) != 1) return PLUGIN_CONTINUE;
	
	if(!g_event_freeze_time)
	{
		validate_max_speed(id);
	}
	
	return PLUGIN_CONTINUE;
}

public event_item_pickup(id)
{
	if(get_pcvar_num(cvar_naruto) != 1) return PLUGIN_CONTINUE;
	
	new item_name[32];
	read_data(1,item_name,31);
	
	if((equal(item_name,"item_assaultsuit") || equal(item_name,"item_kevlar")) &&  cs_get_user_buyzone(id))
	{
		if(g_skill[id][P_SKILL_5] > 0)
		{
			static armor,CsArmorType:armor_type;
			armor=cs_get_user_armor(id,armor_type);
			cs_set_user_armor(id,armor+g_skill[id][P_SKILL_5]*15,armor_type);
		}
	}
	
	return PLUGIN_CONTINUE;
}


public clcmd_fullupdate()
{
	return PLUGIN_HANDLED_MAIN;
}

public fm_cmd_start(id,uc_handle,seed)
{
	if((get_pcvar_num(cvar_naruto) != 1) || (!is_user_alive(id))) return FMRES_IGNORED;
  
	new button = get_uc(uc_handle,UC_Buttons);
	
	if(g_player_frozen[id])
	{
		if(button & IN_JUMP)
		{
			button &= ~IN_JUMP;
			set_uc(uc_handle,UC_Buttons,button);
		}
	}
	
	if(button & IN_USE)
	{
		g_player_use[id]=true;
	}
	else if(button & ~IN_USE)
	{
		g_player_use[id]=false;
	}
	
	return FMRES_HANDLED;
}

public handler_say(id)
{
	if(get_pcvar_num(cvar_naruto) != 1) return PLUGIN_CONTINUE;
	
	static said[32];
	read_args(said,31);
	remove_quotes(said);

	if(equal(said,"/ntmenu"))
	{
		menu_print_main(id);
	}
	else if(equal(said,"/ntmenu2"))
	{
		menu_print_next(id);
	}
	else if(equal(said,"/information"))
	{
		menu_print_information(id);
	}
	else if(equal(said,"/side"))
	{
		menu_print_classes(id);
	}
	else if(equal(said,"/attributes"))
	{
		menu_print_attributes(id);
	}
	else if(equal(said,"/skills"))
	{
		menu_print_skills(id);
	}
	else if(equal(said,"/items"))
	{
		menu_print_items(id);
	}
	else if(equal(said,"/drop"))
	{
		drop_player_item(id);
	}
	else if(equal(said,"/use"))
	{
		item_use(id);
	}
	else if(equal(said,"/attributesinfo"))
	{
		motd_attributes(id);
	}
	else if(equal(said,"/skillsinfo"))
	{
		motd_skills(id);
	}
	else if(equal(said,"/itemsinfo"))
	{
		motd_items(id);
	}
	else if(equal(said,"/character"))
	{
		motd_character(id);
	}
	else if(equal(said,"/reskills"))
	{
		if(g_player_skill_reseted[id])
		{
			client_print(id,print_chat,"%L",id,"L_SKILL_RESELECT_ONCE",PLUGIN_TAG);
		}
		else
		{
			reselect_skills(id);
		}
	}
	else if(equal(said,"/save"))
	{
		if(get_pcvar_num(cvar_savexp) == 1)
		{
			client_print(id,print_chat,"%L",id,"L_USER_SAVE",PLUGIN_TAG);
			save_player(id);
		}
		else
		{
			client_print(id,print_chat,"%L",id,"L_SAVEXP_MANUAL_SAVE_DISABLED",PLUGIN_TAG);
		}
	}
	else if(equal(said,"/help"))
	{
		motd_help(id);
	}
	else if(equal(said,"/about"))
	{
		motd_about(id);
	}
	else if(equal(said,"/commands"))
	{
		motd_commands(id);
	}
	else if(equal(said,"/players"))
	{
		motd_players(id);
	}
	
	return PLUGIN_CONTINUE;
}

public handler_cmd(id,level,cid)
{
	if (!cmd_access(id,level,cid,1))
	{
		return PLUGIN_HANDLED;
	}
	
	static cmd[32],arg1[32],arg2[32];
	read_argv(0,cmd,31);
	
	if((!equal(cmd,"bm_naruto")) && (get_pcvar_num(cvar_naruto) != 1))
	{
		admin_print(id,"%L",id,"L_GAME_NOT_ENABLED",PLUGIN_TAG);
		return PLUGIN_HANDLED;
	}
	
	read_argv(1,arg1,31);
	read_argv(2,arg2,31);
	
	if(equal(cmd,"bm_naruto"))
	{
		if(equal(arg1,"1"))
		{
			if (get_pcvar_num(cvar_naruto) == 1)
			{
				admin_print(id,"%L",id,"L_GAME_ALREADY_ENABLED",PLUGIN_TAG);
			}
			else
			{
				admin_print(id,"%L",id,"L_GAME_ENABLED",PLUGIN_TAG);
				naruto_start();
			}
		}
		else if(equal(arg1,"0"))
		{
			if(get_pcvar_num(cvar_naruto) == 1)
			{
				admin_print(id,"%L",id,"L_GAME_DISABLED",PLUGIN_TAG);
				naruto_stop();
			}
			else
			{
				admin_print(id,"%L",id,"L_GAME_ALREADY_DISABLED",PLUGIN_TAG);
			}
		}
	}
	else if (equal(cmd,"bm_savexp"))
	{
		if (read_argc() < 2)
		{
			admin_print(id,"%L",id,"L_FORMAT_SAVEXP",cmd);
			return PLUGIN_HANDLED;
		}
		
		static savexp[8];
		num_to_str(get_pcvar_num(cvar_savexp),savexp,7);
		
		if(equal(arg1,savexp))
		{
			admin_print(id,"%L",id,"L_SAVEXP_METHOD",PLUGIN_TAG);
			return PLUGIN_HANDLED;
		}
		
		if(str_to_num(arg1) != get_pcvar_num(cvar_savexp))
		{
			save_all_players();
			database_close();
			reset_player_all();
		}

		if(equal(arg1,"1"))
		{
			admin_print(id,"%L",id,"L_SAVEXP_VAULT",PLUGIN_TAG);
			set_pcvar_num(cvar_savexp,1);
		}
		else if(equal(arg1,"2"))
		{
			admin_print(id,"%L",id,"L_SAVEXP_SQL",PLUGIN_TAG);
			set_pcvar_num(cvar_savexp,2);
			database_init();
		}
		else if(equal(arg1,"0"))
		{
			admin_print(id,"%L",id,"L_SAVEXP_DISABLED",PLUGIN_TAG);
			set_pcvar_num(cvar_savexp,0);
		}
	}
	else if (equal(cmd,"bm_givexp"))
	{
		if (read_argc() < 3)
		{
			admin_print(id,"%L",id,"L_FORMAT_XP",cmd);
			return PLUGIN_HANDLED;
		}
		admin_give_xp(id,arg1,str_to_num(arg2));
	}
	else if (equal(cmd,"bm_setxp"))
	{
		if (read_argc() < 3)
		{
			admin_print(id,"%L",id,"L_FORMAT_XP",cmd);
			return PLUGIN_HANDLED;
		}
		admin_set_xp(id,arg1,str_to_num(arg2));
	}
	else if (equal(cmd,"bm_givespr"))
	{
		if (read_argc() < 3)
		{
			admin_print(id,"%L",id,"L_FORMAT_SPIRIT",cmd);
			return PLUGIN_HANDLED;
		}
		admin_give_spirit(id,arg1,str_to_num(arg2));
	}
	else if (equal(cmd,"bm_setspr"))
	{
		if (read_argc() < 3)
		{
			admin_print(id,"%L",id,"L_FORMAT_SPIRIT",cmd);
			return PLUGIN_HANDLED;
		}
		admin_set_spirit(id,arg1,str_to_num(arg2));
	}
	else if(equal(cmd,"bm_giveitem"))
	{
		if (read_argc() < 3)
		{
			admin_print(id,"%L",id,"L_FORMAT_G_ITEM",cmd);
			return PLUGIN_HANDLED;
		}
		admin_give_item(id,arg1,str_to_num(arg2));
	}
	else if(equal(cmd,"bm_dropitem"))
	{
		if (read_argc() < 2)
		{
			admin_print(id,"%L",id,"L_FORMAT_D_ITEM",cmd);
			return PLUGIN_HANDLED;
		}
		admin_drop_item(id,str_to_num(arg1));
	}
	else if (equal(cmd,"bm_resetuser"))
	{
		if (read_argc() < 3)
		{
			admin_print(id,"%L",id,"L_FORMAT_RESET",cmd);
			return PLUGIN_HANDLED;
		}
		admin_reset_player(id,arg1,str_to_num(arg2));
	}
	else if (equal(cmd,"bm_purge"))
	{
		admin_purge(id);
	}
	else if (equal(cmd,"bm_reset"))
	{
		if(g_player_character_reseted[id])
		{
			client_print(id,print_console,"%L",id,"L_USER_RESET_ONCE",PLUGIN_TAG);
		}
		else
		{
			client_print(id,print_console,"%L",id,"L_USER_RESETED",PLUGIN_TAG,g_naruto_classes[g_player_class[id]]);
			
			reset_player(id);
			reset_player_attributes(id);
			reset_player_skills(id);
			restore_cooldowns(id);
			
			validate_max_speed(id);
			validate_gravity(id);
			
			save_player(id);
			print_hud_player(id);
			g_player_character_reseted[id]=true;
		}
	}
	else if(equal(cmd,"bm_item_use"))
	{
		item_use(id);
	}

	return PLUGIN_HANDLED;
}

public handler_skill(id)
{
	if(get_pcvar_num(cvar_naruto) != 1 || !is_user_alive(id)) return PLUGIN_HANDLED;

	new cmd[32];
	read_argv(0,cmd,31);
	
	if(equal(cmd,""))
	{
		return PLUGIN_HANDLED;
	}
	else if(equal(cmd,"bm_skill_next") || equal(cmd,"bm_skill_prev"))
	{
		if(equal(cmd,"bm_skill_next"))
		{
			if(g_player_current_skill[id] < (NARUTO_MAX_SKILLS - 1))
			{
				g_player_current_skill[id] += 1;
			}
			else
			{
				g_player_current_skill[id] = 0;
			}
		}
		else if(equal(cmd,"bm_skill_prev"))
		{
			if(g_player_current_skill[id] > 0)
			{
				g_player_current_skill[id] -= 1;
			}
		}
		

		if(g_player_class[id] == 1)
		{
			print_hud_status(id,"%L",id,"L_STATUS_SKILL_CURRENT",g_dg_skill_names[g_player_current_skill[id]]);
		}
		else if(g_player_class[id] == 2)
		{
			print_hud_status(id,"%L",id,"L_STATUS_SKILL_CURRENT",g_hw_skill_names[g_player_current_skill[id]]);
		}
		
		return PLUGIN_HANDLED;
	}
	else if(equal(cmd,"+bm_skill_use") || equal(cmd,"-bm_skill_use"))
	{
		if(g_player_class[id] == 0)
		{
			return PLUGIN_HANDLED;
		}
		
		static skill;
		skill=g_player_current_skill[id];
		
		if(equal(cmd,"+bm_skill_use"))
		{
			if(g_player_class[id] == 1)
			{
				if(equal(g_dg_skill_p_cmds[skill],"")) return PLUGIN_HANDLED;
				
				format(cmd,31,g_dg_skill_p_cmds[skill]);
			}
			else if(g_player_class[id] == 2)
			{
				if(equal(g_hw_skill_p_cmds[skill],"")) return PLUGIN_HANDLED;
				
				format(cmd,31,g_hw_skill_p_cmds[skill]);
			}
		}
		else if(equal(cmd,"-bm_skill_use"))
		{
			if(g_player_class[id] == 1)
			{
				if(equal(g_dg_skill_n_cmds[skill],"")) return PLUGIN_HANDLED;
				
				format(cmd,31,g_dg_skill_n_cmds[skill]);
			}
			else if(g_player_class[id] == 2)
			{
				if(equal(g_hw_skill_n_cmds[skill],"")) return PLUGIN_HANDLED;
				
				format(cmd,31,g_hw_skill_n_cmds[skill]);
			}
		}
	}
	
	static target,body_part,origin[3],aim_origin[3],Float:time;
	new spirit_cost = 0;
	
	get_user_aiming(id,target,body_part,2500);
	get_user_origin(id,origin);
	get_user_origin(id,aim_origin,3);
	time=get_gametime();
	
	if(equal(cmd,"+bm_spirit"))
	{
		if(skill_active_check(id,1,NARUTO_SKILL_NOVICE_COST,CLASS_NONE))
		{
			skill_spirit_release_start(id);
		}
	}
	else if(equal(cmd,"-bm_spirit"))
	{
		skill_spirit_release_reset(id);
	}
	else if(equal(cmd,"bm_hbullet"))
	{
		if(!skill_active_check(id,g_skill[id][P_SKILL_2],NARUTO_SKILL_NOVICE_COST,CLASS_HOLLOW)) return PLUGIN_HANDLED;
		if(get_cooldown(id,NARUTO_SKILL_NOVICE_CD,g_player_last_event[id][0],true)) return PLUGIN_HANDLED;
		if(check_target(id,target)) return PLUGIN_HANDLED;
			
		g_player_last_event[id][0]=time;
		spirit_cost = NARUTO_SKILL_NOVICE_COST;
		skill_hollow_bullet(id,target,origin,aim_origin);
	}
	else if(equal(cmd,"bm_wlight"))
	{
		if(!skill_active_check(id,g_skill[id][P_SKILL_1],NARUTO_SKILL_NORMAL_COST,CLASS_DEATHGOD)) return PLUGIN_HANDLED;
		if(get_cooldown(id,NARUTO_SKILL_NORMAL_CD,g_player_last_event[id][1],true)) return PLUGIN_HANDLED;
		if(check_target(id,target)) return PLUGIN_HANDLED;
			
		spirit_cost = NARUTO_SKILL_NORMAL_COST;
		g_player_last_event[id][1]=time;
		skill_white_lightning(id,target,body_part,aim_origin);
	}
	else if(equal(cmd,"+bm_cero"))
	{	
		if(!skill_active_check(id,g_skill[id][P_SKILL_4],NARUTO_SKILL_MASTER_COST,CLASS_HOLLOW)) return PLUGIN_HANDLED;
		if(get_cooldown(id,NARUTO_SKILL_MASTER_CD,g_player_last_event[id][2],true)) return PLUGIN_HANDLED;
			
		skill_cero(id);
	}
	else if(equal(cmd,"-bm_cero"))
	{
		skill_cero_activate(id);
	}
	else if(equal(cmd,"bm_icering"))
	{
		if(!skill_active_check(id,g_skill[id][P_SKILL_3],NARUTO_SKILL_GREATER_COST,CLASS_DEATHGOD)) return PLUGIN_HANDLED;
		if(get_cooldown(id,NARUTO_SKILL_GREATER_CD,g_player_last_event[id][3],true)) return PLUGIN_HANDLED;
		
		skill_ice_ring(id);
		g_player_last_event[id][3]=time;
		spirit_cost = NARUTO_SKILL_GREATER_COST;
	}
	else if(equal(cmd,"bm_cherry"))
	{
		if(!skill_active_check(id,g_skill[id][P_SKILL_5],NARUTO_SKILL_MASTER_COST,CLASS_DEATHGOD)) return PLUGIN_HANDLED;
		if(get_cooldown(id,NARUTO_SKILL_MASTER_CD,g_player_last_event[id][0],true)) return PLUGIN_HANDLED;
		
		skill_cherry_blossoms(id);
	}
	else if(equal(cmd,"bm_flame"))
	{
		if(!skill_active_check(id,g_skill[id][P_SKILL_6],NARUTO_SKILL_GREATER_COST,CLASS_HOLLOW)) return PLUGIN_HANDLED;
		
		if(g_player_volcanic_flame[id] >= NARUTO_SKILL_GREATER_COST*3)
		{
			if(get_cooldown(id,NARUTO_SKILL_MASTER_CD,g_player_last_event[id][5],true)) return PLUGIN_HANDLED;
			
			g_player_last_event[id][5]=time;
			g_player_volcanic_flame[id]=0;
		}
		
		skill_volcanic_flame(id);
		spirit_cost = NARUTO_SKILL_GREATER_COST;
		g_player_volcanic_flame[id]+=NARUTO_SKILL_GREATER_COST;
	}
	
	if(spirit_cost > 0)
	{
		spirit_set(id,g_player_spirit[id]-spirit_cost);
	}
	
	return PLUGIN_HANDLED;
}


public handler_cvar_cmd(id)
{
	static cmd[32],arg1[32];
	read_argv(0,cmd,31);
	read_argv(1,arg1,31);
	
	if (read_argc() < 1) return PLUGIN_CONTINUE;
	
	if(equal(cmd,"sv_naruto"))
	{
		if(equal(arg1,"1"))
		{
			naruto_start();
		}
		else if(equal(arg1,"0"))
		{
			naruto_stop();
		}
	}
	else if (equal(cmd,"sv_savexp"))
	{
		if(str_to_num(arg1) != get_pcvar_num(cvar_savexp))
		{
			save_all_players();
			database_close();
			reset_player_all();
		}

		if(equal(arg1,"1"))
		{
			set_pcvar_num(cvar_savexp,1);
		}
		else if(equal(arg1,"2"))
		{
			set_pcvar_num(cvar_savexp,2);
			database_init();
		}
		else if(equal(arg1,"0"))
		{
			set_pcvar_num(cvar_savexp,0);
		}
	}
	else if (equal(cmd,"sv_bm_sql_host"))
	{
		set_pcvar_string(cvar_sql_host,arg1);
	}
	else if (equal(cmd,"sv_bm_sql_user"))
	{
		set_pcvar_string(cvar_sql_user,arg1);
	}
	else if (equal(cmd,"sv_bm_sql_password"))
	{
		set_pcvar_string(cvar_sql_password,arg1);
	}
	else if (equal(cmd,"sv_bm_sql_database"))
	{
		set_pcvar_string(cvar_sql_database,arg1);
	}
	else if (equal(cmd,"sv_bm_sql_table"))
	{
		set_pcvar_string(cvar_sql_table,arg1);
	}
	else if (equal(cmd,"sv_bm_sql_type"))
	{
		set_pcvar_num(cvar_sql_type,str_to_num(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_minplayers"))
	{
		set_pcvar_num(cvar_xp_minplayers,str_to_num(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_share"))
	{
		set_pcvar_num(cvar_xp_share_radius,str_to_num(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_suicide"))
	{
		set_pcvar_num(cvar_xp_suicide,str_to_num(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_kill"))
	{
		set_pcvar_num(cvar_xp_kill,str_to_num(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_teamkill"))
	{
		set_pcvar_num(cvar_xp_teamkill,str_to_num(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_assist"))
	{
		set_pcvar_num(cvar_xp_assist,str_to_num(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_skill"))
	{
		set_pcvar_num(cvar_xp_skill,str_to_num(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_negation"))
	{
		set_pcvar_num(cvar_xp_negation,str_to_num(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_headshot"))
	{
		set_pcvar_num(cvar_xp_headshot,str_to_num(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_plant"))
	{
		set_pcvar_num(cvar_xp_plant,str_to_num(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_explode"))
	{
		set_pcvar_num(cvar_xp_explode,str_to_num(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_defuse"))
	{
		set_pcvar_num(cvar_xp_defuse,str_to_num(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_round"))
	{
		set_pcvar_num(cvar_xp_round,str_to_num(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_bomber"))
	{
		set_pcvar_num(cvar_xp_bomber,str_to_num(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_planter"))
	{
		set_pcvar_num(cvar_xp_planter,str_to_num(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_defuser"))
	{
		set_pcvar_num(cvar_xp_defuser,str_to_num(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_long_term"))
	{
		set_pcvar_float(cvar_xp_long_term,str_to_float(arg1));
	}
	else if (equal(cmd,"sv_bm_xp_short_term"))
	{
		set_pcvar_float(cvar_xp_short_term,str_to_float(arg1));
	}
	
	return PLUGIN_CONTINUE;
}


public cvar_clcmd_init()
{
	register_clcmd("fullupdate","clcmd_fullupdate",-1);
	register_clcmd("say","handler_say",-1);
	register_clcmd("say_team","handler_say",-1);
	
	register_clcmd("bm_reset","handler_cmd",-1);
	register_clcmd("bm_item_use","handler_cmd",-1);
	
	register_clcmd("bm_skill_next","handler_skill",-1);
	register_clcmd("bm_skill_prev","handler_skill",-1);
	
	register_clcmd("+bm_skill_use","handler_skill",-1);
	register_clcmd("-bm_skill_use","handler_skill",-1);
	
	register_clcmd("bm_hbullet","handler_skill",-1);
	register_clcmd("bm_wlight","handler_skill",-1);
	register_clcmd("bm_icering","handler_skill",-1);
	register_clcmd("bm_cherry","handler_skill",-1);
	register_clcmd("bm_flame","handler_skill",-1);
	
	register_clcmd("+bm_cero","handler_skill",-1);
	register_clcmd("-bm_cero","handler_skill",-1);
	register_clcmd("+bm_spirit","handler_skill",-1);
	register_clcmd("-bm_spirit","handler_skill",-1);
}

public cvar_concmd_init()
{
	register_concmd("bm_naruto","handler_cmd",NARUTO_ADMIN_FLAG);
	register_concmd("bm_savexp","handler_cmd",NARUTO_ADMIN_FLAG);
	
	register_concmd("bm_setxp","handler_cmd",NARUTO_ADMIN_FLAG);
	register_concmd("bm_givexp","handler_cmd",NARUTO_ADMIN_FLAG);
	register_concmd("bm_setspr","handler_cmd",NARUTO_ADMIN_FLAG);
	register_concmd("bm_givespr","handler_cmd",NARUTO_ADMIN_FLAG);
	register_concmd("bm_giveitem","handler_cmd",NARUTO_ADMIN_FLAG);
	register_concmd("bm_dropitem","handler_cmd",NARUTO_ADMIN_FLAG);
	register_concmd("bm_resetuser","handler_cmd",NARUTO_ADMIN_FLAG);
}

public cvar_srvcmd_init()
{
	register_srvcmd("sv_naruto","handler_cvar_cmd",-1);
	register_srvcmd("sv_savexp","handler_cvar_cmd",-1);
	
	register_srvcmd("sv_bm_sql_host","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_sql_user","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_sql_password","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_sql_database","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_sql_table","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_sql_type","handler_cvar_cmd",-1);
	
	register_srvcmd("sv_bm_xp_minplayers","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_xp_share","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_xp_suicide","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_xp_kill","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_xp_teamkill","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_xp_assist","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_xp_skill","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_xp_negation","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_xp_plant","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_xp_explode","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_xp_defuse","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_xp_round","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_xp_bomber","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_xp_planter","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_xp_defuser","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_xp_long_term","handler_cvar_cmd",-1);
	register_srvcmd("sv_bm_xp_short_term","handler_cvar_cmd",-1);
	
	register_srvcmd("bm_purge","handler_cmd",-1);
}


public client_authorized(id)
{
	if(get_pcvar_num(cvar_naruto) != 1) return PLUGIN_CONTINUE;
	
	new authid[32];
	get_user_authid(id,authid,31);

	if(equal(authid,"STEAM_ID_PENDING"))
	{
		client_cmd(id,"reconnect");
	}
	
	return PLUGIN_CONTINUE;
}

public  client_putinserver(id) 
{
	if(get_pcvar_num(cvar_naruto) != 1) return PLUGIN_CONTINUE;
	
	g_player_class[id]=0;
	g_player_first_spawn[id]=true;
	g_restart_attempt[id]=false;
	
	g_player_character_reseted[id]=false;
	
	reset_player(id);
	reset_player_attributes(id);
	reset_player_skills(id);
	restore_player(id);
	restore_cooldowns(id);
	
	return PLUGIN_CONTINUE;
}

public client_disconnect(id)
{
	if(get_pcvar_num(cvar_naruto) != 1) return PLUGIN_CONTINUE;
	
	item_reset(id);
	save_player(id);
	
	return PLUGIN_CONTINUE;
}

public client_damage(attacker,victim,damage,weapon,hitplace,ta)
{
	if(get_pcvar_num(cvar_naruto) != 1) return PLUGIN_CONTINUE;
	
	g_player_damage_dealt[attacker][victim]=damage;
	
	if(attacker!=victim)
	{
		skill_passive(attacker,victim,1,damage,weapon,hitplace,ta);
	}
	
	return PLUGIN_CONTINUE;
}

public client_death(killer,victim,weapon,hitplace,tk) 
{
	if(get_pcvar_num(cvar_naruto) != 1) return PLUGIN_CONTINUE;
	
	new xp;
	static bonusxp;
	bonusxp = g_player_level[victim]/g_player_level[killer];
	
	if(bonusxp < 0.6) bonusxp = 1;
	
	if(g_player_died_by_skill[victim])
	{
		g_player_died_by_skill[victim]=false;
	}
	else if((killer == victim) && (weapon != CSW_C4))
	{
		xp=xp_get(get_pcvar_num(cvar_xp_suicide));
		
		client_print(killer,print_chat,"%L",killer,"L_XP_SUICIDE",PLUGIN_TAG,xp);
		xp_set(killer,g_player_experience[killer]-xp);
	}	
	else if(tk)
	{
		xp=xp_get(get_pcvar_num(cvar_xp_teamkill));
		
		client_print(killer,print_chat,"%L",killer,"L_XP_TEAMKILL",PLUGIN_TAG,xp);
		xp_set(killer,g_player_experience[killer]-xp);
	}
	else
	{
		skill_passive(killer,victim,0,g_player_damage_dealt[killer][victim],weapon,hitplace,tk);
		
		if(hitplace == HIT_HEAD)
		{
			xp=xp_get((get_pcvar_num(cvar_xp_kill)+get_pcvar_num(cvar_xp_headshot))*bonusxp);
			
			client_print(killer,print_chat,"%L",killer,"L_XP_HEADSHOT",PLUGIN_TAG,xp);
			xp_set(killer,g_player_experience[killer]+xp);
		}
		else 
		{
			xp=xp_get(get_pcvar_num(cvar_xp_kill)*bonusxp);
			
			client_print(killer,print_chat,"%L",killer,"L_XP_KILL",PLUGIN_TAG,xp);
			xp_set(killer,g_player_experience[killer]+xp);
		}
		
		if(g_player_bomber==victim)
		{
			g_player_bomber=0;
			xp=xp_get(get_pcvar_num(cvar_xp_bomber)*bonusxp);
			
			client_print(killer,print_chat,"%L",killer,"L_XP_BOMBER",PLUGIN_TAG,xp);
			xp_set(killer,g_player_experience[killer]+xp);
		}
		else if(g_player_planter==victim)
		{
			g_player_planter=0;
			xp=xp_get(get_pcvar_num(cvar_xp_planter)*bonusxp);
			
			client_print(killer,print_chat,"%L",killer,"L_XP_PLANTER",PLUGIN_TAG,xp);
			xp_set(killer,g_player_experience[killer]+xp);
		}
		else if(g_player_defuser==victim)
		{
			g_player_defuser=0;
			xp=xp_get(get_pcvar_num(cvar_xp_defuser)*bonusxp);
			
			client_print(killer,print_chat,"%L",killer,"L_XP_DEFUSER",PLUGIN_TAG,xp);
			xp_set(killer,g_player_experience[killer]+xp);
		}
	}
	
	new id,players[MAXPLAYERS];
	static num,req_damage,name_killer[32];
	
	req_damage=floatround(g_player_damage_dealt[killer][victim]*0.45);
	get_user_name(killer,name_killer,31);
	
	get_players(players,num,"ch");
	for (new i; i < num; ++i)
	{
		id=players[i];
		
		if(g_player_damage_dealt[id][victim] == 0)
		{
			continue;
		}
		else
		{
			if((is_user_alive(id)) && (id != killer) && (!tk))
			{
				if(g_player_damage_dealt[id][victim] > req_damage)
				{
					xp=xp_get(get_pcvar_num(cvar_xp_assist)*bonusxp);
					
					client_print(id,print_chat,"%L",id,"L_XP_ASSIST",PLUGIN_TAG,xp,name_killer);
					xp_set(id,g_player_experience[id]+xp);
				}
			}
			
			g_player_damage_dealt[id][victim]=0;
		}
	}
	
	g_player_class_selected[victim]=false;
	
	drop_player_item(victim);
	
	restore_player(victim);
	set_user_rendering(victim);
	remove_status_icon(victim);
	
	return PLUGIN_CONTINUE;
}


public admin_print(id,const message[],...)
{
	static buffer_message[512];
	vformat(buffer_message,511,message,3);

	if(id == 0)
	{
		server_print(buffer_message);
	}
	else
	{
		client_print(id,print_console,buffer_message);
	}
}

public admin_purge(id)
{
	if(get_playersnum())
	{
		admin_print(id,"%L",id,"L_SERVER_NO_EMPTY",PLUGIN_TAG);
		return PLUGIN_HANDLED;
	}
	
	if(get_pcvar_num(cvar_savexp) == 1)
	{
		admin_print(id,"%L",id,"L_VAULT_FILE_DELETED",PLUGIN_TAG);
		new data_path[64] = "%s/vault/%s.VAULT";
		format(data_path,63,data_path,amxx_data_dir,PLUGIN_VAULT);
		delete_file(data_path);
	}
	else if(get_pcvar_num(cvar_savexp) == 2)
	{
		admin_print(id,"%L",id,"L_SQL_TABLE_EMPTY",PLUGIN_TAG);
		database_truncate();
	}
	else
	{
		admin_print(id,"%L",id,"L_TURN_ON_SAVEXP",PLUGIN_TAG);
	}
	
	return PLUGIN_HANDLED;
}

public admin_reset_player(id,szTarget[],class)
{
	if(class > 2)
	{
		admin_print(id,"%L",id,"L_INVALID_CLASS",PLUGIN_TAG);
		return PLUGIN_HANDLED;
	}
	
	new victim = 0,bool:target_found = false, class_old;
	while ((victim = find_target(victim,szTarget)) > 0)
	{
		class_old=g_player_class[victim];
		
		if(class == 1)
		{
			g_player_class[victim]=1;
		}
		else if(class == 2)
		{
			g_player_class[victim]=2;
		}
		else
		{
			continue;
		}
		
		client_print(victim,print_chat,"%L",victim,"L_ADMIN_RESET_USER",PLUGIN_TAG,g_naruto_classes[g_player_class[victim]]);
		
		load_player(victim);
		
		reset_player(victim);
		reset_player_attributes(victim);
		reset_player_skills(victim);
		
		restore_cooldowns(victim);
		restore_player(victim);
		
		save_player(victim);
		
		g_player_class[victim]=class_old;
		
		load_player(victim);
		print_hud_player(victim);
		
		target_found = true;
	}
	
	if (!target_found)
	{
		no_target_found(id,szTarget,(victim == -2));
	}
	
	return PLUGIN_HANDLED;
}

//---------------------------------------------------------------------

public admin_give_xp(id,szTarget[],amount)
{
	new victim = 0,bool:target_found = false;

	while ((victim = find_target(victim,szTarget)) > 0)
	{
		client_print(victim,print_chat,"%L",victim,"L_ADMIN_XP_GAVE",PLUGIN_TAG,amount);
		target_found = true;
		xp_set(victim,g_player_experience[victim]+amount);
	}
	
	if (!target_found)
	{
		no_target_found(id,szTarget,(victim == -2));
	}
}

public admin_set_xp(id,szTarget[],amount)
{
	new victim = 0,bool:target_found = false;

	while ( ( victim = find_target( victim, szTarget ) ) > 0 )
	{
		client_print(victim,print_chat,"%L",victim,"L_ADMIN_XP_SET",PLUGIN_TAG,amount);
		target_found = true;
		xp_set(victim,amount);
	}
	
	if (!target_found)
	{
		no_target_found(id,szTarget,(victim == -2));
	}
}

//---------------------------------------------------------------------

public admin_give_spirit(id,szTarget[],amount)
{
	new victim = 0,bool:target_found = false;

	while ((victim = find_target(victim,szTarget)) > 0)
	{
		client_print(victim,print_chat,"%L",victim,"L_ADMIN_SPR_GAVE",PLUGIN_TAG,amount);
		target_found = true;
		spirit_set(victim,g_player_spirit[victim]+amount);
	}
	
	if (!target_found)
	{
		no_target_found(id,szTarget,(victim == -2));
	}
}

public admin_set_spirit(id,szTarget[],amount)
{
	new victim = 0,bool:target_found = false;

	while ( ( victim = find_target( victim, szTarget ) ) > 0 )
	{
		client_print(victim,print_chat,"%L",victim,"L_ADMIN_SPR_SET",PLUGIN_TAG,amount);
		target_found = true;
		spirit_set(victim,amount);
	}
	
	if (!target_found)
	{
		no_target_found(id,szTarget,(victim == -2));
	}
}

//---------------------------------------------------------------------

public admin_item_list(id)
{
	admin_print(id,"%L",id,"L_INVALID_ITEM_ID");
	for (new i = 1; i <= NARUTO_MAX_ITEMS; ++i)
	{
			admin_print(id,"%d = %s",i,g_item_names[i]);
	}
}

public admin_give_item(id,szTarget[],item)
{
	if((item <= 0) || (item > NARUTO_MAX_ITEMS))
	{
		admin_item_list(id);
	}
	else
	{
		new victim = 0,bool:target_found = false;
		
		while ( ( victim = find_target( victim, szTarget ) ) > 0 )
		{
			if(g_player_item[victim] == 0)
			{
				client_print(victim,print_chat,"%L",victim,"L_ADMIN_ITEM_GAVE",PLUGIN_TAG,g_item_names[item]);
				target_found = true;
				g_player_item[victim]=item;
				item_passive(victim);
			}
		}
		
		if (!target_found)
		{
			no_target_found(id,szTarget,(victim == -2));
		}
	}
}

public admin_drop_item(id,item)
{
	if((item > 0) && (item <= NARUTO_MAX_ITEMS))
	{
		item_drop(id,item);
		admin_print(id,"%L",id,"L_ADMIN_DROPPED_ITEM",PLUGIN_TAG,g_item_names[item]);
	}
	else
	{
		admin_item_list(id);
	}
}

//---------------------------------------------------------------------

public find_target( iLastID, szTarget[] )
{
	new iTarget = -1;

	if ( equali( szTarget, "@ALL" ) )
	{
		new players[32], iTotalPlayers, i;
		get_players( players, iTotalPlayers );
		
		for ( i = 0; i < iTotalPlayers; i++ )
		{
			if ( players[i] == iLastID && i + 1 != iTotalPlayers )
			{
				iTarget = players[i+1];
			}
		}

		if ( iTotalPlayers > 0 && iLastID == 0 )
		{
			iTarget = players[0];
		}
	}

	else if ( szTarget[0] == '@' )
	{
		new iTeam = -1;
		
		if ( equali( szTarget, "@T" ) )
		{
			iTeam = TEAM_T;
		}
		else if ( equali( szTarget, "@CT" ) )
		{
				iTeam = TEAM_CT;
		}

		if ( iTeam != -1 )
		{
			new players[32], iTotalPlayers, i, iFirstPlayer = -1, bool:bSaveNext = false;
			get_players( players, iTotalPlayers );

			for ( i = 0; i < iTotalPlayers; i++ )
			{			
				if ( iTeam == get_user_team( players[i] ) )
				{
					
					if ( bSaveNext )
					{
						iTarget = players[i];
						break;
					}

					if ( players[i] == iLastID )
					{
						bSaveNext = true;
					}
					
					if ( iFirstPlayer == -1 )
					{
						iFirstPlayer = players[i];
					}
				}
			}

			if ( iLastID == 0 )
			{
				iTarget = iFirstPlayer;
			}
		}
	}

	else
	{
		new iPlayer = find_player( "a", szTarget );
		
		if ( !iPlayer )
		{
			iPlayer = find_player( "bl", szTarget );

			if ( iPlayer )
			{

				if ( iPlayer != find_player( "blj", szTarget ) )
				{
					return -2;
				}
			}
		}

		if ( !iPlayer )
		{
			iPlayer = find_player( "c" , szTarget );
		}

		if ( !iPlayer )
		{
			if ( szTarget[0] == '#' && szTarget[1] )
			{
				iPlayer = find_player( "k", str_to_num( szTarget[1] ) );
			}
		}
		
		if ( iPlayer && iLastID != iPlayer )
		{
			iTarget = iPlayer;
		}
	}

	return iTarget;
}

public no_target_found(id,szTarget[],bool:multi)
{
	if(multi)
	{
		admin_print(id,"%L",id,"L_ADMIN_FIND_TARGETS",PLUGIN_TAG,szTarget);
	}
	else
	{
		admin_print(id,"%L",id,"L_ADMIN_NO_TARGET",PLUGIN_TAG,szTarget);
		admin_print(id,"%L",id,"L_ADMIN_AVAILABLE_TARGETS",PLUGIN_TAG);
	}
}


stock create_status_icon(id,status,sprite[],red,green,blue)
{
	message_begin(MSG_ONE,g_msg_status_icon,{0,0,0},id);
	write_byte(status);
	write_string(sprite);
	write_byte(red);
	write_byte(green);
	write_byte(blue);
	message_end();
}

stock create_death_msg(id,victim,headshot,weapon_name[])
{
	message_begin(MSG_ALL,g_msg_death_msg,{0,0,0},0);
	write_byte(id);
	write_byte(victim);
	write_byte(headshot);
	write_string(weapon_name);
	message_end();
}

stock create_te_sprite(origin[3],sprite,scale,alpha)
{
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_SPRITE);
	write_coord(origin[0]);
	write_coord(origin[1]);
	write_coord(origin[2]);
	write_short(sprite);
	write_byte(scale);
	write_byte(alpha);
	message_end() ;
}

stock create_te_spray(origin[3],direction[3],sprite,count,speed,noise,rendermode)
{
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_SPRAY);
	write_coord(origin[0]);
	write_coord(origin[1]);
	write_coord(origin[2]);
	write_coord(direction[0]);
	write_coord(direction[1]);
	write_coord(direction[2]);
	write_short(sprite);
	write_byte(count);
	write_byte(speed);
	write_byte(noise);
	write_byte(rendermode);
	message_end();
}

stock create_screen_fade(id,duration,holdtime,fadetype,red,green,blue,alpha)
{
	message_begin(MSG_ONE,g_msg_screen_fade,{0,0,0},id);
	write_short(duration);
	write_short(holdtime);
	write_short(fadetype);
	write_byte(red);
	write_byte(green);
	write_byte(blue);
	write_byte(alpha);
	message_end();
}

stock create_te_largefunnel(origin[3],sprite,flags)
{
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_LARGEFUNNEL);
	write_coord(origin[0]);
	write_coord(origin[1]);
	write_coord(origin[2]);
	write_short(sprite);
	write_short(flags);
	message_end();
}

stock create_te_beaments(start_entity,end_entity,sprite,frame_start,frame_rate,life,width,noise,red,green,blue,alpha,speed)
{
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_BEAMENTS);
	write_short(start_entity);
	write_short(end_entity);
	write_short(sprite);
	write_byte(frame_start);
	write_byte(frame_rate);
	write_byte(life);
	write_byte(width);
	write_byte(noise);
	write_byte(red);
	write_byte(green);
	write_byte(blue);
	write_byte(alpha);
	write_byte(speed);
	message_end();
}

stock create_te_beamtorus(origin[3],center[3],axis[3],sprite,frame_start,frame_rate,life,width,amplitude,red,green,blue,brightness,speed)
{
	message_begin(MSG_PAS,SVC_TEMPENTITY,origin);
	write_byte(TE_BEAMTORUS);
	write_coord(center[0]);
	write_coord(center[1]);
	write_coord(center[2]);
	write_coord(axis[0]);
	write_coord(axis[1]);
	write_coord(axis[2]);
	write_short(sprite);
	write_byte(frame_start);
	write_byte(frame_rate);
	write_byte(life);
	write_byte(width);
	write_byte(amplitude);
	write_byte(red);
	write_byte(green);
	write_byte(blue);
	write_byte(brightness);
	write_byte(speed);
	message_end();
}

stock create_te_beamcylinder(origin[3],center[3],axis[3],sprite,frame_start,frame_rate,life,width,amplitude,red,green,blue,brightness,speed)
{
	message_begin(MSG_PAS,SVC_TEMPENTITY,origin);
	write_byte(TE_BEAMCYLINDER);
	write_coord(center[0]);
	write_coord(center[1]);
	write_coord(center[2]);
	write_coord(axis[0]);
	write_coord(axis[1]);
	write_coord(axis[2]);
	write_short(sprite);
	write_byte(frame_start);
	write_byte(frame_rate);
	write_byte(life);
	write_byte(width);
	write_byte(amplitude);
	write_byte(red);
	write_byte(green);
	write_byte(blue);
	write_byte(brightness);
	write_byte(speed);
	message_end();
}

stock create_te_beampoint(start_entity,origin[3],sprite,frame_start,frame_rate,life,width,noise,red,green,blue,alpha,speed)
{
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_BEAMENTPOINT);
	write_short(start_entity);
	write_coord(origin[0]);
	write_coord(origin[1]);
	write_coord(origin[2]);
	write_short(sprite);
	write_byte(frame_start);
	write_byte(frame_rate);
	write_byte(life);
	write_byte(width);
	write_byte(noise);
	write_byte(red);
	write_byte(green);
	write_byte(blue);
	write_byte(alpha);
	write_byte(speed);
	message_end();
}

stock create_te_beampoints(origin_start[3],origin_end[3],sprite,frame_start,frame_rate,life,width,noise,red,green,blue,alpha,speed)
{
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_BEAMENTPOINTS);
	write_coord(origin_start[0]);
	write_coord(origin_start[1]);
	write_coord(origin_start[2]);
	write_coord(origin_end[0]);
	write_coord(origin_end[1]);
	write_coord(origin_end[2]);
	write_short(sprite);
	write_byte(frame_start);
	write_byte(frame_rate);
	write_byte(life);
	write_byte(width);
	write_byte(noise);
	write_byte(red);
	write_byte(green);
	write_byte(blue);
	write_byte(alpha);
	write_byte(speed);
	message_end();
}

stock create_te_spritetrail(origin_start[3],origin_end[3],sprite,count,life,scale,velocity,randomness)
{
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_SPRITETRAIL);
	write_coord(origin_start[0]);
	write_coord(origin_start[1]);
	write_coord(origin_start[2]);
	write_coord(origin_end[0]);
	write_coord(origin_end[1]);
	write_coord(origin_end[2]);
	write_short(sprite);
	write_byte(count);
	write_byte(life);
	write_byte(scale);
	write_byte(velocity);
	write_byte(randomness);
	message_end();
}

stock create_te_elight(entity,origin[3],radius,red,green,blue,life,decay_rate)
{
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_ELIGHT);
	write_short(entity);
	write_coord(origin[0]);
	write_coord(origin[1]);
	write_coord(origin[2]);
	write_coord(radius);
	write_byte(red);
	write_byte(green);
	write_byte(blue);
	write_byte(life);
	write_coord(decay_rate);
	message_end();
}

stock create_te_lightning(origin[3],origin2[3],life,width,amplitude,sprite)
{
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_LIGHTNING);
	write_coord(origin[0]);
	write_coord(origin[1]);
	write_coord(origin[2]);
	write_coord(origin2[0]);
	write_coord(origin2[1]);
	write_coord(origin2[2]);
	write_byte(life);
	write_byte(width);
	write_byte(amplitude);
	write_short(sprite);
	message_end();
}

stock create_te_smoke(origin[3],sprite,scale,frame_rate)
{
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_SMOKE);
	write_coord(origin[0]);
	write_coord(origin[1]);
	write_coord(origin[2]);
	write_short(sprite);
	write_byte(scale);
	write_byte(frame_rate);
	message_end();
}

stock create_screen_shake(id,amount,duration,frequency)
{
	message_begin(MSG_ONE,g_msg_screen_shake,{0,0,0},id);
	write_short(amount);
	write_short(duration);
	write_short(frequency);
	message_end();
}

stock create_te_explosion(origin[3],sprite,scale,frame_rate,flags)
{	
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_EXPLOSION);
	write_coord(origin[0]);
	write_coord(origin[1]);
	write_coord(origin[2]);
	write_short(sprite);
	write_byte(scale);
	write_byte(frame_rate);
	write_byte(flags);
	message_end();
}

stock create_te_tarexplosiom(origin[3])
{
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_TAREXPLOSION);
	write_coord(origin[0]);
	write_coord(origin[1]);
	write_coord(origin[2]);
	message_end();
}

stock create_te_spark(origin[3])
{
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_SPARKS);
	write_coord(origin[0]);
	write_coord(origin[1]);
	write_coord(origin[2]);
	message_end();
}

stock create_te_teleport(origin[3])
{
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_TELEPORT);
	write_coord(origin[0]);
	write_coord(origin[1]);
	write_coord(origin[2]);
	message_end();
}

stock create_te_gunshotdecal(origin[3],decal)
{
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_GUNSHOTDECAL);
	write_coord(origin[0]);
	write_coord(origin[1]);
	write_coord(origin[2]);
	write_short(0);
	write_byte (decal);
	message_end();
}

stock create_bartime(id,duration,flag)
{
	message_begin(MSG_ONE,g_msg_bartime,{0,0,0},id);
	write_byte(duration);
	write_byte(flag);
	message_end();
}

stock create_te_dlight(origin[3],radius,red,green,blue,life,decay_rate)
{
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_DLIGHT);
	write_coord(origin[0]);
	write_coord(origin[1]);
	write_coord(origin[2]);
	write_byte(radius);
	write_byte(red);
	write_byte(green);
	write_byte(blue);
	write_byte(life);
	write_byte(decay_rate);
	message_end();
}


public sqrt(num)
{
	new div = num;
	new result = 1;
	
	while (div > result)
	{
		div=(div + result)/2;
		result=num/div;
	}
	
	return div;
}

public random_chance(num,max)
{
	static rand;
	rand=random_num(0,max);
	
	if(num >= rand)
	{
		return true;
	}
	
	return false;
}

public buy_time_over()
{
	g_event_buy_time=false;
	if(task_exists (NARUTO_TASK_BUYTIME,0))
	{
		remove_task(NARUTO_TASK_BUYTIME);
	}
}

public get_cooldown(id,Float:cooldown,Float:last_used,notice)
{
	static Float:time;
	time=get_gametime();
	
	if(time-last_used < cooldown)
	{
		if(notice)
		{
			static time_left;
			time_left = floatround((last_used + cooldown) - time);
			
			if(time_left > 0)
			{
				print_hud_status(id,"%L",id,"L_STATUS_CAST_TIME",time_left);
			}
		}
		return true;
	}

	return false;
}

public remove_status_icon(id)
{
	if(!equal(g_player_statusicon[id],"") && is_user_connected(id))
	{
		create_status_icon(id,0,g_player_statusicon[id],0,0,0);
		g_player_statusicon[id]="";
	}
}

public drop_player_item(id)
{
	if(g_player_item[id] > 0)
	{
		item_reset(id);
		item_drop(id,g_player_item[id]);
		
		g_player_item[id]=0;
		
		print_hud_player(id);
	}
}

public reselect_skills(id)
{
	static money,cost;
	money = cs_get_user_money(id); 
	cost = NARUTO_RESKILL_COST*g_player_level[id];
	
	if(money < cost)
	{
		client_print(id,print_chat,"%L",id,"L_SKILL_MONEY_TO_RESTORE",PLUGIN_TAG,cost);
		return PLUGIN_CONTINUE;
	}
	
	client_print(id,print_chat,"%L",id,"L_SKILL_RESELECTED",PLUGIN_TAG);
	
	g_player_skillpoints[id]=g_player_level[id]*NARUTO_SP_PER_LEVEL;
	reset_player_skills(id);
	restore_cooldowns(id);
	menu_print_skills(id);
	print_hud_player(id);
	cs_set_user_money(id,money-cost,1);
	g_player_skill_reseted[id]=true;
	
	return PLUGIN_CONTINUE;
}

public check_target(id,target)
{
	if(pev_valid(target) && is_user_alive(target))
	{		
		if(get_user_team(id) == get_user_team(target))
		{
			print_hud_status(id,"%L",id,"L_STATUS_TARGET_TEAM");
			return true;
		}
		else if(get_entity_distance(id,target) > 850)
		{
			print_hud_status(id,"%L",id,"L_STATUS_TARGET_FA");
			return true;
		}
	}
	else
	{
		print_hud_status(id,"%L",id,"L_STATUS_NO_TARGET");
		return true;
	}
	
	return false;
}

public set_naruto_damage(id,victim,Float:damage)
{
	static Float:bonus_damage;
	
	if(!is_user_alive(victim))
	{
		return PLUGIN_HANDLED;
	}
	else if(random_chance(g_player_level[victim]*4,floatround(100+damage)))
	{
		print_hud_status(victim,"%L",victim,"L_STATUS_EVADED");
		return PLUGIN_HANDLED;
	}
	else if(g_player_spirit[victim] >= damage)
	{
		if(g_player_spirit_releasing[victim])
		{
			print_hud_status(victim,"%L",victim,"L_STATUS_NULLIFIED");
			return PLUGIN_HANDLED;
		}
		else if(random_chance(g_player_spirit[victim]-floatround(damage),g_player_spirit[id]))
		{
			print_hud_status(victim,"%L",victim,"L_STATUS_KNOCKED_DAMAGE");
			bonus_damage=0.5;
			spirit_set(victim,g_player_spirit[victim]-floatround(damage));
		}
		else
		{
			bonus_damage=0.9;
		}
	}
	else if(g_player_spirit[victim] < random_num(1,floatround(damage)))
	{
		print_hud_status(id,"%L",id,"L_STATUS_CRITICAL");
		bonus_damage=1.5;
	}
	else
	{
		bonus_damage=1.0;
	}
	
	if(damage*bonus_damage >= get_user_health(victim))
	{
		set_msg_block(g_msg_death_msg,BLOCK_ONCE);
		g_player_died_by_skill[victim]=true;
	}
	
	fakedamage(victim,"skill",damage*bonus_damage,GENERIC);
	skill_deathmsg(id,victim);
	
	return PLUGIN_CONTINUE;
}

public get_num_diff(num,num2)
{
	if(num > num2)
	{
		return (num-num2);
	}
	else
	{
		return (num2-num);
	}

	return 0;
}

public naruto_stop()
{
	buy_time_over();
	remove_task(NARUTO_TASK_SPIRIT);
	item_drop_remove();
	save_all_players();
	database_close();
	reset_player_all();
	set_pcvar_num(cvar_naruto,0);
	set_cvar_num("sv_restartround",1);
}

public naruto_start()
{
	set_pcvar_num(cvar_naruto,1);
	set_task(5.0,"spirit_regenerate",NARUTO_TASK_SPIRIT,"",0,"b");
	reset_player_all();
	database_init();
}

public validate_max_speed(id)
{
	if(g_event_freeze_time)
	{
		return PLUGIN_HANDLED;
	}
	else if(g_player_stunned[id] > 0 || g_player_cero_charged[id])
	{
		set_user_maxspeed(id,0.1);
	}
	else if(g_player_negating[id] || g_player_frozen[id])
	{
		if(g_player_negating[id])
		{
			client_cmd(id,"weapon_knife");
		}
		set_user_maxspeed(id,0.1);
	}
	else if(g_player_frosted[id] > 0)
	{
		switch(g_player_frosted[id])
		{
			case 1:
			{
				set_user_maxspeed(id,NARUTO_SKILL_NOVICE_FROSTED);
			}
			case 2:
			{
				set_user_maxspeed(id,NARUTO_SKILL_NORMAL_FROSTED);
			}
			case 3:
			{
				set_user_maxspeed(id,NARUTO_SKILL_GREATER_FROSTED);
			}
			case 4:
			{
				set_user_maxspeed(id,NARUTO_SKILL_MASTER_FROSTED);
			}
		}
	}
	else
	{
		new clip,ammo,Float:speed;
		new weapon = get_user_weapon(id,clip,ammo);
		
		if(cs_get_user_vip(id))
		{
			speed=g_cs_speed_vip;
		}
		else if(g_player_zoomed[id])
		{
			speed=g_cs_weapon_speed_zoom[weapon];
		}
		else
		{
			speed=g_cs_weapon_speed[weapon];
		}
		
		set_user_maxspeed(id,speed+g_player_athletic[id]);
	}
	
	return PLUGIN_CONTINUE;
}

public validate_gravity(id)
{
	new Float:gravity;
	gravity=g_player_acrobatic[id];
	
	if((g_player_item[id] == 3))
	{
		if((gravity >= 0.60))
		{
			set_user_gravity(id,gravity - 0.10);
		}
		else
		{
			set_user_gravity(id,0.50);
		}
	}
	else
	{
		set_user_gravity(id,gravity);
	}
}

public Float:radius_calucation(center_origin[3],origin[3],radius,Float:min_value,Float:max_value)
{
	static Float:percent,distance;
	
	distance = get_distance(center_origin,origin);

	if(distance < 40.0)
	{
		return max_value;
	}
	else
	{
		percent = 1.0 - (distance / radius);
	}

	return min_value + (percent * (max_value - min_value));
}

public random_target(id)
{
	new players[MAXPLAYERS];
	new victims[MAXPLAYERS+1], total_targets = 0;
	static num;
	
	get_players(players,num,"ah");
	for (new i = 0; i < num; i++ )
	{
		if (get_user_team(players[i]) != get_user_team(id))
		{
			victims[total_targets++] = players[i];
		}
	}
	
	if(total_targets == 0)
	{
		return -1;
	}

	new victim = 0, random_id;
	while (victim == 0)
	{
		random_id = random_num(0,total_targets);
		victim = victims[random_id];
	}

	return victim;
}

public reset_player(id)
{
	g_player_experience[id]=0;
	g_player_level[id]=NARUTO_START_LEVEL;
	g_player_attributepoints[id]=NARUTO_START_ATTRIBUTEPOINTS;
	g_player_skillpoints[id]=NARUTO_START_SKILLPOINTS;
	g_player_spirit[id]=NARUTO_START_SPIRIT_POWER;
	g_player_max_spirit[id]=NARUTO_MAXIMUM_SPIRIT_POWER+(g_player_level[id]*NARUTO_SPR_PER_LEVEL);
	g_player_current_skill[id]=0;
	
	g_player_class_selected[id]=false;
	g_player_skill_reseted[id]=false;
	g_player_negation_used[id]=false;
	
	g_player_max_health[id]=DEFAULT_MAX_HEALTH;
	g_player_max_armour[id]=DEFAULT_MAX_ARMOUR;
	
	item_reset(id);
	
	g_player_item[id]=0;
	
	if(cs_get_user_vip(id))
	{
		g_player_max_armour[id]+=100;
	}
}

public reset_player_attributes(id)
{
	g_player_athletic[id]=0.0;
	g_player_acrobatic[id]=1.0;
	g_player_endurance[id]=0;
}

public reset_player_skills(id)
{
	g_skill[id][P_SKILL_1]=0;
	g_skill[id][P_SKILL_2]=0;
	g_skill[id][P_SKILL_3]=0;
	g_skill[id][P_SKILL_4]=0;
	g_skill[id][P_SKILL_5]=0;
	g_skill[id][P_SKILL_6]=0;
}

public reset_player_all()
{
	new players[MAXPLAYERS],id;
	static num;
	get_players(players,num,"ch");
	
	if(!g_event_round_end)
	{
		set_cvar_num("sv_restart",2);
	}
	
	for (new i; i < num; ++i)
	{
		id=players[i];
		if(is_user_connected(id))
		{
			reset_player(id);
			reset_player_attributes(id);
			reset_player_skills(id);
			restore_cooldowns(id);
			restore_player(id);
			g_player_class[id]=0;
			g_player_character_reseted[id]=false;
		}
	}
}

public restore_player(id)
{
	g_player_frozen[id]=false;
	g_player_burning[id]=false;
	g_player_negating[id]=false;
	g_player_cero_charged[id]=false;
	g_player_spirit_releasing[id]=false;
	g_player_in_skill[id]=false;
	g_player_died_by_skill[id]=false;
	g_player_use[id]=false;
	
	g_player_stunned[id]=0;
	g_player_frosted[id]=0;
	g_player_death_stinged[id]=0;
	g_player_volcanic_flame[id]=0;
}

public restore_cooldowns(id)
{
	static Float:time;
	time=get_gametime();
	
	g_player_last_event[id][0]=time;
	g_player_last_event[id][1]=time;
	g_player_last_event[id][2]=time;
	g_player_last_event[id][3]=time;
	g_player_last_event[id][4]=time;
	g_player_last_event[id][5]=time;
}


public vault_save(id)
{
	new vault,vkey[128],vdata[1024],authid[33];
	
	vault = nvault_open(PLUGIN_VAULT);
	
	if(vault == INVALID_HANDLE) 
	{
		server_print("nVault returned invalid handle.");
		return PLUGIN_CONTINUE;
	}
	
	get_user_authid(id,authid,32); 
	
	format(vdata,1023,
	"%d %d %d %d %d %f %f %d %d %d %d %d %d %d",
	g_player_experience[id],
	g_player_level[id],
	g_player_attributepoints[id],
	g_player_skillpoints[id],
	g_player_spirit[id],
	g_player_athletic[id],
	g_player_acrobatic[id],
	g_player_endurance[id],
	g_skill[id][P_SKILL_1],
	g_skill[id][P_SKILL_2],
	g_skill[id][P_SKILL_3],
	g_skill[id][P_SKILL_4],
	g_skill[id][P_SKILL_5],
	g_skill[id][P_SKILL_6]);
	
	format(vkey,127,"%s-%s",authid,g_player_class[id]);
	
	nvault_set(vault,vkey,vdata);
	nvault_close(vault);
	
	return PLUGIN_CONTINUE;
}

public vault_load(id)
{
	new vault,vkey[128],vdata[1024],authid[33],vault_check;
	
	vault = nvault_open(PLUGIN_VAULT);
	
	if(vault == INVALID_HANDLE)
	{
		server_print("nVault returned invalid handle.");
		return PLUGIN_CONTINUE;
	}
	
	get_user_authid(id,authid,32);
	
	format(vkey,127,"%s-%s",authid,g_player_class[id]);
	vault_check=nvault_get(vault,vkey,vdata,1023);
	nvault_close(vault);
	
	if(vault_check)
	{
		static data_xp[8],
		data_lvl[8],
		data_ap[8],
		data_sp[8],
		data_spirit[8],
		data_athletic[8],
		data_acrobatic[8],
		data_endurance[8],
		data_skill_1[8],
		data_skill_2[8],
		data_skill_3[8],
		data_skill_4[8],
		data_skill_5[8],
		data_skill_6[8];
		
		parse(vdata,
		data_xp,7,
		data_lvl,7,
		data_ap,7,
		data_sp,7,
		data_spirit,7,
		data_athletic,7,
		data_acrobatic,7,
		data_endurance,7,
		data_skill_1,7,
		data_skill_2,7,
		data_skill_3,7,
		data_skill_4,7,
		data_skill_5,7,
		data_skill_6,7);
		
		g_player_experience[id]=str_to_num(data_xp);
		g_player_level[id]=str_to_num(data_lvl);
		g_player_attributepoints[id]=str_to_num(data_ap);
		g_player_skillpoints[id]=str_to_num(data_sp);
		g_player_spirit[id]=str_to_num(data_spirit);
		
		g_player_athletic[id]=str_to_float(data_athletic);
		g_player_acrobatic[id]=str_to_float(data_acrobatic);
		g_player_endurance[id]=str_to_num(data_endurance);
		
		g_skill[id][P_SKILL_1]=str_to_num(data_skill_1);
		g_skill[id][P_SKILL_2]=str_to_num(data_skill_2);
		g_skill[id][P_SKILL_3]=str_to_num(data_skill_3);
		g_skill[id][P_SKILL_4]=str_to_num(data_skill_4);
		g_skill[id][P_SKILL_5]=str_to_num(data_skill_5);
		g_skill[id][P_SKILL_6]=str_to_num(data_skill_6);
	}
	else
	{
		reset_player(id);
		reset_player_attributes(id);
		reset_player_skills(id);
		restore_cooldowns(id);
		restore_player(id);
	}
	
	return PLUGIN_CONTINUE;
}


public skill_active_check(id,skill_level,skill_cost,skill_class)
{		
	static bool:skill_class_all;
	
	if(skill_class == 0)
	{
		skill_class_all=true;
	}
	else
	{
		skill_class_all=false;
	}
	
	if(skill_level == 0)
	{
		print_hud_status(id,"%L",id,"L_STATUS_SKILL_NOT");
	}
	else if(g_player_class[id] != skill_class && !skill_class_all)
	{
		print_hud_status(id,"%L",id,"L_STATUS_SKILL_REQ");
	}
	else if(g_player_spirit[id] < skill_cost)
	{
		print_hud_status(id,"%L",id,"L_STATUS_SKILL_SPIRIT");
	}
	else if(g_player_in_skill[id])
	{
		print_hud_status(id,"%L",id,"L_STATUS_SKILL_CAST");
	}
	else if(g_event_freeze_time)
	{
		print_hud_status(id,"%L",id,"L_STATUS_SKILL_FT");
	}
	else
	{
		return true;
	}
	
	return false;
}

public skill_passive_check(id,skill_level,skill_cost,skill_class,skill_chance)
{
	if((skill_level > 0) && (g_player_spirit[id] >= skill_cost) && (g_player_class[id] == skill_class) && (!g_event_freeze_time))
	{
		if(random_chance(skill_chance,100))
		{
			return true;
		}
	}
	
	return false;
}

public skill_passive(id,victim,type,damage,weapon,hitplace,ta)
{
	switch(type)
	{
		case 0:
		{
			if(skill_passive_check(id,g_skill[id][P_SKILL_1],1,CLASS_HOLLOW,NARUTO_SKILL_NOVICE_CHANCE*g_skill[id][P_SKILL_1]))
			{
				skill_devour_soul(id,victim);
			}
		}
		case 1:
		{
			if(skill_passive_check(id,g_skill[id][P_SKILL_2],5,CLASS_DEATHGOD,NARUTO_SKILL_NOVICE_CHANCE*g_skill[id][P_SKILL_2]))
			{
				skill_shine_brightly(id,victim);
			}
			
			if(skill_passive_check(victim,g_skill[victim][P_SKILL_3],10,CLASS_HOLLOW,NARUTO_SKILL_NORMAL_CHANCE*g_skill[victim][P_SKILL_3]))
			{
				skill_negation(id,victim);
			}
			
			if(skill_passive_check(victim,g_skill[id][P_SKILL_4],15,CLASS_DEATHGOD,NARUTO_SKILL_NOVICE_CHANCE*g_skill[id][P_SKILL_4]))
			{
				skill_restrain(id,victim,hitplace);
			}

			if(skill_passive_check(victim,g_skill[victim][P_SKILL_5],15,CLASS_HOLLOW,NARUTO_SKILL_GREATER_CHANCE*g_skill[victim][P_SKILL_5]))
			{
				skill_steel_skin(id,victim,damage,weapon,hitplace);
			}
			
			if(skill_passive_check(victim,g_skill[id][P_SKILL_6],15,CLASS_DEATHGOD,NARUTO_SKILL_GREATER_CHANCE*g_skill[id][P_SKILL_6]))
			{
				skill_death_sting(id,victim,weapon,hitplace);
			}
		}
	}
	
	return PLUGIN_CONTINUE;
}

public skill_select_check(id,skill,req_level,max_level)
{
	if(g_player_level[id] < req_level)
	{
		client_print(id,print_chat,"%L",id,"L_SKILL_REQ",PLUGIN_TAG,req_level);
	}
	else if(skill == max_level)
	{
		client_print(id,print_chat,"%L",id,"L_SKILL_MAX",PLUGIN_TAG,max_level);
	}
	else
	{
		return true;
	}
	
	return false;
}

public skill_deathmsg(id,victim)
{
	if(!is_user_alive(victim))
	{
		static frags;
		
		create_death_msg(id,victim,0,"skill");
			
		frags=get_user_frags(id)+1;
		set_user_frags(id,frags);
		
		if(id!=victim)
		{
			static xp;
			xp=xp_get(get_pcvar_num(cvar_xp_skill));
			
			client_print(id,print_chat,"%L",id,"L_XP_SKILL",PLUGIN_TAG,xp);
			xp_set(id,g_player_experience[id]+xp);
		}
	}
}


public database_error(Handle:query)
{
	SQL_QueryError(query,g_sql_error,255);
	server_print("[DB - query]: %s",g_sql_string);
	server_print("[DB - error]: %s",g_sql_error);
}

public database_init()
{
	if(g_database_initialized) return PLUGIN_CONTINUE;
	
	if(get_pcvar_num(cvar_savexp) == 2)
	{
		get_pcvar_string(cvar_sql_table,g_sql_table,63);
		switch(get_pcvar_num(cvar_sql_type))
		{
			case DB_MYSQL:	mysql_init();
			case DB_SQLITE:	sqlite_init();
		}
		
		g_database_initialized=true;
	}
	
	return PLUGIN_CONTINUE;
}

public database_close()
{
	if(!g_database_initialized) return PLUGIN_CONTINUE;
	else
	{
		g_database_initialized=false;
	}
	
	switch(get_pcvar_num(cvar_sql_type))
	{
		case DB_MYSQL:	mysql_close();
		case DB_SQLITE:	mysql_close();
	}
	
	return PLUGIN_CONTINUE;
}

public database_save(id)
{
	if(!g_database_initialized) return PLUGIN_CONTINUE;
	
	switch(get_pcvar_num(cvar_sql_type))
	{
		case DB_MYSQL:	mysql_save(id);
		case DB_SQLITE:	mysql_save(id);
	}
	
	return PLUGIN_CONTINUE;
}

public database_load(id)
{
	if(!g_database_initialized) return PLUGIN_CONTINUE;
	
	switch(get_pcvar_num(cvar_sql_type))
	{
		case DB_MYSQL:	mysql_load(id);
		case DB_SQLITE:	mysql_load(id);
	}
	
	return PLUGIN_CONTINUE;
}

public database_truncate()
{
	if(!g_database_initialized) return PLUGIN_CONTINUE;
	
	switch(get_pcvar_num(cvar_sql_type))
	{
		case DB_MYSQL:	mysql_truncate();
		case DB_SQLITE:	mysql_truncate();
	}
	
	return PLUGIN_CONTINUE;
}

//---------------------------------------------------------------------

public save_player(id)
{
	if(g_player_class[id] == 0 ||  is_user_bot(id)) return PLUGIN_CONTINUE;
	

	switch(get_pcvar_num(cvar_savexp))
	{
		case SAVE_VAULT:	vault_save(id);
		case SAVE_DB:		database_save(id);
	}

	return PLUGIN_CONTINUE;
}

public load_player(id)
{
	if(is_user_bot(id)) return PLUGIN_CONTINUE;
	
	switch(get_pcvar_num(cvar_savexp))
	{
		case SAVE_VAULT:	vault_load(id);
		case SAVE_DB:		database_load(id);
	}
	
	return PLUGIN_CONTINUE;
}

public save_all_players()
{
	if(get_pcvar_num(cvar_savexp) == 0) return PLUGIN_CONTINUE;
	
	new players[MAXPLAYERS];
	static num;
	
	get_players(players,num,"ch");
	for (new i; i < num; ++i)
	{
		save_player(players[i]);
	}
	
	return PLUGIN_CONTINUE;
}


public menu_print_main(id)
{
	new menu_body[256];
	format(menu_body,255,"%L",id,"L_MENU_MAIN_BODY");
	show_menu(id,KEYS,menu_body,-1,"menu_main");
	
	return PLUGIN_CONTINUE;
}

public menu_print_next(id)
{
	new menu_body[256];
	format(menu_body,255,"%L",id,"L_MENU_MAIN2_BODY");
	show_menu(id,KEYS,menu_body,-1,"menu_next");
	
	return PLUGIN_CONTINUE;
}

public menu_print_information(id)
{
	new menu_body[256];
	format(menu_body,255,"%L",id,"L_MENU_INFO_BODY");
	show_menu(id,KEYS,menu_body,-1,"menu_info");
	
	return PLUGIN_CONTINUE;
}

public menu_print_classes(id)
{
	if(g_player_class_selected[id])
	{
		client_print(id,print_chat,"%L",id,"L_CLASS_SELECTE_ONCE",PLUGIN_TAG);
		return PLUGIN_HANDLED;
	}
	
	save_player(id);
		
	new menu_body[256];
	format(menu_body,255,"%L",id,"L_MENU_CLASS_BODY");
	show_menu(id,KEYS,menu_body,-1,"menu_classes");
	
	return PLUGIN_CONTINUE;
}

public menu_print_attributes(id)
{
	new menu_body[1024];
	
	if(g_player_class[id] == 0)
	{
		client_print(id,print_chat,"%L",id,"L_ATTR_MUST_SELECT_CLASS",PLUGIN_TAG);
		return PLUGIN_HANDLED;
	}
	else
	{
		format(menu_body,1023,"%L",id,"L_MENU_ATTRIBUTE_BODY",
		g_player_athletic[id],
		g_player_acrobatic[id],
		g_player_endurance[id]);
		
		show_menu(id,KEYS,menu_body,-1,"menu_attributes");
	}

	print_hud_player(id);
	
	return PLUGIN_CONTINUE;
}

public menu_print_skills(id)
{
	new menu_body[1024];
	
	if(g_player_class[id] == 0)
	{
		client_print(id,print_chat,"%L",id,"L_SKILL_MUST_SELECT_CLASS",PLUGIN_TAG);
		return PLUGIN_HANDLED;
	}
	else if(g_player_class[id] == 1)
	{
		format(menu_body,1023,"%L",id,"L_MENU_SKILL_BODY_1",
		g_skill[id][P_SKILL_1],
		g_skill[id][P_SKILL_2],
		g_skill[id][P_SKILL_3],
		g_skill[id][P_SKILL_4],
		g_skill[id][P_SKILL_5],
		g_skill[id][P_SKILL_6]);
		
		show_menu(id,KEYS,menu_body,-1,"menu_skills");
	}
	else
	{
		format(menu_body,1023,"%L",id,"L_MENU_SKILL_BODY_2",
		g_skill[id][P_SKILL_1],
		g_skill[id][P_SKILL_2],
		g_skill[id][P_SKILL_3],
		g_skill[id][P_SKILL_4],
		g_skill[id][P_SKILL_5],
		g_skill[id][P_SKILL_6]);
		
		show_menu(id,KEYS,menu_body,-1,"menu_skills");
	}
	
	print_hud_player(id);
	
	return PLUGIN_CONTINUE;
}

public menu_print_items(id)
{
	new menu_body[1024];
	
	if(g_player_class[id] == 0)
	{
		client_print(id,print_chat,"%L",id,"L_ITEM_MUST_SELECT_CLASS",PLUGIN_TAG);
		return PLUGIN_HANDLED;
	}
	else
	{
		format(menu_body,1023,"%L",id,"L_MENU_ITEM_BODY",
		NARUTO_ITEM_1_COST,
		NARUTO_ITEM_2_COST,
		NARUTO_ITEM_3_COST);
		
		show_menu(id,KEYS,menu_body,-1,"menu_items");
	}

	print_hud_player(id);
	
	return PLUGIN_CONTINUE;
}


public item_check(id,cost)
{
	if(!is_user_alive(id))
	{
		client_print(id,print_chat,"%L",id,"L_ITEM_B_ALIVE",PLUGIN_TAG);
	}
	else if(!cs_get_user_buyzone(id))
	{
		client_print(id,print_chat,"%L",id,"L_ITEM_B_ZONE",PLUGIN_TAG);
	}
	else if(!g_event_buy_time)
	{
		client_print(id,print_chat,"%L",id,"L_ITEM_B_TIME",PLUGIN_TAG);
	}
	else if(cs_get_user_money(id) <= cost)
	{
		client_print(id,print_chat,"%L",id,"L_ITEM_NOT_ENOUGH",PLUGIN_TAG);
	}
	else if(g_player_item[id] > 0)
	{
		client_print(id,print_chat,"%L",id,"L_ITEM_HAVE",PLUGIN_TAG);
	}
	else
	{
		return true;
	}
	
	return false;
}

public item_use(id)
{
	if(g_player_item_in_use[id])
	{
		print_hud_status(id,"%L",id,"L_STATUS_ITEM_IN_USE");
		return PLUGIN_CONTINUE;
	}
	else if(g_event_freeze_time || g_event_round_end)
	{
		client_print(id,print_chat,"%L",id,"L_ITEM_BLOCK_USE",PLUGIN_TAG);
		return PLUGIN_CONTINUE;
	}
	
	switch(g_player_item[id])
	{
		case 1:
		{
			item_gigai(id);
		}
		case 2:
		{
			item_injection(id);
		}
	}
	print_hud_player(id);
	
	return PLUGIN_CONTINUE;
}

public item_passive(id)
{
	switch(g_player_item[id])
	{
		case 3:
		{
			validate_gravity(id);
		}
	}
	
	return PLUGIN_CONTINUE;
}

public item_reset(id)
{
	switch(g_player_item[id])
	{
		case 1:
		{
			item_gigai_remove(id);
		}
		case 3:
		{
			item_mantle_reset(id);
		}
	}
	
	g_player_item_in_use[id]=false;
}


public skill_cero_discharge(parm[1])
{
	static id;
	id=parm[0];

	g_player_cero_charged[id]=false;
	set_user_rendering(id);
	print_hud_status(id,"%L",id,"L_STATUS_SKILL_CERO_DISCHARGED");
}

public skill_cero(id)
{	
	static task,parm[1];
	
	task = NARUTO_TASK_CERO + id;
	remove_task(task,0);
	
	g_player_last_event[id][4]=get_gametime();
	g_player_cero_charged[id]=true;
	validate_max_speed(id);
	
	set_user_rendering(id,kRenderFxGlowShell,255,0,0,kRenderNormal,50); 
	
	parm[0] = id;
	
	set_task(NARUTO_SKILL_CERO_DISCHARGE_TIME,"skill_cero_discharge",task,parm,1);
	create_bartime(id,2,0);
	
	return PLUGIN_HANDLED;
}

public skill_cero_fire(id)
{
	new players[MAXPLAYERS],origin_victim[3],distance,Float:damage;
	static origin[3],radius,num;
	radius=300;
	
	get_user_origin(id,origin,3);
	
	create_te_beampoint(id,origin,g_sprite_beam,1,5,4,250,0,255,0,0,100,200);
	create_te_beampoint(id,origin,g_sprite_beam,1,5,4,125,0,255,255,255,255,200);
	
	emit_sound(id,CHAN_STATIC,g_sound[NARUTO_SOUND_CERO],VOL_NORM,ATTN_NORM,0,PITCH_NORM);
	
	create_te_explosion(origin,g_sprite_explosion,40,30,TE_EXPLFLAG_NONE);
	create_te_tarexplosiom(origin);
	create_te_gunshotdecal(origin,28);
	
	get_players(players,num,"ah");
	for(new i = 0; i < num; i++)
	{
		if(get_user_team(id)==get_user_team(players[i]) && id!=players[i])
		{
			continue;
		}
		
		get_user_origin(players[i],origin_victim);
		distance = get_distance(origin,origin_victim);
		
		if(distance < radius)
		{
			damage=radius_calucation(origin,origin_victim,radius,NARUTO_SKILL_MASTER_DAMAGE/2,NARUTO_SKILL_MASTER_DAMAGE*g_skill[id][P_SKILL_4]);
			set_naruto_damage(id,players[i],damage);
		}            
	}
	
	return PLUGIN_CONTINUE;
}

public skill_cero_activate(id)
{
	static Float:time;
	time=get_gametime();
	
	if (time >= g_player_last_event[id][4]+NARUTO_SKILL_CERO_CHARGE_TIME && g_player_cero_charged[id] && is_user_alive(id) && !g_player_in_skill[id])
	{
		skill_cero_fire(id);
		g_player_last_event[id][2]=time;
		spirit_set(id,g_player_spirit[id]-NARUTO_SKILL_MASTER_COST);
	}
	
	remove_task(NARUTO_TASK_CERO + id,0);
	set_user_rendering(id);
	create_bartime(id,0,0);
	g_player_cero_charged[id]=false;
	validate_max_speed(id);
	
	return PLUGIN_HANDLED;
}


public skill_cherry_blossoms(id)
{
	new victim = random_target(id);

	if (victim == -1)
	{
		print_hud_status(id,"%L",id,"L_STATUS_NO_TARGETS");
		return PLUGIN_HANDLED;
	}

	static origin[3],parm[10];
	get_user_origin(id,origin);
	
	parm[0] = id;
	parm[1] = victim;
	parm[2] = origin[0];
	parm[3] = origin[1];
	parm[4] = origin[2];

	skill_cherry_blossoms_effect(parm);

	return PLUGIN_HANDLED;
}

public skill_cherry_blossoms_effect(parm[])
{
	new attacker = parm[0];
	new victim = parm[1];

	if (!is_user_alive(victim))
	{
		new victim = random_target(attacker);

		if (victim == -1)
		{
			print_hud_status(attacker,"%L",attacker,"L_STATUS_NO_TARGETS");
			return PLUGIN_HANDLED;
		}

		static origin[3];
		get_user_origin(attacker,origin);
		parm[1] = victim;
		parm[2] = origin[0];
		parm[3] = origin[1];
		parm[4] = origin[2];

		client_print(attacker,print_chat,"%L",attacker,"L_SKILL_CB_TARGETABLE",PLUGIN_TAG);
		
		return PLUGIN_HANDLED;
	}

	new multiplier = 150;

	new victim_origin[3], funnel[3];
	get_user_origin(victim,victim_origin);

	funnel[0] = parm[2];
	funnel[1] = parm[3];
	funnel[2] = parm[4];
	
	create_te_largefunnel(funnel,g_sprite_pflare,random_num(0,1));
	
	static dist[3];
	dist[0] = get_num_diff(victim_origin[0],funnel[0]);
	dist[1] = get_num_diff(victim_origin[1],funnel[1]);
	dist[2] = get_num_diff(victim_origin[2],funnel[2]);	
	
	for (new i = 0; i < 3; i++)
	{
		
		if(get_num_diff(victim_origin[i],funnel[i] - multiplier) < dist[i])
		{
			funnel[i] -= multiplier;
		}
		else if (get_num_diff(victim_origin[i],funnel[0] + multiplier) < dist[i])
		{
			funnel[i] += multiplier;
		}
		else
		{
			funnel[i] = victim_origin[i];
		}
	}

	parm[2] = funnel[0];
	parm[3] = funnel[1];
	parm[4] = funnel[2];

	if (!(dist[0] < 50 && dist[1] < 50 && dist[2] < 50))
	{
		static Float:time;
		time = 0.2;
		
		set_task(time,"skill_cherry_blossoms_effect",attacker + NARUTO_TASK_BLOSSOMS,parm,5);
	}
	else
	{
		new players[32],origin_victim[3],distance,Float:damage;
		static radius,num;
		radius = 75;
		
		get_players(players,num,"ah");
		for(new i = 0; i < num; i++)
		{
			if(get_user_team(attacker)==get_user_team(players[i]) && attacker==players[i])
			{
				continue;
			}
			
			get_user_origin(players[i],origin_victim);
			distance = get_entity_distance(victim,players[i]);
			
			if(distance < radius)
			{
				damage=radius_calucation(funnel,origin_victim,radius,NARUTO_SKILL_MASTER_DAMAGE/2,NARUTO_SKILL_MASTER_DAMAGE*g_skill[attacker][P_SKILL_5]);
				set_naruto_damage(attacker,players[i],damage);
				create_screen_fade(players[i],(1<<10),(1<<10),(1<<12),255,156,255,floatround(damage));
			}
		}
		
		g_player_last_event[attacker][0]=get_gametime();
		spirit_set(attacker,g_player_spirit[attacker]-NARUTO_SKILL_MASTER_COST);
	}
	
	return PLUGIN_CONTINUE;
}


public skill_hollow_bullet(id,target,origin[3],aim_origin[3])
{
	static Float:damage;

	create_te_spritetrail(origin,aim_origin,g_sprite_gwave,10,10,5,2,6);
	create_te_smoke(aim_origin,g_sprite_smoke,22,10);
	damage=NARUTO_SKILL_NOVICE_DAMAGE*(g_skill[id][P_SKILL_2]/random_num(2,5));
	set_naruto_damage(id,target,damage);
	
	return PLUGIN_HANDLED;
}


public skill_icering_reset(parm[1])
{
	static id;
	id=parm[0];
	
	create_screen_fade(id,0,0,0,0,0,0,0);
	remove_status_icon(id);
	g_player_in_skill[id] = false;
	g_player_frozen[id]=false;
	g_player_frosted[id]=0;
	validate_max_speed(id);
	set_user_rendering(id);
}

public skill_ice_ring(id)
{
	new players[MAXPLAYERS],victim,origin_victim[3],distance,Float:damage,life;
	static origin[3],center[3],axis[3],num,radius;
	
	radius=120+g_skill[id][P_SKILL_3]*15;

	get_user_origin(id,origin);
	
	center[0]=origin[0];
	center[1]=origin[1];
	center[2]=origin[2]-16;
	
	axis[0]=origin[0]+radius/3;
	axis[1]=origin[1]+radius/3;
	axis[2]=origin[2]+300;
	
	life=floatround(g_skill[id][P_SKILL_3]/3.0);
	create_te_beamcylinder(origin,center,axis,g_sprite_shockwave,0,0,3+life,60,0,0,206,209,100,0);

	life=floatround(g_skill[id][P_SKILL_3]/1.5);
	create_te_beamcylinder(origin,center,axis,g_sprite_streak,0,0,3+life,40,0,0,206,209,100,0);
	
	create_te_dlight(origin,radius/5,0,206,209,8,60);
	
	emit_sound(id,CHAN_STATIC,g_sound[NARUTO_SOUND_IRING],VOL_NORM,ATTN_NORM,0,PITCH_NORM);
	
	get_players(players,num,"ah");
	for(new i = 0; i < num; i++)
	{
		victim = players[i];
		if(get_user_team(id) == get_user_team(victim))
		{
			continue;
		}
		
		get_user_origin(victim,origin_victim);
		distance = get_distance(origin,origin_victim);
		
		if(distance < radius)
		{
			new task,parm[1];
			
			task = NARUTO_TASK_IRING + victim;
			remove_task(task,0);
			
			parm[0] = victim;
			
			remove_status_icon(victim);
			g_player_statusicon[victim]="dmg_cold";
			create_status_icon(victim,2,g_player_statusicon[victim],0,206,209);
			
			g_player_in_skill[victim] = true;
			
			if(random_chance(50,100))
			{
				g_player_frozen[victim]=true;
				set_user_rendering(victim,kRenderFxNone,0,206,209,kRenderTransAdd,128);
				create_screen_fade(victim,~0,~0,0x0004,0,206,209,100);
	
				static time;
				time=floatround(NARUTO_SKILL_GREATER_FR_TIME*10);
				create_te_elight(id,origin_victim,30,0,206,209,time,10);
			}
			else
			{
				set_user_rendering(victim,kRenderFxGlowShell,0,206,209,kRenderNormal,50); 
				create_screen_fade(victim,~0,~0,0x0004,0,206,209,50);
				g_player_frosted[victim]=3;
			}
			
			damage=radius_calucation(origin,origin_victim,radius,NARUTO_SKILL_GREATER_DAMAGE/2,NARUTO_SKILL_GREATER_DAMAGE*g_skill[id][P_SKILL_3]);
			set_naruto_damage(id,victim,damage);
			
			validate_max_speed(victim);
			set_task(NARUTO_SKILL_GREATER_FR_TIME,"skill_icering_reset",task,parm,1);
		}            
	}
	
	return PLUGIN_CONTINUE;
}


public skill_spirit_release_reset(id)
{
	static task;
	task = NARUTO_TASK_SPIRITRELEASE + id;
	remove_task(task,0);
	
	g_player_spirit_releasing[id]=false;
	
	return PLUGIN_HANDLED;
}

public skill_spirit_release_start(id)
{
	static task;
	task = NARUTO_TASK_SPIRITRELEASE + id;
	remove_task(task,0);
	
	new parm_spirit[2];
	parm_spirit[0] = id;

	set_task(0.2,"skill_spirit_release",task,parm_spirit,1,"b");
	
	return PLUGIN_HANDLED;
}

public skill_spirit_release(parm_spirit[1])
{
	static id,button;
	id=parm_spirit[0];
	
	button=pev(id,pev_button);

	if(g_player_spirit[id] < NARUTO_SKILL_NOVICE_COST)
	{
		skill_spirit_release_reset(id);
		return PLUGIN_HANDLED;
	}
	else if((button & IN_FORWARD) || (button & IN_BACK) || (button &  IN_MOVELEFT) || (button & IN_MOVERIGHT))
	{
		print_hud_status(id,"%L",id,"L_STATUS_SKILL_SR_CONCENTRATE");
		skill_spirit_release_reset(id);
		return PLUGIN_HANDLED;
	}
	else
	{
		spirit_set(id,g_player_spirit[id]-NARUTO_SKILL_NOVICE_COST);
		g_player_spirit_releasing[id]=true;
	}
	

	g_player_spirit_releasing[id]=true;
		
	new players[32],origin_victim[3],distance;
	new center[3],axis[3];
	static origin[3],num,radius;
		
	radius=40*g_player_level[id];
		
	get_players(players,num,"a");
	get_user_origin(id,origin);
		
	center[0]=origin[0];
	center[1]=origin[1];
	center[2]=origin[2]-25;
		
	axis[0]=origin[0];
	axis[1]=origin[1];
	axis[2]=origin[2]+10;
		
	for (new i = 0; i < 300; i += 10)
	{
		create_te_beamtorus(origin,center,axis,g_sprite_shockwave,0,0,3,60,1,50,50,random_num(50,150),255,0);	
		center[2]+=10;
	}
		
	for(new i = 0; i < num; i++)
	{
		if(get_user_team(id)==get_user_team(players[i]))
		{
			continue;
		}
			
		get_user_origin(players[i],origin_victim);
		distance = get_distance(origin,origin_victim);
		    
		if(distance < radius && random_chance(g_player_level[id],g_player_level[players[i]]*10))
		{
			create_screen_shake(players[i],(255<<14),(10<<14),(255<<14));
			create_screen_fade(players[i],(1<<10),(1<<10),(1<<12),0,0,0,200);
		}            
	}

	return PLUGIN_HANDLED;
}


public skill_volcanic_flame(id)
{
	new vec[3],aim_vec[3],velocity_vec[3];
	static length,speed0;
	
	get_user_origin(id,vec);
	get_user_origin(id,aim_vec,2);
	
	new dist = get_distance(vec,aim_vec);

	new speed1 = 160;
	new speed2 = 350;
	new radius = 105;

	if(dist < 50)
	{
		radius = 0;
		speed0 = 5;
	}
	else if(dist < 150)
	{
		speed1 = speed2 = 1;
		speed0 = 5;
		radius = 50;
	}
	else if(dist < 200)
	{
		speed1 = speed2 = 1;
		speed0 = 5;
		radius = 90;
	}
	else if(dist < 250)
	{
		speed1 = speed2 = 90;
		speed0 = 6;
		radius = 90;
	}
	else if(dist < 300)
	{
		speed1 = speed2 = 140;
		speed0 = 7;
	}
	else if(dist < 350)
	{
		speed1 = speed2 = 190;
		speed0 = 7;
	}
	else if(dist < 400)
	{
		speed1 = 150;
		speed2 = 240;
		speed0 = 8;
	}
	else if(dist < 450)
	{
		speed1 = 150;
		speed2 = 290;
		speed0 = 8;
	}
	else if(dist < 500)
	{
		speed1 = 180;
		speed2 = 340;
		speed0 = 9;
	}
	
	velocity_vec[0]=aim_vec[0]-vec[0];
	velocity_vec[1]=aim_vec[1]-vec[1];
	velocity_vec[2]=aim_vec[2]-vec[2];
	
	length=sqrt(velocity_vec[0]*velocity_vec[0]+velocity_vec[1]*velocity_vec[1]+velocity_vec[2]*velocity_vec[2]);
	
	velocity_vec[0]=velocity_vec[0]*speed0/length;
	velocity_vec[1]=velocity_vec[1]*speed0/length;
	velocity_vec[2]=velocity_vec[2]*speed0/length;

	static parm_flame[6];
	
	parm_flame[0] = vec[0];
	parm_flame[1] = vec[1];
	parm_flame[2] = vec[2];
	
	parm_flame[3] = velocity_vec[0];
	parm_flame[4] = velocity_vec[1];
	parm_flame[5] = velocity_vec[2];
	
	set_task(0.1,"skill_vf_fire",0,parm_flame,6,"a",3);
	
	skill_vf_burnzone(id,vec,aim_vec,speed1,speed2,radius);
	
	return PLUGIN_HANDLED;
}

public skill_vf_fire(parm_flame[6])
{
	static vec[3],velocity_vec[3];
	
	vec[0]=parm_flame[0];
	vec[1]=parm_flame[1];
	vec[2]=parm_flame[2];
	
	velocity_vec[0]=parm_flame[3];
	velocity_vec[1]=parm_flame[4];
	velocity_vec[2]=parm_flame[5];
	
	create_te_spray(vec,velocity_vec,g_sprite_explosion,8,70,100,5);
}

public skill_vf_burnzone(id,vec[3],aim_vec[3],speed1,speed2,radius)
{
	new players[MAXPLAYERS],origin[3],burn_vec1[3],burn_vec2[3];
	static num,length,target,body_part;
	
	burn_vec1[0]=aim_vec[0]-vec[0];
	burn_vec1[1]=aim_vec[1]-vec[1];
	burn_vec1[2]=aim_vec[2]-vec[2];

	length=sqrt(burn_vec1[0]*burn_vec1[0]+burn_vec1[1]*burn_vec1[1]+burn_vec1[2]*burn_vec1[2]);
	
	burn_vec2[0]=burn_vec1[0]*speed2/length;
	burn_vec2[1]=burn_vec1[1]*speed2/length;
	burn_vec2[2]=burn_vec1[2]*speed2/length;
	
	burn_vec1[0]=burn_vec1[0]*speed1/length;
	burn_vec1[1]=burn_vec1[1]*speed1/length;
	burn_vec1[2]=burn_vec1[2]*speed1/length;
	
	burn_vec1[0] += vec[0];
	burn_vec1[1] += vec[1];
	burn_vec1[2] += vec[2];
	
	burn_vec2[0] += vec[0];
	burn_vec2[1] += vec[1];
	burn_vec2[2] += vec[2];
	
	get_user_aiming(id,target,body_part,500);
	if(pev_valid(target) && is_user_alive(target))
	{
		if(get_user_team(id) != get_user_team(target))
		{
			g_player_burning[target]=true;
			
			set_naruto_damage(id,target,1.0+g_skill[id][P_SKILL_6]/3.0);
			skill_vf_burn(id,target);
		}
	}
	
	get_players(players,num,"ah");
	for(new i = 0; i < num; i++)
	{
		if(get_user_team(id)==get_user_team(players[i]) || g_player_burning[players[i]])
		{
			continue;
		}
		
		g_player_burning[players[i]]=true;
		get_user_origin(players[i],origin);
	
		if(get_distance(origin,burn_vec1) <= radius)
		{
			skill_vf_burn(id,players[i]);
		}
		else if(get_distance(origin,burn_vec2) <= radius)
		{
			skill_vf_burn(id,players[i]);
		}
	}
	
	return PLUGIN_CONTINUE;
}

public skill_vf_burn(id,victim)
{
	static task,parm_flame[2],burn_time;
	
	task = NARUTO_TASK_VBURNING + victim;
	remove_task(task,0);
	
	parm_flame[0] = id;
	parm_flame[1] = victim;
	
	if(!g_player_burning[victim])
	{
		burn_time=random_num(4,8);
		set_task(0.8,"skill_vf_burning",task,parm_flame,2,"a",burn_time);
	}
	
	return PLUGIN_CONTINUE;
}

public skill_vf_burning(parm_flame[2])
{
	new origin[3];
	static id,victim;
	
	id = parm_flame[0];
	victim = parm_flame[1];
	
	if(!is_user_alive(victim))
	{
		remove_task(NARUTO_TASK_VBURNING+victim,0);
		return PLUGIN_HANDLED;
	}
	
	if(g_player_frozen[victim] || g_player_frosted[victim] > 0)
	{
		g_player_frozen[victim]=false;
		g_player_frosted[victim]=0;
		return PLUGIN_HANDLED;
	}
	
	get_user_origin(victim,origin);
		
	origin[0]+=random_num(-30,30);
	origin[1]+=random_num(-30,30);
	origin[2]+=random_num(-30,30)+10;
	
	create_te_sprite(origin,g_sprite_burning,30,200);
		
	origin[0]+=random_num(-30,30)*2;
	origin[1]+=random_num(-30,30)*2;
	origin[2]+=random_num(-30,30)*2+100;
		
	create_te_smoke(origin,g_sprite_smoke,60,15);
		
	create_screen_fade(victim,(1<<10),(1<<10),(1<<12),255,0,0,150);
		
	set_naruto_damage(id,victim,1.0+g_skill[id][P_SKILL_6]/2.0);
	
	return PLUGIN_CONTINUE;
}

public GameDesc( ) { 
	static gamename[32]; 
	get_pcvar_string( nt_gamename, gamename, 31 ); 
	forward_return( FMV_STRING, gamename ); 
	return FMRES_SUPERCEDE; 
}

public skill_white_lightning_reset(id)
{
	g_player_stunned[id]=0;
	validate_max_speed(id);
	remove_status_icon(id);
}

public skill_white_lightning(id,target,body_part,aim_origin[3])
{
	static Float:damage;

	create_te_beaments(id,target,g_sprite_lightning,0,15,10,100,10,255,255,255,255,0);
	create_te_elight(id,aim_origin,100,255,255,255,5,3);
	create_te_spark(aim_origin);
	
	emit_sound(id,CHAN_STATIC,g_sound[NARUTO_SOUND_WLIGHT],VOL_NORM,ATTN_NORM,0,PITCH_NORM);
	
	damage=NARUTO_SKILL_NORMAL_DAMAGE*(g_skill[id][P_SKILL_1]/random_num(2,6));
	set_naruto_damage(id,target,damage);
	
	remove_status_icon(target);
	g_player_statusicon[target]="dmg_shock";
	create_status_icon(target,2,g_player_statusicon[target],255,200,255);
	
	g_player_stunned[target]=2;
	validate_max_speed(target);
	set_task(NARUTO_SKILL_NORMAL_STUNNED,"skill_white_lightning_reset",target);
	
	return PLUGIN_HANDLED;
}


public skill_death_sting_reset(parm[2])
{
	static id,victim;
	id=parm[0];
	victim=parm[1];
	
	if(is_user_alive(victim))
	{
		print_hud_status(id,"%L",id,"L_STATUS_SKILL_DS_DISSAPPEAR");
		print_hud_status(victim,"%L",victim,"L_STATUS_SKILL_DS_DISSAPPEAR_TARGET");
		g_player_death_stinged[victim] = 0;
		remove_status_icon(victim);
	}
}

public skill_death_sting(id,victim,weapon,hitplace)
{
	if(!weapon || weapon == CSW_KNIFE || weapon == CSW_C4)
	{
		return PLUGIN_CONTINUE;
	}
	
	if(g_player_death_stinged[victim] == 0)
	{
		static random_hit;
		random_hit = random_num(HIT_HEAD,HIT_RIGHTLEG);
		if(random_hit < hitplace)
		{
			g_player_death_stinged[victim]=hitplace;
			print_hud_status(victim,"%L",victim,"L_STATUS_SKILL_DS_BODY");
			
			remove_status_icon(victim);
			g_player_statusicon[victim]="dmg_bio";
			create_status_icon(victim,2,g_player_statusicon[victim],255,255,255);
			
			static task,parm[2];
			
			task = NARUTO_TASK_STING + id;
			remove_task(task,0);
			
			parm[0] = id;
			parm[1] = victim;
			
			set_task(2.0*g_skill[id][P_SKILL_6],"skill_death_sting_reset",task,parm,2);
		}
	}
	else if(g_player_death_stinged[victim] == hitplace)
	{
		g_player_died_by_skill[victim]=true;
		print_hud_status(id,"%L",id,"L_STATUS_SKILL_DS_KILL");
		
		set_msg_block(g_msg_death_msg,BLOCK_ONCE);
		user_kill(victim,1);
		skill_deathmsg(id,victim);
	}
	
	return PLUGIN_CONTINUE;
}

public skill_steel_skin(id,victim,damage,weapon,hitplace)
{
	if(!weapon || weapon == CSW_HEGRENADE || weapon == CSW_C4 || weapon == CSW_AWP)
	{
		return PLUGIN_CONTINUE;
	}
	
	static armor,CsArmorType:armor_type;
	armor=cs_get_user_armor(victim,armor_type);
	
	if((!armor_type) && (hitplace == HIT_HEAD)) return PLUGIN_CONTINUE;
	
	if((armor > 100) || (cs_get_user_vip(id)) && (armor > 200))
	{
		static draw_damage;
		draw_damage=floatround(damage*(g_skill[victim][P_SKILL_5]*0.05));
		
		set_user_health(victim,get_user_health(victim)+draw_damage);
		cs_set_user_armor (victim,armor-draw_damage,armor_type);
		
		print_hud_status(victim,"%L",victim,"L_STATUS_SKILL_STEELSKIN");
	}
	
	return PLUGIN_CONTINUE;
}


public menu_handler_attributes(id,key)
{
	if((g_player_attributepoints[id] == 0) && (key < 8))
	{
		client_print(id,print_chat,"%L",id,"L_ENOUGH_ATTRIBUTEPOINTS",PLUGIN_TAG);
		return PLUGIN_HANDLED;
	}
	
	new attribute_name[64];
	
	switch(key)
	{
		case 0:
		{
			attribute_name="athletic";
			g_player_athletic[id] += 2.5;
			
			validate_max_speed(id);
		}
		case 1:
		{
			if(g_player_acrobatic[id] < 0.52)
			{
				client_print(id,print_chat,"%L",id,"L_ATTR_ACROBATIC_MAXED",PLUGIN_TAG);
				menu_print_attributes(id);
				return PLUGIN_HANDLED;
			}
			
			attribute_name="acrobatic";
			g_player_acrobatic[id] -= 0.02;
			
			validate_gravity(id);
		}
		case 2:
		{
			attribute_name="endurance";
			g_player_endurance[id] += 1;
			g_player_max_health[id] += 1;
			
			set_user_health(id,get_user_health(id)+1);
		}
		case 8:
		{
			menu_print_main(id);
		}
		
		default:
		{
			return PLUGIN_HANDLED;
		}
	}
	
	if(!equal(attribute_name,""))
	{
		client_print(id,print_chat,"%L",id,"L_ATTR_SELECTED",PLUGIN_TAG,attribute_name);
		g_player_attributepoints[id] -= 1;
		menu_print_attributes(id);
	}
	else if((equal(attribute_name,"")) && (key < 8))
	{
		menu_print_attributes(id);
	}
	
	return PLUGIN_HANDLED;
}


public menu_handler_classes(id,key)
{
	switch(key)
	{
		case 0:
		{
			client_print(id,print_chat,"%L",id,"L_CLASS_1_SELECTED",PLUGIN_TAG);
			g_player_class[id]=CLASS_DEATHGOD;
		}
		case 1:
		{
			client_print(id,print_chat,"%L",id,"L_CLASS_2_SELECTED",PLUGIN_TAG);
			g_player_class[id]=CLASS_HOLLOW;
		}
		case 8:
		{
			menu_print_main(id);
		}
		default:
		{
			return PLUGIN_HANDLED;
		}
	}
	
	if(key < 2)
	{
		load_player(id);
		g_player_max_spirit[id]=NARUTO_MAXIMUM_SPIRIT_POWER+(g_player_level[id]*NARUTO_SPR_PER_LEVEL);
		print_hud_player(id);
		g_player_class_selected[id]=true;
	}
	else if((key > 1) && (key < 8))
	{
		menu_print_classes(id);
	}
	
	return PLUGIN_HANDLED;
}


public menu_handler_information(id,key)
{
	switch(key)
	{
		case 0:
		{
			motd_skills(id);
		}
		case 1:
		{
			motd_attributes(id);
		}
		case 2:
		{
			motd_items(id);
		}
		case 8:
		{
			menu_print_main(id);
		}
		
		default:
		{
			return PLUGIN_HANDLED;
		}
	}
	
	if((key > 2) && (key < 8))
	{
		menu_print_information(id);
	}
	
	return PLUGIN_HANDLED;
}

public menu_handler_items(id,key)
{
	static item_bought,cost;
	
	switch(key)
	{
		case 0:
		{
			cost=NARUTO_ITEM_1_COST;
			item_bought=item_check(id,cost);
			if(item_bought)
			{
				g_player_item[id]=1;
			}
		}
		case 1:
		{
			cost=NARUTO_ITEM_2_COST;
			item_bought=item_check(id,cost);
			if(item_bought)
			{
				g_player_item[id]=2;
			}
		}
		case 2:
		{
			cost=NARUTO_ITEM_3_COST;
			item_bought=item_check(id,cost);
			if(item_bought)
			{
				g_player_item[id]=3;
			}
		}
		case 8:
		{
			menu_print_main(id);
		}
		
		default:
		{
			return PLUGIN_HANDLED;
		}
	}
	
	if(item_bought)
	{
		client_print(id,print_chat,"%L",id,"L_ITEM_BOUGHT",PLUGIN_TAG,g_item_names[g_player_item[id]]);
		cs_set_user_money(id,cs_get_user_money(id)-cost,1);
		item_passive(id);
		print_hud_player(id);
	}
	else if((!item_bought) && (key < 8))
	{
		menu_print_items(id);
	}
	
	return PLUGIN_HANDLED;
}


public menu_handler_main(id,key)
{
	switch(key)
	{
		case 0:
		{
			menu_print_classes(id);
		}
		case 1:
		{
			menu_print_attributes(id);
		}
		case 2:
		{
			menu_print_skills(id);
		}
		case 3:
		{
			menu_print_items(id);
		}
		case 4:
		{
			motd_character(id);
		}
		case 5:
		{
			menu_print_information(id);
		}
		case 6:
		{
			motd_help(id);
		}
		case 7:
		{
			motd_about(id);
		}
		case 8:
		{
			menu_print_next(id);
		}

		default:
		{
			return PLUGIN_HANDLED;
		}
	}
	
	return PLUGIN_HANDLED;
}

public menu_handler_next(id,key)
{
	switch(key)
	{
		case 0:
		{
			motd_players(id);
		}
		case 1:
		{
			motd_commands(id);
		}
		case 8:
		{
			menu_print_main(id);
		}


		default:
		{
			return PLUGIN_HANDLED;
		}
	}
	
	return PLUGIN_HANDLED;
}


public menu_handler_skills(id,key)
{
	if((g_player_skillpoints[id] == 0) && (key < 8))
	{
		client_print(id,print_chat,"%L",id,"L_ENOUGH_SKILLPOINTS",PLUGIN_TAG);
		return PLUGIN_HANDLED;
	}
	
	new skill_name[64],skill_selected;

	if(g_player_class[id] == 1)
	{
		switch(key)
		{
			case 0:
			{
				skill_selected=skill_select_check(id,g_skill[id][P_SKILL_1],NARUTO_SKILL_NORMAL_REQ_LEVEL,NARUTO_SKILL_NORMAL_MAXLEVEL);
				if(skill_selected)
				{
					skill_name="white lightning";
					g_skill[id][P_SKILL_1]+=1;
				}
			}
			case 1:
			{
				skill_selected=skill_select_check(id,g_skill[id][P_SKILL_2],0,NARUTO_SKILL_NOVICE_MAXLEVEL);
				if(skill_selected)
				{
					skill_name="shine brightly";
					g_skill[id][P_SKILL_2]+=1;
				}
			}
			case 2:
			{
				skill_selected=skill_select_check(id,g_skill[id][P_SKILL_3],NARUTO_SKILL_GREATER_REQ_LEVEL,NARUTO_SKILL_GREATER_MAXLEVEL);
				if(skill_selected)
				{
					skill_name="ice ring";
					g_skill[id][P_SKILL_3]+=1;
				}
			}
			case 3:
			{
				skill_selected=skill_select_check(id,g_skill[id][P_SKILL_4],0,NARUTO_SKILL_NOVICE_MAXLEVEL);
				if(skill_selected)
				{
					skill_name="restrain";
					g_skill[id][P_SKILL_4]+=1;
				}
			}
			case 4:
			{
				skill_selected=skill_select_check(id,g_skill[id][P_SKILL_5],NARUTO_SKILL_MASTER_REQ_LEVEL,NARUTO_SKILL_MASTER_MAXLEVEL);
				if(skill_selected)
				{
					skill_name="cherry blossoms";
					g_skill[id][P_SKILL_5]+=1;
				}
			}
			case 5:
			{
				skill_selected=skill_select_check(id,g_skill[id][P_SKILL_6],NARUTO_SKILL_GREATER_REQ_LEVEL,NARUTO_SKILL_GREATER_MAXLEVEL);
				if(skill_selected)
				{
					skill_name="death sting";
					g_skill[id][P_SKILL_6]+=1;
				}
			}
			case 8:
			{
				menu_print_main(id);
			}
			default:
			{
				return PLUGIN_HANDLED;
			}
		}
	}
	else if(g_player_class[id] == 2)
	{
		switch(key)
		{
			case 0:
			{
				skill_selected=skill_select_check(id,g_skill[id][P_SKILL_1],0,NARUTO_SKILL_NOVICE_MAXLEVEL);
				if(skill_selected)
				{	
					skill_name="devour soul";
					g_skill[id][P_SKILL_1]+=1;
				}
			}
			case 1:
			{
				skill_selected=skill_select_check(id,g_skill[id][P_SKILL_2],0,NARUTO_SKILL_NOVICE_MAXLEVEL);
				if(skill_selected)
				{
					skill_name="hollow bullet";
					g_skill[id][P_SKILL_2]+=1;
				}
			}
			case 2:
			{
				skill_selected=skill_select_check(id,g_skill[id][P_SKILL_3],NARUTO_SKILL_NORMAL_REQ_LEVEL,NARUTO_SKILL_NORMAL_MAXLEVEL);
				if(skill_selected)
				{
					skill_name="negation";
					g_skill[id][P_SKILL_3]+=1;
				}
			}
			case 3:
			{
				skill_selected=skill_select_check(id,g_skill[id][P_SKILL_4],NARUTO_SKILL_MASTER_REQ_LEVEL,NARUTO_SKILL_MASTER_MAXLEVEL);
				if(skill_selected)
				{
					skill_name="cero";
					g_skill[id][P_SKILL_4]+=1;
				}
			}
			case 4:
			{
				skill_selected=skill_select_check(id,g_skill[id][P_SKILL_5],NARUTO_SKILL_GREATER_REQ_LEVEL,NARUTO_SKILL_GREATER_MAXLEVEL);
				if(skill_selected)
				{
					skill_name="steel skin";
					g_skill[id][P_SKILL_5]+=1;
				}
			}
			case 5:
			{
				skill_selected=skill_select_check(id,g_skill[id][P_SKILL_6],NARUTO_SKILL_GREATER_REQ_LEVEL,NARUTO_SKILL_GREATER_MAXLEVEL);
				if(skill_selected)
				{
					skill_name="volcanic flame";
					g_skill[id][P_SKILL_6]+=1;
				}
			}
			case 8:
			{
				menu_print_main(id);
			}
			default:
			{
				return PLUGIN_HANDLED;
			}
		}
	}
	
	if(skill_selected)
	{
		client_print(id,print_chat,"%L",id,"L_SKILL_SELECTED",PLUGIN_TAG,skill_name);
		g_player_skillpoints[id] -= 1;
		menu_print_skills(id);
	}
	else if((!skill_selected) && (key < 8))
	{
		menu_print_skills(id);
	}
	
	return PLUGIN_HANDLED;
}

public item_gigai(id)
{
	if((find_ent_by_owner(-1,"npc_gigai",id,0)) || (!is_user_alive(id))) return PLUGIN_CONTINUE;
	
	static Float:origin[3];
	
	entity_get_vector(id,EV_VEC_origin,origin);
	
	new ent = create_entity("info_target");
	entity_set_string(ent,EV_SZ_classname,"npc_gigai");
	entity_set_edict(ent,EV_ENT_owner,id);

	entity_set_origin(ent,origin);
	
	entity_set_float(ent,EV_FL_takedamage,DAMAGE_AIM);
	entity_set_float(ent,EV_FL_health,100.0);
	
	if(get_user_team(id) == TEAM_CT)
	{
		entity_set_model(ent,"models/player/gign/gign.mdl");
	}
	else
	{
		entity_set_model(ent,"models/player/leet/leet.mdl");
	}
	
	entity_set_byte(ent,EV_BYTE_controller1,125);
	entity_set_byte(ent,EV_BYTE_controller2,125);
	entity_set_byte(ent,EV_BYTE_controller3,125);
	entity_set_byte(ent,EV_BYTE_controller4,125);
	
	static Float:max[3],Float:min[3];
	
	max[0] = 16.0;
	max[1] = 16.0;
	max[2] = 36.0;
	
	min[0] = -16.0;
	min[1] = -16.0;
	min[2] = -36.0;
	
	entity_set_size(ent,min,max);
	entity_set_int(ent,EV_INT_solid,SOLID_TRIGGER);
	
	entity_set_float(ent,EV_FL_animtime,2.0);
	entity_set_float(ent,EV_FL_framerate,1.0);
	
	entity_set_int(ent,EV_INT_sequence,1);
	
	//---------------------------------------------------------------------
	
	new ent_weapon = create_entity("info_target");

	entity_set_string(ent_weapon,EV_SZ_classname,"npc_gigai_weapon");
	
	entity_set_int(ent_weapon,EV_INT_movetype,MOVETYPE_FOLLOW);
	entity_set_int(ent_weapon,EV_INT_solid,SOLID_NOT);
	
	entity_set_edict(ent_weapon,EV_ENT_aiment,ent);
	entity_set_edict(ent_weapon,EV_ENT_owner,ent);
	
	entity_set_model(ent_weapon,"models/p_deagle.mdl");
	
	//---------------------------------------------------------------------
	
	drop_to_floor(ent);
	g_player_item_in_use[id]=true;
	
	return PLUGIN_CONTINUE;
}

public item_gigai_touch(touched,toucher)
{
	if(entity_get_edict(touched,EV_ENT_owner) != toucher)
	{
		print_hud_status(toucher,"%L",toucher,"L_STATUS_NOT_YOURS");
		return PLUGIN_CONTINUE;
	}
	
	
	if(g_player_use[toucher])
	{
		static ent_weapon;
		ent_weapon = find_ent_by_owner(-1,"npc_gigai_weapon",touched,0);
		
		if(is_valid_ent(ent_weapon))
		{
			remove_entity(ent_weapon);
		}
		remove_entity(touched);
		g_player_item_in_use[toucher]=false;
	}
	else
	{
		print_hud_status(toucher,"%L",toucher,"L_STATUS_RESTORE");
	}
	
	return PLUGIN_CONTINUE;
}

public item_gigai_remove(id)
{
	static ent,ent_weapon;
	ent = find_ent_by_owner(-1,"npc_gigai",id,0);

	if(is_valid_ent(ent))
	{
		ent_weapon = find_ent_by_owner(-1,"npc_gigai_weapon",ent,0);
		if(is_valid_ent(ent_weapon))
		{
			remove_entity(ent_weapon);
		}
		remove_entity(ent);
	}
}


public item_injection_drain(parm[1])
{
	static id,bool:task_removed;
	new health;
	
	id=parm[0];
	health=get_user_health(id);
	
	
	if((health == 1) || (!is_user_alive(id)) || (g_event_freeze_time) || (g_event_round_end))
	{
		remove_task(NARUTO_TASK_INJECTION + id,0);
		task_removed=true;
	}
	else if(health > 1)
	{
		set_user_health(id,health-1);
	}

	
	if((task_removed) || (health <= g_player_max_health[id]))
	{
		g_player_item_in_use[id]=false;
	}
}

public item_injection(id)
{
	if(!is_user_alive(id)) return PLUGIN_CONTINUE;
	
	static task,health,parm[1];
	
	task = NARUTO_TASK_INJECTION + id;
	remove_task(task,0);
	
	health=get_user_health(id);
	parm[0] = id;
	
	set_user_health(id,health+50);
	g_player_item_in_use[id]=true;
		
	set_task(2.0,"item_injection_drain",task,parm,1,"a",50);
	
	g_player_item[id]=0;
	
	return PLUGIN_CONTINUE;
}


public item_drop(id,item_id)
{
	new Float:origin[3],Float:colors[3];
	entity_get_vector(id,EV_VEC_origin,origin);
	
	new ent = create_entity("info_target");
	
	entity_set_string(ent,EV_SZ_classname,"item_drop");
	entity_set_model(ent,"models/sphere.mdl");
	
	origin[2] += 10.0;
	entity_set_origin(ent,origin);
	
	entity_set_int(ent,EV_INT_rendermode,kRenderTransColor);
	entity_set_int(ent,EV_INT_renderfx,kRenderFxGlowShell);
	
	entity_set_int(ent,EV_INT_movetype,MOVETYPE_TOSS);
	entity_set_int(ent,EV_INT_solid,SOLID_TRIGGER);
	
	colors[0]=g_item_color_red[item_id];
	colors[1]=g_item_color_green[item_id];
	colors[2]=g_item_color_blue[item_id];
	
	entity_set_vector(ent,EV_VEC_rendercolor,colors);
	entity_set_float(ent,EV_FL_renderamt,150.0);
	
	entity_set_edict(ent,EV_ENT_owner,item_id);

	drop_to_floor(ent);
	
	return PLUGIN_CONTINUE;
}

public item_drop_touch(touched,toucher)
{
	if(!is_user_alive(toucher))
	{
		return PLUGIN_CONTINUE;
	}
	
	static item_id;
	item_id=entity_get_edict(touched,EV_ENT_owner);
	
	if(g_player_use[toucher])
	{
		if(g_player_item[toucher] > 0)
		{
			print_hud_status(toucher,"%L",toucher,"L_STATUS_ITEM_HAVE");
			return PLUGIN_CONTINUE;
		}
			
		g_player_item[toucher]=item_id;
		item_passive(toucher);
		
		print_hud_player(toucher);
		remove_entity(touched);
	}
	else
	{
		print_hud_status(toucher,"%L",toucher,"L_STATUS_ITEM",g_item_names[item_id]);
	}
	
	return PLUGIN_CONTINUE;
}

public item_drop_remove()
{
	new ent = 0;
	while((ent = find_ent_by_class(-1,"item_drop")) > 0)
	{
		if(is_valid_ent(ent))
		{
			remove_entity(ent);
		}
	}
	
	return PLUGIN_CONTINUE;
}


public item_mantle_reset(id)
{
	set_user_gravity(id,g_player_acrobatic[id]);
}


public mysql_init()
{
	static host[64],user[32],password[32],database[128],error_num;

	get_pcvar_string(cvar_sql_host,host,63);
	get_pcvar_string(cvar_sql_user,user,31);
	get_pcvar_string(cvar_sql_password,password,31);
	get_pcvar_string(cvar_sql_database,database,127);
	
	g_sql_tuple = SQL_MakeDbTuple(host,user,password,database);
	g_sql_connect = SQL_Connect(g_sql_tuple,error_num,g_sql_error,255);

	if(g_sql_connect == Empty_Handle)
	{
		g_sql_available = false;
		server_print(g_sql_error);
		return PLUGIN_CONTINUE;
	}
	
	g_sql_available = true;
	
	new sql_path[64] = "%s/sql/naruto.sql";
	format(sql_path,63,sql_path,amxx_data_dir);
	if(file_exists(sql_path))
	{
		new sql_table[512],line[256],len,len2,i = 0;
		
		while(read_file(sql_path,i++,line,255,len))
		{
			read_file(sql_path,i,line,255,len);
			len2 += formatex(sql_table[len2],511-len2,line);
		}
		
		g_sql_query = SQL_PrepareQuery(g_sql_connect,sql_table);
		
		if (!SQL_Execute(g_sql_query))
		{
			database_error(g_sql_query);
		}

		SQL_FreeHandle(g_sql_query);
	}

	
	return PLUGIN_CONTINUE;
}

public mysql_close()
{
	if(g_sql_tuple)
	{
		SQL_FreeHandle(g_sql_tuple);
	}

	if(g_sql_connect)
	{
		SQL_FreeHandle(g_sql_connect);
	}
}

public mysql_save(id)
{
	if(!g_sql_available) return PLUGIN_CONTINUE;
	
	static authid[33];
	get_user_authid(id,authid,32);
	
	//Select Character
	format(g_sql_string,255,"SELECT * FROM `%s` WHERE authid='%s' AND class=%d",g_sql_table,authid,g_player_class[id]);
	g_sql_query = SQL_PrepareQuery(g_sql_connect,g_sql_string);
	if(!SQL_Execute(g_sql_query))
	{
		database_error(g_sql_query);
	}
	
	new found;
	if(SQL_MoreResults(g_sql_query))
	{
		found=SQL_ReadResult(g_sql_query,0);
	}
	SQL_FreeHandle(g_sql_query);
	
	//Update/Insert Character
	if(found)
	{
		format(g_sql_string,255,"UPDATE `%s` SET experience=%d,level=%d,attributepoints=%d,skillpoints=%d,spirit=%d WHERE authid='%s' AND class=%d",
		g_sql_table,g_player_experience[id],g_player_level[id],g_player_attributepoints[id],g_player_skillpoints[id],g_player_spirit[id],authid,g_player_class[id]);
	}	
	else
	{
		format(g_sql_string,255,"INSERT into `%s` (`authid`,`class`,`experience`,`level`,`attributepoints`,`skillpoints`,`spirit`) values ('%s','%d','%d','%d','%d','%d','%d')",
		g_sql_table,authid,g_player_class[id],g_player_experience[id],g_player_level[id],g_player_attributepoints[id],g_player_skillpoints[id],g_player_spirit[id]);
	}
	
	g_sql_query = SQL_PrepareQuery(g_sql_connect,g_sql_string);
	if(!SQL_Execute(g_sql_query))
	{
		database_error(g_sql_query);
	}
	
	SQL_FreeHandle(g_sql_query);
	
	//Update Attributes
	format(g_sql_string,255,"UPDATE `%s` SET athletic='%f',acrobatic='%f',endurance='%d' WHERE authid='%s' AND class=%d",g_sql_table,g_player_athletic[id],g_player_acrobatic[id],g_player_endurance[id],authid,g_player_class[id]);
	g_sql_query = SQL_PrepareQuery(g_sql_connect,g_sql_string);
	if(!SQL_Execute(g_sql_query))
	{
		database_error(g_sql_query);
	}
	SQL_FreeHandle(g_sql_query);
	
	//Update Skills
	for (new i = 0; i < NARUTO_MAX_SKILLS; i++)
	{
		format(g_sql_string,255,"UPDATE `%s` SET skill_%d=%d WHERE authid='%s' AND class=%d",g_sql_table,i,g_skill[id][i],authid,g_player_class[id]);
		g_sql_query = SQL_PrepareQuery(g_sql_connect,g_sql_string);	
		if(!SQL_Execute(g_sql_query))
		{
			database_error(g_sql_query);
		}
		SQL_FreeHandle(g_sql_query);
	}
	
	return PLUGIN_CONTINUE;
}

public mysql_load(id)
{
	if(!g_sql_available) return PLUGIN_CONTINUE;
	
	static authid[33];
	get_user_authid(id,authid,32);
	
	format(g_sql_string,255,"SELECT * FROM `%s` WHERE authid='%s' AND class=%d",g_sql_table,authid,g_player_class[id]);
	g_sql_query = SQL_PrepareQuery(g_sql_connect,g_sql_string);
	if(!SQL_Execute(g_sql_query))
	{
		database_error(g_sql_query);
	}
	
	new found;
	if(SQL_MoreResults(g_sql_query))
	{
		found=SQL_ReadResult(g_sql_query,0);
	}
	
	if(found)
	{
		g_player_experience[id]=SQL_ReadResult(g_sql_query,3);
		g_player_level[id]=SQL_ReadResult(g_sql_query,4);
		g_player_attributepoints[id]=SQL_ReadResult(g_sql_query,5);
		g_player_skillpoints[id]=SQL_ReadResult(g_sql_query,6);
		g_player_spirit[id]=SQL_ReadResult(g_sql_query,7);

		SQL_ReadResult(g_sql_query,8,g_player_athletic[id]);
		SQL_ReadResult(g_sql_query,9,g_player_acrobatic[id]);
		
		g_player_endurance[id]=SQL_ReadResult(g_sql_query,10);
	
		g_skill[id][P_SKILL_1]=SQL_ReadResult(g_sql_query,11);
		g_skill[id][P_SKILL_2]=SQL_ReadResult(g_sql_query,12);
		g_skill[id][P_SKILL_3]=SQL_ReadResult(g_sql_query,13);
		g_skill[id][P_SKILL_4]=SQL_ReadResult(g_sql_query,14);
		g_skill[id][P_SKILL_5]=SQL_ReadResult(g_sql_query,15);
		g_skill[id][P_SKILL_6]=SQL_ReadResult(g_sql_query,16);
	}
	else
	{
		reset_player(id);
		reset_player_attributes(id);
		reset_player_skills(id);
		restore_cooldowns(id);
		restore_player(id);
	}
	
	SQL_FreeHandle(g_sql_query);
	
	return PLUGIN_CONTINUE;
}

public mysql_truncate()
{
	if(!g_sql_available) return PLUGIN_CONTINUE;
	format(g_sql_string,255,"TRUNCATE TABLE %s",g_sql_table);
	g_sql_query = SQL_PrepareQuery(g_sql_connect,g_sql_string);
	
	if(!SQL_Execute(g_sql_query))
	{
		database_error(g_sql_query);
	}
	SQL_FreeHandle(g_sql_query);
	
	return PLUGIN_CONTINUE;
}


public sqlite_init()
{
	static database[128],integrity_check[64],error_num;
	get_pcvar_string(cvar_sql_database,database,127);
	
	g_sql_tuple = SQL_MakeDbTuple("","","",database);
	g_sql_connect = SQL_Connect(g_sql_tuple,error_num,g_sql_error,255);
	
	g_sql_available = false;
	
	if(g_sql_connect == Empty_Handle)
	{
		database_error(g_sql_query);
		return PLUGIN_CONTINUE;
	}
	
	g_sql_query = SQL_PrepareQuery(g_sql_connect,"PRAGMA integrity_check");

	if(!SQL_Execute(g_sql_query))
	{
		database_error(g_sql_query);
		SQL_FreeHandle(g_sql_query);
		return PLUGIN_CONTINUE;
	}
	
	if(SQL_NumResults(g_sql_query) > 0 )
	{
		SQL_ReadResult(g_sql_query,0,integrity_check,63);
	}

	if (!equali(integrity_check,"ok"))
	{
		return PLUGIN_CONTINUE;
	}
	
	format(g_sql_string,255,"PRAGMA synchronous = %d",SQLITE_SYNC_OFF);
	g_sql_query = SQL_PrepareQuery(g_sql_connect,g_sql_string);

	if(!SQL_Execute(g_sql_query))
	{
		database_error(g_sql_query);
		SQL_FreeHandle(g_sql_query);
		return PLUGIN_CONTINUE;
	}

	g_sql_available = true;
	
	return PLUGIN_CONTINUE;
}

public skill_devour_soul(id,victim)
{
	static health,max_health,bonus_health,bonus_spirit;
	
	health=get_user_health(id);
	max_health=g_player_max_health[id];
	bonus_health=floatround(g_skill[id][P_SKILL_1]*(g_player_max_health[victim]*0.2));
	bonus_spirit=floatround(g_skill[id][P_SKILL_1]*(g_player_max_spirit[victim]*0.05));
	
	if (health < max_health)
	{
		if (health+bonus_health > max_health)
		{
			set_user_health(id,max_health);
		}
		else
		{
			set_user_health(id,health+bonus_health);
		}
		
		spirit_set(id,g_player_spirit[id]+bonus_spirit);
		create_screen_fade(id,(1<<10),(1<<10),(1<<12),0,0,255,bonus_health);
	}
	
	return PLUGIN_CONTINUE;
}

public skill_shine_brightly(id,victim)
{
	if(g_player_spirit[id] > random_num(1,g_player_spirit[victim]))
	{
		if(!g_player_in_skill[victim])
		{
			static flash;
			flash=105+g_skill[id][P_SKILL_2]*random_num(20,30);
			
			create_screen_fade(victim,(1<<10),(1<<10),(1<<12),255,255,255,flash);
		}
	}
	
	return PLUGIN_CONTINUE;
}

public skill_negation(id,victim)
{
	if((!g_player_negation_used[victim]) && (is_user_alive(victim)) && (!g_event_planted))
	{
		static origin[3],health;
		health = pev(victim,pev_health);
		if(health < floatround(g_player_max_health[victim]*0.60))
		{
			get_user_origin(victim,origin);
			create_te_teleport(origin);
		
			g_player_in_skill[victim] = true;
			g_player_negation_used[victim] = true;
			g_player_negating[victim] = true;
			set_user_godmode (victim,1);
			set_user_rendering(victim,kRenderFxGlowShell,255,255,0,kRenderNormal,50); 
			validate_max_speed(victim);
			
			set_task(NARUTO_SKILL_NEGATION_TIME,"skill_negation_activate",victim);
		
			static xp;
			xp=xp_get(get_pcvar_num(cvar_xp_negation));
			
			client_print(id,print_chat,"%L",id,"L_XP_NEGATE",PLUGIN_TAG,xp);
			xp_set(id,g_player_experience[id]+xp);
		}
	}
	
	return PLUGIN_CONTINUE;
}

public skill_negation_activate(id)
{
	if(is_user_alive(id))
	{
		spawn(id);
		spawn(id);
		set_user_rendering(id);
		set_user_health(id,NARUTO_SKILL_NEGATION_HEALTH);
		print_hud_status(id,"%L",id,"L_STATUS_SKILL_NEGATED");
	}
	
	g_player_in_skill[id] = false;
	g_player_negating[id] = false;
	
	set_user_godmode(id,0);
	validate_max_speed(id);
}


public skill_restrain_reset(id)
{
	g_player_stunned[id]=0;
	validate_max_speed(id);
	set_user_rendering(id);
}

public skill_restrain(id,victim,hitplace)
{
	if((hitplace == HIT_LEFTARM) || (hitplace == HIT_RIGHTARM))
	{
		g_player_stunned[victim]=1;
		set_user_rendering(victim,kRenderFxGlowShell,255,255,255,kRenderNormal,10); 
		validate_max_speed(victim);
		set_task(NARUTO_SKILL_NOVICE_STUNNED,"skill_restrain_reset",victim);
	}
	
	return PLUGIN_CONTINUE;
}