Eroare plugin [rezolvat]

Modificari necesare ale pluginurilor

Moderators: Moderatori ajutatori, Moderatori, Echipa eXtreamCS.com

Post Reply
User avatar
alexnovac18
Utilizator neserios (tepar)
Utilizator neserios (tepar)
Posts: 35
Joined: 17 Mar 2018, 15:46
Detinator Steam: Da
CS Status: Citesc forumul eXtreamCS.com...!
Detinator server CS: ZE.WSTRIKE.RO
SteamID: alexnovac18
Reputatie: Utilizator neserios (tepar!)
Utilizator vechi: novac-alex
Fond eXtream: 0
Contact:

06 Sep 2018, 05:09

Salut ExtreamCS, am o problemă cu pluginul zombie escape, tot îmi dă erorile astea în consolă

L 09/05/2018 - 22:01:24: Invalid cellvector handle provided (27:0:0)
L 09/05/2018 - 22:01:24: [AMXX] Displaying debug trace (plugin "ze_escape_classic.amxx")
L 09/05/2018 - 22:01:24: [AMXX] Run time error 10: native error (native "ArrayGetString")
L 09/05/2018 - 22:01:24: [AMXX] [0] ze_escape_classic.sma::End_Round (line 2304)
L 09/05/2018 - 22:01:24: [AMXX] [1] ze_escape_classic.sma::event_roundend (line 893)
L 09/05/2018 - 22:01:37: Invalid cellvector handle provided (27:-1:0)
L 09/05/2018 - 22:01:37: [AMXX] Displaying debug trace (plugin "ze_escape_classic.amxx")
L 09/05/2018 - 22:01:37: [AMXX] Run time error 10: native error (native "ArrayGetString")
L 09/05/2018 - 22:01:37: [AMXX] [0] ze_escape_classic.sma::rs_menu (line 2372)
L 09/05/2018 - 22:01:37: [AMXX] [1] ze_escape_classic.sma::gamem_handle (line 1011)
L 09/05/2018 - 22:01:38: Invalid cellvector handle provided (27:-1:0)
L 09/05/2018 - 22:01:38: [AMXX] Displaying debug trace (plugin "ze_escape_classic.amxx")
L 09/05/2018 - 22:01:38: [AMXX] Run time error 10: native error (native "ArrayGetString")
L 09/05/2018 - 22:01:38: [AMXX] [0] ze_escape_classic.sma::rs_menu (line 2372)
L 09/05/2018 - 22:01:38: [AMXX] [1] ze_escape_classic.sma::gamem_handle (line 1011)
L 09/05/2018 - 22:02:19: Invalid cellvector handle provided (27:0:0)
L 09/05/2018 - 22:02:19: [AMXX] Displaying debug trace (plugin "ze_escape_classic.amxx")
L 09/05/2018 - 22:02:19: [AMXX] Run time error 10: native error (native "ArrayGetString")
L 09/05/2018 - 22:02:19: [AMXX] [0] ze_escape_classic.sma::End_Round (line 2304)
L 09/05/2018 - 22:02:19: [AMXX] [1] ze_escape_classic.sma::event_roundend (line 893)

Sursă plugin :
| Afiseaza codul
#include <amxmodx>
#include <amxmisc>
#include <engine>
#include <fakemeta_util>
#include <hamsandwich>
#include <cstrike>
#include <fun>
#include <amx_settings_api>
#include <cs_player_models_api>
#include <cs_maxspeed_api>

#define PLUGIN "Zombie Escape"
#define VERSION "2.5"
#define AUTHOR "Dias"

// Main Config 
#define CONFIG_FILE "zombie_escape.ini"
#define OFFICIAL_LANG LANG_PLAYER
const OFFSET_LINUX = 5 // offsets 5 higher in Linux builds
const OFFSET_CSMENUCODE = 205

new allow_map_prefix[1][] = 
{
	"ze_"
}


// Config Vars
new cfg_min_player, cfg_default_light[2], cfg_zom_release_time, cfg_hum_freeze_time, cfg_round_time
new cfg_use_fog, cfg_fog_density[16], cfg_fog_color[32]
new cfg_human_health, cfg_human_armor, Float:cfg_human_gravity, Float:cfg_human_speed	
new cfg_zombie_health, cfg_zombie_armor, Float:cfg_zombie_gravity, Float:cfg_zombie_speed, Float:cfg_zombie_kbpower
new cfg_skyname[10], Array:v_knife_human, Array:p_knife_human
new Array:human_model, Array:human_modelindex, Array:host_zombie_model, Array:host_zombie_modelindex, Array:origin_zombie_model, Array:origin_zombie_modelindex, Array:zombie_claws_model, Array:host_zombie_claws_model
new Array:ambience_sound, Array:zombieappear_sound, Array:zombieinfect_sound
new Array:zombiepain_sound, Array:zombieattack_sound, Array:zombieswing_sound, Array:zombiewall_sound
new count_sound[64], Array:sound_win_humans, Array:sound_win_zombies
new last_win, current_playing[33], music_team[33], last_music, rs_disable[33], knock_back_immune[33]
new const sound_nvg[2][] = {"items/nvg_off.wav", "items/nvg_on.wav"}

// Game Vars
new g_endround, g_count, bot_register, g_gamestart, /*score_hud,*/ Float:delay_hud[33], stat_hud
new notice_hud, g_started, g_zombie[33], g_zombie_type[33], g_nvg[33], g_team_score[6]
new Float:g_spawn_origin[33][3], g_escape_point[33], g_escape_rank[4]
new g_MsgDeathMsg, Array:sound_win_zombies_name, Array:sound_win_humans_name, cvar_fragskill

enum
{
	RANK_NONE = 0,
	RANK_FIRST,
	RANK_SECOND,
	RANK_THIRD
}

// Hardcode
new g_primaryweapons[][][] = 
{ 
	{ "M4A1",     "weapon_m4a1"    },
	{ "AK47",     "weapon_ak47"    },
	{ "AUG",      "weapon_aug"     },
	{ "SG552",    "weapon_sg552"   },
	{ "Galil",    "weapon_galil"   },
	{ "Famas",    "weapon_famas"   },
	{ "MP5 Navy", "weapon_mp5navy" },
	{ "XM1014",   "weapon_xm1014"  },
	{ "M3",       "weapon_m3"      },
	{ "P90",      "weapon_p90"     },
	{ "M249",     "weapon_m249"    },
	{ "SG550",    "weapon_sg550"   },
	{ "G3SG1",    "weapon_g3sg1"   }			
}

// secondary weapons (menu|game)
new g_secondaryweapons[][][] = 
{ 
	{ "USP",      "weapon_usp"     },
	{ "Glock",      "weapon_glock18"     },
	{ "Deagle",   "weapon_deagle"  },
	{ "Elite",    "weapon_elite"   } 
}

// grenade loadout (game)
new g_grenades[][] = 
{ 
	"weapon_hegrenade",
	"weapon_smokegrenade"
}

new g_szObjectiveClassNames[][] =
{
	"func_bomb_target",
	"info_bomb_target",
	"info_vip_start",
	"func_vip_safetyzone",
	"func_escapezone",
	"hostage_entity",
	"monster_scientist",
	"func_hostage_rescue",
	"info_hostage_rescue",
	"item_longjump"
}
enum
{
	TASK_COUNTDOWN = 52000,
	TASK_COUNTDOWN2,
	TASK_AMBIENCE,
	TASK_ROUNDTIME,
	TASK_TEAM
}
enum
{
	TEAM_T = 1,
	TEAM_CT = 2,
	TEAM_ALL = 5,
	TEAM_START = 6
}
enum
{
	AL_NOT = 0,
	AL_ALIVE = 1,
	AL_BOTH = 2
}
enum
{
	ZOMBIE_TYPE_HOST = 0,
	ZOMBIE_TYPE_ORIGIN
}

#define ID_TEAM (taskid - TASK_TEAM)

new g_WinText[7][64]

// Menu Weapon Code (Thank to Cheap_Suit)
new bool:g_showmenu[33], bool:g_menufailsafe[33], g_player_weapons[33][2], g_menuposition[33]
#define TASKID_WEAPONSMENU 564
#define EQUIP_PRI (1<<0)
#define EQUIP_SEC (1<<1)
#define EQUIP_GREN (1<<2)
#define EQUIP_ALL (1<<0 | 1<<1 | 1<<2)

#define OFFSET_LASTPRIM 368
#define OFFSET_LASTSEC 369
#define OFFSET_LASTKNI 370

#define OFFSET_DEATH 444
#define OFFSET_TEAM 114
#define OFFSET_ARMOR 112
#define OFFSET_NVG 129
#define OFFSET_CSMONEY 115
#define OFFSET_PRIMARYWEAPON 116
#define OFFSET_WEAPONTYPE 43
#define OFFSET_CLIPAMMO	51
#define EXTRAOFFSET_WEAPONS 4

#define OFFSET_AMMO_338MAGNUM 377
#define OFFSET_AMMO_762NATO 378
#define OFFSET_AMMO_556NATOBOX 379
#define OFFSET_AMMO_556NATO 380
#define OFFSET_AMMO_BUCKSHOT 381
#define OFFSET_AMMO_45ACP 382
#define OFFSET_AMMO_57MM 383
#define OFFSET_AMMO_50AE 384
#define OFFSET_AMMO_357SIG 385
#define OFFSET_AMMO_9MM 386

#define fm_lastprimary(%1) get_pdata_cbase(id, OFFSET_LASTPRIM)
#define fm_lastsecondry(%1) get_pdata_cbase(id, OFFSET_LASTSEC)
#define fm_lastknife(%1) get_pdata_cbase(id, OFFSET_LASTKNI)
#define fm_get_weapon_id(%1) get_pdata_int(%1, OFFSET_WEAPONTYPE, EXTRAOFFSET_WEAPONS)

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

// CS Player PData Offsets (win32)
#define PDATA_SAFE 2

// Fowards
enum
{
	FORWARD_NONE = 0,
	FORWARD_INFECTED,
	FORWARD_INFECTED2,
	FORWARD_HUMANIZED,
	FORWARD_HUMANIZED2,
	FORWARD_GAMESTART,
	FORWARD_GAMESTART2,
	FORWARD_SPAWN,
	FORWARD_ROUNDEND,
	FORWARD_ROUNDEND2,
	MAX_FORWARD
}

new g_forwards[MAX_FORWARD], g_fwDummyResult

// Custom GamePlay
enum
{
	START_TYPE_NEW = 0,
	START_ZOMBIE_APPEAR,
	START_ZOMBIE_RELEASE
}

new g_gamestop[3], g_MaxPlayers, g_MsgScoreInfo

// Player Config
new g_ena_background_sound[33]

// Plugin & Precache & Config Zone
public plugin_init()
{
	new map_name[32], check_index
	get_mapname(map_name, sizeof(map_name))
	
	for(check_index = 0; check_index < sizeof(allow_map_prefix); check_index++)
	{
		if(equali(map_name, allow_map_prefix[check_index], strlen(allow_map_prefix[check_index])))
			break
	}
	
	if(check_index == sizeof(allow_map_prefix))
	{
		set_fail_state("[ZE] Wrong Map")
		return
	}  
	
	register_plugin(PLUGIN, VERSION, AUTHOR)
	
	register_cvar("ze_version", VERSION, FCVAR_SERVER|FCVAR_SPONLY)
	set_cvar_string("ze_version", VERSION)	
	
	cvar_fragskill = register_cvar("ze_human_kill_frags", "4")
	
	// Lang
	register_dictionary("zombie_escape.txt")
	
	format(g_WinText[TEAM_T], 63, "Escape Fail")
	format(g_WinText[TEAM_CT], 63, "Escape Success")		
	format(g_WinText[TEAM_ALL], 63, "#Round_Draw")
	format(g_WinText[TEAM_START], 63, "#Game_Commencing")	
	
	register_menu("Equipment", 1023, "action_equip")
	register_menu("Primary", 1023, "action_prim")
	register_menu("Secondary", 1023, "action_sec")
	
	register_clcmd("say !roundsound", "rs_menu")
	register_clcmd("say roundsound", "rs_menu")
	register_clcmd("say /roundsound", "rs_menu")
	register_clcmd("say_team !roundsound", "rs_menu")
	register_clcmd("say_team roundsound", "rs_menu")
	register_clcmd("say_team /roundsound", "rs_menu")

	// Event
	register_event("HLTV", "event_newround", "a", "1=0", "2=0")
	register_logevent("event_roundend", 2, "1=Round_End")
	register_event("TextMsg","event_roundend","a","2=#Game_Commencing","2=#Game_will_restart_in")	
	register_event("CurWeapon", "event_CurWeapon", "be", "1=1")
	register_message(get_user_msgid("TextMsg"), "message_textmsg")
	register_message(get_user_msgid("TeamScore"), "Message_TeamScore")
	// Message
	register_message(get_user_msgid("Health"), "message_health")
	register_message(get_user_msgid("StatusIcon"), "message_StatusIcon")
	
	// Forward & Ham
	register_forward(FM_EmitSound, "fw_EmitSound")
	register_forward(FM_GetGameDescription, "fw_GetGameDesc")

	RegisterHam(Ham_Spawn, "player", "fw_Spawn_Post", 1)
	RegisterHam(Ham_TraceAttack, "player", "fw_TraceAttack")
	RegisterHam(Ham_TakeDamage, "player", "fw_TakeDamage")
	RegisterHam(Ham_Touch, "weaponbox", "fw_TouchWeapon")
	RegisterHam(Ham_Touch, "armoury_entity", "fw_TouchWeapon")
	RegisterHam(Ham_Touch, "weapon_shield", "fw_TouchWeapon")
	register_event("DeathMsg","event_deathmsg","a")

	set_cvar_string("sv_skyname", cfg_skyname)
	
	// Hud
	notice_hud = CreateHudSyncObj(1)
	//score_hud = CreateHudSyncObj(2)
	stat_hud = CreateHudSyncObj(3)
	g_MsgScoreInfo = get_user_msgid("ScoreInfo")
	
	// Cache
	g_MsgDeathMsg = get_user_msgid("DeathMsg")
	g_MaxPlayers = get_maxplayers()	
	
	// Create Forwards
	g_forwards[FORWARD_INFECTED] = CreateMultiForward("ze_user_infected", ET_IGNORE, FP_CELL, FP_CELL)
	g_forwards[FORWARD_INFECTED2] = CreateMultiForward("zp_user_infected_post", ET_IGNORE, FP_CELL, FP_CELL)
	g_forwards[FORWARD_HUMANIZED] = CreateMultiForward("ze_user_humanized", ET_IGNORE, FP_CELL)
	g_forwards[FORWARD_HUMANIZED2] = CreateMultiForward("zp_user_humanized_post", ET_IGNORE, FP_CELL)
	g_forwards[FORWARD_GAMESTART] = CreateMultiForward("ze_gamestart", ET_IGNORE, FP_CELL)
	g_forwards[FORWARD_GAMESTART2] = CreateMultiForward("zp_round_start", ET_IGNORE, FP_CELL)
	g_forwards[FORWARD_ROUNDEND] = CreateMultiForward("ze_roundend", ET_IGNORE, FP_CELL)
	g_forwards[FORWARD_ROUNDEND2] = CreateMultiForward("zp_round_ended", ET_IGNORE, FP_CELL)
	g_forwards[FORWARD_SPAWN] = CreateMultiForward("zp_player_spawn_post", ET_IGNORE, FP_CELL)

	// Some Commands
	register_clcmd("nightvision", "cmd_nightvision")
	register_clcmd("jointeam", "cmd_jointeam")
	register_clcmd("joinclass", "cmd_joinclass")
	register_clcmd("chooseteam", "cmd_jointeam")		
	
	// Reset GamePlay
	native_reset_gameplay(0)
}

public plugin_cfg()
{
	new map_name[32], check_index
	get_mapname(map_name, sizeof(map_name))
	
	for(check_index = 0; check_index < sizeof(allow_map_prefix); check_index++)
	{
		if(equali(map_name, allow_map_prefix[check_index], strlen(allow_map_prefix[check_index])))
			break
	}
	
	if(check_index == sizeof(allow_map_prefix))
		return
	
	//set_cvar_float("mp_freezetime", float(cfg_hum_freeze_time) + 2.0)
	set_cvar_float("mp_freezetime", 0.0)
	set_cvar_float("mp_roundtime", float(cfg_round_time))
}
	
public plugin_precache()
{
	new map_name[32], check_index
	get_mapname(map_name, sizeof(map_name))
	
	for(check_index = 0; check_index < sizeof(allow_map_prefix); check_index++)
	{
		if(equali(map_name, allow_map_prefix[check_index], strlen(allow_map_prefix[check_index])))
			break
	}
	
	if(check_index == sizeof(allow_map_prefix))
		return
	
	// Create Array
	human_model = ArrayCreate(64, 1)
	human_modelindex = ArrayCreate(1, 1)
	host_zombie_model = ArrayCreate(64, 1)
	host_zombie_modelindex = ArrayCreate(1, 1)
	origin_zombie_model = ArrayCreate(64, 1)
	origin_zombie_modelindex = ArrayCreate(1, 1)
	host_zombie_claws_model = ArrayCreate(64, 1)
	zombie_claws_model = ArrayCreate(64, 1)
	v_knife_human = ArrayCreate(64, 1)
	p_knife_human = ArrayCreate(64, 1)
	
	ambience_sound = ArrayCreate(64, 1)
	zombieappear_sound = ArrayCreate(64, 1)
	zombieinfect_sound = ArrayCreate(64, 1)
	
	zombiepain_sound = ArrayCreate(64, 1)
	zombieattack_sound = ArrayCreate(64, 1)
	zombieswing_sound = ArrayCreate(64, 1)
	zombiewall_sound = ArrayCreate(64, 1)
	
	sound_win_humans = ArrayCreate(64, 1)
	sound_win_zombies = ArrayCreate(64, 1)
	sound_win_zombies_name = ArrayCreate(64, 1)
	sound_win_humans_name = ArrayCreate(64, 1)
	
	// Load Custom Config
	load_config_file()
	
	new i, buffer[128], temp_string[256]
	
	// Model
	for(i = 0; i < ArraySize(human_model); i++)
	{
		ArrayGetString(human_model, i, temp_string, sizeof(temp_string))
		ArrayPushCell(human_modelindex, precache_player_model(temp_string))
	}
	for(i = 0; i < ArraySize(origin_zombie_model); i++)
	{
		ArrayGetString(origin_zombie_model, i, temp_string, sizeof(temp_string))
		ArrayPushCell(origin_zombie_modelindex, precache_player_model(temp_string))
	}
	for(i = 0; i < ArraySize(host_zombie_model); i++)
	{
		ArrayGetString(host_zombie_model, i, temp_string, sizeof(temp_string))
		ArrayPushCell(host_zombie_modelindex, precache_player_model(temp_string))
	}
	
	for(i = 0; i < ArraySize(zombie_claws_model); i++)
	{
		ArrayGetString(zombie_claws_model, i, temp_string, sizeof(temp_string))
		precache_model(temp_string)
	}
	
	for(i = 0; i < ArraySize(host_zombie_claws_model); i++)
	{
		ArrayGetString(host_zombie_claws_model, i, temp_string, sizeof(temp_string))
		precache_model(temp_string)
	}

	for(i = 0; i < ArraySize(ambience_sound); i++)
	{
		ArrayGetString(ambience_sound, i, temp_string, sizeof(temp_string))
	
		if(equal(temp_string[strlen(temp_string) - 4], ".mp3"))
		{
			format(buffer, charsmax(buffer), "sound/%s", temp_string)
			precache_generic(buffer)
		} else {
			precache_sound(temp_string)
		}
	}
	for(i = 0; i < ArraySize(zombieappear_sound); i++)
	{
		ArrayGetString(zombieappear_sound, i, temp_string, sizeof(temp_string))
		precache_sound(temp_string)
	}
	for(i = 0; i < ArraySize(zombieinfect_sound); i++)
	{
		ArrayGetString(zombieinfect_sound, i, temp_string, sizeof(temp_string))
		precache_sound(temp_string)
	}
	for(i = 0; i < ArraySize(zombiepain_sound); i++)
	{
		ArrayGetString(zombiepain_sound, i, temp_string, sizeof(temp_string))
		precache_sound(temp_string)
	}
	for(i = 0; i < ArraySize(zombieattack_sound); i++)
	{
		ArrayGetString(zombieattack_sound, i, temp_string, sizeof(temp_string))
		precache_sound(temp_string)
	}
	for(i = 0; i < ArraySize(zombieswing_sound); i++)
	{
		ArrayGetString(zombieswing_sound, i, temp_string, sizeof(temp_string))
		precache_sound(temp_string)
	}
	for(i = 0; i < ArraySize(zombiewall_sound); i++)
	{
		ArrayGetString(zombiewall_sound, i, temp_string, sizeof(temp_string))
		precache_sound(temp_string)
	}
	for (i = 1; i <= 10; i++)
	{
		new sound_count[64]
		format(sound_count, sizeof sound_count - 1, count_sound, i)
		engfunc(EngFunc_PrecacheSound, sound_count)
	}
	for(i = 0; i < ArraySize(sound_win_humans); i++)
	{
		ArrayGetString(sound_win_humans, i, temp_string, sizeof(temp_string))
		precache_sound(temp_string)
	}
	for(i = 0; i < ArraySize(sound_win_zombies); i++)
	{
		ArrayGetString(sound_win_zombies, i, temp_string, sizeof(temp_string))
		precache_sound(temp_string)
	}		
	
	for(i = 0; i < ArraySize(v_knife_human); i++) {
		ArrayGetString(v_knife_human, i, temp_string, sizeof(temp_string))
		precache_model(temp_string)
	}
	
	for(i = 0; i < ArraySize(p_knife_human); i++) {
		ArrayGetString(p_knife_human, i, temp_string, sizeof(temp_string))
		precache_model(temp_string)
	}
	
	formatex(buffer, sizeof(buffer), "gfx/env/%sbk.tga", cfg_skyname)
	precache_generic(buffer)
	formatex(buffer, sizeof(buffer), "gfx/env/%sdn.tga", cfg_skyname)
	precache_generic(buffer)
	formatex(buffer, sizeof(buffer), "gfx/env/%sft.tga", cfg_skyname)
	precache_generic(buffer)
	formatex(buffer, sizeof(buffer), "gfx/env/%slf.tga", cfg_skyname)
	precache_generic(buffer)
	formatex(buffer, sizeof(buffer), "gfx/env/%srt.tga", cfg_skyname)
	precache_generic(buffer)
	formatex(buffer, sizeof(buffer), "gfx/env/%sup.tga", cfg_skyname)
	precache_generic(buffer)	
	
	if(cfg_use_fog == 1)
	{
		static ent
		ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "env_fog"))
		if(pev_valid(ent))
		{
			DispatchKeyValue(ent, "density", cfg_fog_density)
			DispatchKeyValue(ent, "rendercolor", cfg_fog_color)
			DispatchSpawn(ent)
		}
	}
	
	register_forward(FM_Spawn, "fw_Spawn")	
}
	
public fw_Spawn(iEnt)
{
	if (!pev_valid(iEnt))
		return FMRES_IGNORED;
	
	static s_szClassName[32], s_iNum
	pev(iEnt, pev_classname, s_szClassName, 31)
	
	for (s_iNum = 0; s_iNum < sizeof g_szObjectiveClassNames; s_iNum++)
	{
		if (equal(s_szClassName, g_szObjectiveClassNames[s_iNum]))
		{
			engfunc(EngFunc_RemoveEntity, iEnt)
			return FMRES_SUPERCEDE;
		}
	}

	return FMRES_IGNORED
}

public client_putinserver(id)
{
	if(!bot_register && is_user_bot(id))
	{
		bot_register = 1
		set_task(1.0, "do_register", id)
	}
	
	g_showmenu[id] = true
	g_escape_point[id] = 0
	g_ena_background_sound[id] = 1
}

public client_disconnect(player)
{
	if(g_zombie[player] && fnGetZombies() <= 1 && fnGetHumans() > 1) 
	{
		static id
		id = get_random_player(TEAM_ALL, AL_ALIVE)
		set_user_zombie(id, ZOMBIE_TYPE_ORIGIN, 0)
		ExecuteForward(g_forwards[FORWARD_INFECTED], g_fwDummyResult, id, 0)
		ExecuteForward(g_forwards[FORWARD_INFECTED2], g_fwDummyResult, id, 0)
		zp_colored_print(0, "!g[ZE]!t The last Zombie is disconnected, New Zombie was choosed")
	}
	
	if(!g_zombie[player] && fnGetZombies() > 1 && fnGetHumans() <= 1) 
	{
		static id
		id = get_random_player(TEAM_ALL, AL_ALIVE)
		set_user_human(id)
		zp_colored_print(0, "!g[ZE]!t The last Human is disconnected, New Human was choosed")
	}
	
	
	
	//if(fnGetZombies() > 1 && fnGetHumans() <= 1)  
		//team_loose(CS_TEAM_CT)
}

public do_register(id)
{
	RegisterHamFromEntity(Ham_Spawn, id, "fw_Spawn_Post", 1)
	RegisterHamFromEntity(Ham_TakeDamage, id, "fw_TakeDamage")	
	RegisterHamFromEntity(Ham_TraceAttack, id, "fw_TraceAttack")	
}


public load_config_file()
{
	// Build customization file path
	new path[64]
	get_configsdir(path, charsmax(path))
	format(path, charsmax(path), "%s/%s", path, CONFIG_FILE)
	
	// File not present
	if (!file_exists(path))
	{
		new error[100]
		formatex(error, charsmax(error), "[ZE] Can't Load Config File: %s!", path)
		set_fail_state(error)
		return;
	}
	
	// Main Config
	amx_load_setting_int(CONFIG_FILE, "MAIN_CONFIG", "MIN_PLAYER", cfg_min_player)
	amx_load_setting_string(CONFIG_FILE, "MAIN_CONFIG", "DEFAULT_LIGHT", cfg_default_light, charsmax(cfg_default_light))
	amx_load_setting_int(CONFIG_FILE, "MAIN_CONFIG", "ZOMBIE_RELEASE_TIME", cfg_zom_release_time)
	amx_load_setting_int(CONFIG_FILE, "MAIN_CONFIG", "HUMAN_FREEZE_TIME", cfg_hum_freeze_time)
	amx_load_setting_int(CONFIG_FILE, "ROUND_TIME", "HUMAN_FREEZE_TIME", cfg_round_time)

	// Fog
	amx_load_setting_int(CONFIG_FILE, "FOG", "FOG_ENABLE", cfg_use_fog)
	amx_load_setting_string(CONFIG_FILE, "FOG", "FOG_DENSITY", cfg_fog_density, charsmax(cfg_fog_density))
	amx_load_setting_string(CONFIG_FILE, "FOG", "FOG_COLOR", cfg_fog_color, charsmax(cfg_fog_color))

	// Human Config
	amx_load_setting_int(CONFIG_FILE, "HUMAN_CONFIG", "HUMAN_HEALTH", cfg_human_health)
	amx_load_setting_int(CONFIG_FILE, "HUMAN_CONFIG", "HUMAN_ARMOR", cfg_human_armor)
	amx_load_setting_float(CONFIG_FILE, "HUMAN_CONFIG", "HUMAN_GRAVITY", cfg_human_gravity)
	amx_load_setting_float(CONFIG_FILE, "HUMAN_CONFIG", "HUMAN_SPEED", cfg_human_speed)
	
	// Zombie Config
	amx_load_setting_int(CONFIG_FILE, "ZOMBIE_CONFIG", "ZOMBIE_HEALTH", cfg_zombie_health)
	amx_load_setting_int(CONFIG_FILE, "ZOMBIE_CONFIG", "ZOMBIE_ARMOR", cfg_zombie_armor)
	amx_load_setting_float(CONFIG_FILE, "ZOMBIE_CONFIG", "ZOMBIE_GRAVITY", cfg_zombie_gravity)
	amx_load_setting_float(CONFIG_FILE, "ZOMBIE_CONFIG", "ZOMBIE_SPEED", cfg_zombie_speed)
	amx_load_setting_float(CONFIG_FILE, "ZOMBIE_CONFIG", "ZOMBIE_KNOCKBACK_POWER", cfg_zombie_kbpower)

	// Sky
	amx_load_setting_string(CONFIG_FILE, "SKY", "SKY_NAME", cfg_skyname, charsmax(cfg_skyname))
	
	// Model
	amx_load_setting_string_arr(CONFIG_FILE, "MODEL_CONFIG", "HUMAN_MODEL", human_model)
	amx_load_setting_string_arr(CONFIG_FILE, "MODEL_CONFIG", "HUMAN_KNIFE_V_MODEL", v_knife_human)
	amx_load_setting_string_arr(CONFIG_FILE, "MODEL_CONFIG", "HUMAN_KNIFE_P_MODEL", p_knife_human)
	amx_load_setting_string_arr(CONFIG_FILE, "MODEL_CONFIG", "ZOMBIE_ORIGIN_MODEL", origin_zombie_model)
	amx_load_setting_string_arr(CONFIG_FILE, "MODEL_CONFIG", "ZOMBIE_HOST_MODEL", host_zombie_model)
	amx_load_setting_string_arr(CONFIG_FILE, "MODEL_CONFIG", "ZOMBIE_CLAW_MODEL", zombie_claws_model)
	amx_load_setting_string_arr(CONFIG_FILE, "MODEL_CONFIG", "HOST_ZOMBIE_CLAW_MODEL", host_zombie_claws_model)
	
	// Sounds
	amx_load_setting_string_arr(CONFIG_FILE, "SOUND_CONFIG", "AMBIENCE", ambience_sound)
	amx_load_setting_string_arr(CONFIG_FILE, "SOUND_CONFIG", "ZOMBIE_APPEAR", zombieappear_sound)
	amx_load_setting_string_arr(CONFIG_FILE, "SOUND_CONFIG", "PLAYER_INFECT", zombieinfect_sound)
	amx_load_setting_string_arr(CONFIG_FILE, "SOUND_CONFIG", "ZOMBIE_PAIN", zombiepain_sound)
	amx_load_setting_string(CONFIG_FILE, "SOUND_CONFIG", "COUNTDOWN", count_sound, charsmax(count_sound))
	amx_load_setting_string_arr(CONFIG_FILE, "SOUND_CONFIG", "ESCAPE_SUCCESS", sound_win_humans)
	amx_load_setting_string_arr(CONFIG_FILE, "SOUND_CONFIG", "ESCAPE_FAIL", sound_win_zombies)
	amx_load_setting_string_arr(CONFIG_FILE, "SOUND_CONFIG", "ESCAPE_SUCCESS_MUSIC_NAME", sound_win_humans_name)
	amx_load_setting_string_arr(CONFIG_FILE, "SOUND_CONFIG", "ESCAPE_FAIL_MUSIC_NAME", sound_win_zombies_name)
	amx_load_setting_string_arr(CONFIG_FILE, "SOUND_CONFIG", "ATTACK_HIT", zombieattack_sound)
	amx_load_setting_string_arr(CONFIG_FILE, "SOUND_CONFIG", "ATTACK_MISS", zombieswing_sound)
	amx_load_setting_string_arr(CONFIG_FILE, "SOUND_CONFIG", "ATTACK_WALL", zombiewall_sound)
}

public plugin_natives()
{
	new map_name[32], check_index
	get_mapname(map_name, sizeof(map_name))
	
	for(check_index = 0; check_index < sizeof(allow_map_prefix); check_index++)
	{
		if(equali(map_name, allow_map_prefix[check_index], strlen(allow_map_prefix[check_index])))
			break
	}
	
	if(check_index == sizeof(allow_map_prefix))
		return
		
	// Check
	register_native("ze_is_user_zombie", "native_get_zombie", 1)
	register_native("zp_get_user_zombie", "native_get_zombie", 1)
	register_native("ze_get_zombie_type", "native_get_zombie_type", 1)
	register_native("ze_set_knock_immune", "native_set_knock_immune", 1)
	register_native("ze_get_knock_immune", "native_get_knock_immune", 1)
	
	// Set
	register_native("ze_set_user_zombie", "native_set_zombie", 1)
	register_native("zp_infect_user", "native_set_zombie", 1)
	register_native("ze_set_user_human", "native_set_human", 1)
	register_native("zp_disinfect_user", "native_set_human", 1)
	
	// GamePlays
	register_native("ze_set_stopgame", "native_set_stopgame", 1)
	register_native("ze_reset_gameplay", "native_reset_gameplay", 1)
	register_native("zp_do_random_spawn", "native_do_random", 1)
	register_native("zp_has_round_started", "native_round_start", 1)
	register_native("zp_get_user_maxspeed", "native_get_maxspeed", 1)
	register_native("zp_set_extra_damage", "native_set_extra_damage", 1)
	register_native("zp_has_round_ended", "native_has_round_ended", 1)
	
	// Nao Encher mais o saco de incompatiblidade por causa dessas natives
	register_native("zp_get_user_last_human", "native_last_h", 1)
	register_native("zp_get_user_last_zombie", "native_last_z", 1)
	
	register_native("zp_get_user_nemesis", "native_return", 1)
	register_native("zp_get_user_survivor", "native_return", 1)
	register_native("zp_get_user_assassin", "native_return", 1)
	register_native("zp_get_user_sniper", "native_return", 1)
	register_native("zp_get_user_berserker", "native_return", 1)
	register_native("zp_get_user_predator", "native_return", 1)
	register_native("zp_get_user_wesker", "native_return", 1)
	register_native("zp_get_user_dragon", "native_return", 1)
	register_native("zp_get_user_bombardier", "native_return", 1)
	register_native("zp_get_user_spy", "native_return", 1)
	register_native("zp_is_nemesis_round", "native_return", 1)
	register_native("zp_is_assassin_round", "native_return", 1)
	register_native("zp_is_berserker_round", "native_return", 1)
	register_native("zp_is_wesker_round", "native_return", 1)
	register_native("zp_is_spy_round", "native_return", 1)
	register_native("zp_is_bombardier_round", "native_return", 1)
	register_native("zp_is_dragon_round", "native_return", 1)
	register_native("zp_is_sniper_round", "native_return", 1)
	register_native("zp_is_survivor_round", "native_return", 1)
	register_native("zp_is_predator_round", "native_return", 1)
	register_native("zp_is_plague_round", "native_return", 1)
	register_native("zp_is_swarm_round", "native_return", 1)
	register_native("zp_get_human_special_class", "native_return", 1)
	register_native("zp_get_zombie_special_class", "native_return", 1)
	register_native("zp_is_escape_map", "native_return_positive", 1)
	
}
// End of Plugin & Precache & Config Zone

// Native
public native_get_zombie(id)
{
	if(!is_user_connected(id))
		return 0 
	if(!is_user_alive(id))
		return 0
		
	return g_zombie[id]
}

public native_get_zombie_type(id)
{
	if(!is_user_connected(id))
		return -1
	if(!is_user_alive(id))
		return -1
		
	return g_zombie_type[id]
}

public native_set_zombie(id, zombie_type)
{
	if(!is_user_connected(id))
		return 0 
	if(!is_user_alive(id))
		return 0
	if(g_zombie[id])
		return 0
		
	set_user_zombie(id, zombie_type, 1)
	return 1
}

public native_set_human(id)
{
	if(!is_user_connected(id))
		return 0 
	if(!is_user_alive(id))
		return 0	
		
	set_user_human(id)
	
	return 0
}

public set_user_human(id)
{
	if(!is_user_alive(id))
		return	
	
	set_human_stuff(id)
	
	g_zombie[id] = false
	g_zombie_type[id] = 0
	g_nvg[id] = 0
	g_menufailsafe[id] = false
	g_escape_point[id] = 0
	
	if(TASKID_WEAPONSMENU + id) remove_task(TASKID_WEAPONSMENU + id)
	
	if(g_showmenu[id])
		display_equipmenu(id)
	else {
		equipweapon(id, EQUIP_ALL)
	}
}

public native_set_stopgame(stop_type, stop)
{
	g_gamestop[stop_type] = stop
	return 1
}

public native_reset_gameplay(restart)
{
	g_gamestop[START_TYPE_NEW] = 0
	g_gamestop[START_ZOMBIE_APPEAR] = 0
	g_gamestop[START_ZOMBIE_RELEASE] = 0
	
	if(restart) server_cmd("sv_restart 1")
}
// End Of Native

// Event: New Round
public event_newround()
{
	ExecuteForward(g_forwards[FORWARD_GAMESTART], g_fwDummyResult, g_gamestart)
	ExecuteForward(g_forwards[FORWARD_GAMESTART2], g_fwDummyResult, g_gamestart)
	
	// Reset Vars
	g_endround = 0
	g_gamestart = 0
	g_count = cfg_hum_freeze_time
	
	// Remove Task
	remove_task(TASK_COUNTDOWN)
	remove_task(TASK_COUNTDOWN2)
	remove_task(TASK_ROUNDTIME)
	
	if(g_gamestop[START_TYPE_NEW])
		return
	
	set_task(9.0, "ambience_sound_stop", 123091293)
	set_task(0.1, "event_newround2")	
}

public event_newround2()
{
	if(get_player_num(TEAM_ALL, AL_ALIVE) < cfg_min_player)
	{
		zp_colored_print(0, "!g[Zombie Escape]!n %L", OFFICIAL_LANG, "NOT_ENOUGH_PLAYER", cfg_min_player)
		g_started = 0
		
		return
	}
	
	zp_colored_print(0, "!g[Zombie Escape]!n %L", OFFICIAL_LANG, "GOOD_LUCK")
	
	set_task(1.0, "do_countdown", TASK_COUNTDOWN, _, _, "b")
	
	balance_teams()
	//set_task(get_cvar_float("mp_roundtime") * 60.0 + 43.0, "do_zombie_win", TASK_ROUNDTIME)	
}

public do_countdown(taskid)
{
	if(g_endround)
	{
		remove_task(taskid)
		return
	}
	
	if (!g_count)
	{
		start_game_now()
		remove_task(taskid)
		return
	}

	if (g_count <= cfg_hum_freeze_time)
	{
		static sound[64]
		formatex(sound, charsmax(sound), count_sound, g_count)
		PlaySound(0, sound)
	}
	
	new message[64]
	format(message, charsmax(message), "%L", OFFICIAL_LANG, "RUN_READY_COUNTDOWN", g_count)
	client_print(0, print_center, message)
	
	g_count--
}
// End of Event: New Round

// Event: Round End
public event_roundend()
{
	ambience_sound_stop(0)
	End_Round()
	//balance_teams()
	//g_endround = 1
	
	remove_task(TASK_COUNTDOWN)
	remove_task(TASK_COUNTDOWN2)
	for(new i = 0; i < g_MaxPlayers; i++)
		remove_task(i+TASK_AMBIENCE)
		

	remove_task(TASK_ROUNDTIME)	
}

// End of Event: Round End

public cmd_jointeam(id)
{	
	if(!is_user_connected(id))
		return 1
	
	if(cs_get_user_team(id) == CS_TEAM_CT || cs_get_user_team(id) == CS_TEAM_T)
	{
		open_game_menu(id)
		return 1
	}
	
	return PLUGIN_CONTINUE
}

public cmd_joinclass(id)
{
	if(!is_user_connected(id))
		return 1

	if(cs_get_user_team(id) != CS_TEAM_CT || cs_get_user_team(id) != CS_TEAM_T)
		return 0
	
	if(g_started && (g_gamestart == 1 || g_gamestart == 2))
	{
		cs_set_user_team(id, CS_TEAM_CT)
		
		g_zombie[id] = false
		g_zombie_type[id] = 0
		g_nvg[id] = 0
		g_menufailsafe[id] = false
		
		if(TASKID_WEAPONSMENU + id) remove_task(TASKID_WEAPONSMENU + id)
	}
	
	return 0
}

public open_game_menu(id)
{
	static menu, string[128]
	
	formatex(string, sizeof(string), "%L", OFFICIAL_LANG, "GAME_MENU_NAME")
	menu = menu_create(string, "gamem_handle")
	
	// Enable Equipment Menu
	formatex(string, sizeof(string), "%L", OFFICIAL_LANG, "EQUIPMENT_NAME")
	menu_additem(menu, string, "1", 0)
	
	// Game Infomation
	formatex(string, sizeof(string), "%L", OFFICIAL_LANG, "GAMEINFO_NAME")
	menu_additem(menu, string, "2", 0)
	
	// Game Infomation
	formatex(string, sizeof(string), "%L", OFFICIAL_LANG, "PCONFIG_NAME")
	menu_additem(menu, string, "3", 0)	
	
        // Game Infomation
        formatex(string, sizeof(string), "%L", OFFICIAL_LANG, "EXTRAITEMSHOP_NAME")
        menu_additem(menu, string, "4", 0) 
	
	menu_setprop(menu, MPROP_EXIT, MEXIT_ALL)
	menu_display(id, menu, 0)
}

public gamem_handle(id, menu, item)
{
	if(!is_user_connected(id))
		return
	
	if(item == MENU_EXIT)
	{
		menu_destroy(menu)
		return
	}
	
	new data[6], szName[64];
	new access, callback;
	
	menu_item_getinfo(menu, item, access, data,charsmax(data), szName,charsmax(szName), callback);
	
	new key = str_to_num(data);
	
	switch(key)
	{
		case 1: // Equipment
		{
			g_showmenu[id] = true
			zp_colored_print(id, "!g[Zombie Escape]!n %L", OFFICIAL_LANG, "EQUIP_ENABLE")
		}
		case 2: // Game Info
		{
			static string_name[128], string_data[1028]
			
			// Game Infomation
			formatex(string_name, sizeof(string_name), "%L", OFFICIAL_LANG, "GAMEINFO_NAME")
			formatex(string_data, sizeof(string_data), "%L", OFFICIAL_LANG, "GAME_INFORMATION")
			
			show_motd(id, string_data, string_name)
		}	
		case 3: // Player Config
		{
			player_config(id)
		}			
		case 4: // Shop Menu
		{
		   client_cmd(id, "say /shop");
		}	
	}
	
	return
}

// Player Config
public player_config(id)
{
	static menu, string[128], on_off[10]
	
	formatex(string, sizeof(string), "%L", OFFICIAL_LANG, "PCONFIG_NAME")
	menu = menu_create(string, "pconfig_handle")
	
	// Background Sound
	if(g_ena_background_sound[id])
	{
		formatex(on_off, sizeof(on_off), "%L", OFFICIAL_LANG, "PCONFIG_ON")
		formatex(string, sizeof(string), "%L	\y%s", OFFICIAL_LANG, "PCONFIG_BACKGROUND_SOUND", on_off)
	} else {
		formatex(on_off, sizeof(on_off), "%L", OFFICIAL_LANG, "PCONFIG_OFF")
		formatex(string, sizeof(string), "%L	\r%s", OFFICIAL_LANG, "PCONFIG_BACKGROUND_SOUND", on_off)	
	}
	menu_additem(menu, string, "2", 0)
	
	menu_setprop(menu, MPROP_EXIT, MEXIT_ALL)
	menu_display(id, menu, 0)	
}

public pconfig_handle(id, menu, item)
{
	if(!is_user_connected(id))
		return
	
	if(item == MENU_EXIT)
	{
		menu_destroy(menu)
		return
	}
	
	new data[6], szName[64];
	new access, callback;
	
	menu_item_getinfo(menu, item, access, data,charsmax(data), szName,charsmax(szName), callback);
	
	new key = str_to_num(data);
	
	switch(key)
	{
		case 2: // Background Sound
		{
			if(g_ena_background_sound[id])
			{
				g_ena_background_sound[id] = 0
				if(g_gamestart > 0) ambience_sound_stop(id)
			} else {
				g_ena_background_sound[id] = 1
				if(g_gamestart > 0)
				{
					static temp_string[128]
					ArrayGetString(ambience_sound, random_num(0, ArraySize(ambience_sound) - 1), temp_string, sizeof(temp_string))
	
					PlaySound(id, temp_string)	
					set_task(105.0, "check_ambience_sound", id+TASK_AMBIENCE, _, _, "b")	
				}
			}
			player_config(id)			
		}
	}
}

// NightVision
public cmd_nightvision(id)
{
	if (!is_user_alive(id) || !g_zombie[id]) return PLUGIN_HANDLED;
	
	if (!g_nvg[id])
	{
		SwitchNvg(id, 1)
		PlaySound(id, sound_nvg[1])
	}
	else
	{
		SwitchNvg(id, 0)
		PlaySound(id, sound_nvg[0])
	}	
	
	return PLUGIN_CONTINUE
}

public SwitchNvg(id, mode)
{
	if (!is_user_connected(id)) return;
	
	g_nvg[id] = mode
	set_user_nvision(id)
}

public set_user_nvision(id)
{	
	if (!is_user_connected(id)) return;
	
	new alpha
	if (g_nvg[id]) alpha = 70
	else alpha = 0
	
	message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("ScreenFade"), _, id)
	write_short(0) // duration
	write_short(0) // hold time
	write_short(0x0004) // fade type
	write_byte(253) // r
	write_byte(110) // g
	write_byte(110) // b
	write_byte(alpha) // alpha
	message_end()
	
	if(g_nvg[id])
	{
		set_player_light(id, "z")
		} else {
		set_player_light(id, cfg_default_light)
	}
}

public set_player_light(id, const LightStyle[])
{
	message_begin(MSG_ONE_UNRELIABLE, SVC_LIGHTSTYLE, .player = id)
	write_byte(0)
	write_string(LightStyle)
	message_end()
}
// End of NightVision

// Start Game
public start_game_now()
{
	g_gamestart = 1
	
	static temp_string[128]
	ArrayGetString(ambience_sound, random_num(0, ArraySize(ambience_sound) - 1), temp_string, sizeof(temp_string))
	
	for(new i = 0; i < g_MaxPlayers; i++)
	{
		if(!is_user_connected(i))
			continue;
	
		if(g_ena_background_sound) {
			PlaySound(i, temp_string)	
			set_task(105.0, "check_ambience_sound", i+TASK_AMBIENCE, _, _, "b")
		}
	}
	
	if(g_gamestop[START_ZOMBIE_APPEAR])
	{
		ExecuteForward(g_forwards[FORWARD_GAMESTART], g_fwDummyResult, g_gamestart)
		ExecuteForward(g_forwards[FORWARD_GAMESTART2], g_fwDummyResult, g_gamestart)
		return
	}
		
	// Make Zombies
	static id
	for(new i = 0; i < require_zombie(); i++)
	{
		id = get_random_player(TEAM_ALL, AL_ALIVE)
		//set_user_zombie(zp_get_random_alive(), ZOMBIE_TYPE_ORIGIN, 0)
		//set_user_zombie(get_random_player(TEAM_CT, AL_ALIVE), ZOMBIE_TYPE_ORIGIN, 0)
		set_user_zombie(id, ZOMBIE_TYPE_ORIGIN, 0)
		ExecuteForward(g_forwards[FORWARD_INFECTED], g_fwDummyResult, id, 0)
		ExecuteForward(g_forwards[FORWARD_INFECTED2], g_fwDummyResult, id, 0)
	}
	
	g_count = cfg_zom_release_time
	set_task(1.0, "do_count_rezombie", TASK_COUNTDOWN2, _, _, "b")
	
	for(new i = 0; i < g_MaxPlayers; i++)
	{
		if(is_user_connected(i) && is_user_alive(i) && !g_zombie)
		{
			cs_reset_player_maxspeed(i)
			
			cs_set_player_maxspeed(i, cfg_human_speed, 0)
			set_user_gravity(i, cfg_human_gravity)
		}
	}

	update_team()

	ExecuteForward(g_forwards[FORWARD_GAMESTART], g_fwDummyResult, g_gamestart)
	ExecuteForward(g_forwards[FORWARD_GAMESTART2], g_fwDummyResult, g_gamestart)
}

public check_ambience_sound(id)
{
	id -= TASK_AMBIENCE
	
	if(g_endround)
	{
		remove_task(id+TASK_AMBIENCE)
		return
	}
	if(!g_ena_background_sound[id])
	{
		remove_task(id+TASK_AMBIENCE)
		return		
	}
	
	static temp_string[128]
	ArrayGetString(ambience_sound, random_num(0, ArraySize(ambience_sound) - 1), temp_string, sizeof(temp_string))
	
	PlaySound(id, temp_string)	
}

public do_count_rezombie(taskid)
{
	if(g_endround)
	{
		remove_task(taskid)
		return
	}
	
	if (!g_count)
	{
		release_zombie()
		remove_task(taskid)
		return
	}
	
	set_hudmessage(255, 255, 0, -1.0, 0.21, 1, 2.0, 2.0)
	ShowSyncHudMsg(0, notice_hud, "%L", OFFICIAL_LANG, "ZOMBIE_RELEASE_COUNTDOWN", g_count)
	
	g_count--
}
// End of Start Game

// Game Main
public release_zombie()
{
	g_gamestart = 2
	
	if(g_gamestop[START_ZOMBIE_RELEASE])
	{
		ExecuteForward(g_forwards[FORWARD_GAMESTART], g_fwDummyResult, g_gamestart)
		ExecuteForward(g_forwards[FORWARD_GAMESTART2], g_fwDummyResult, g_gamestart)
		return
	}
	
	for(new i = 0; i < g_MaxPlayers; i++)
	{
		if(!is_user_connected(i) || !is_user_alive(i))
			continue
		if(!g_zombie)
			continue
		
		cs_set_player_maxspeed(i, cfg_zombie_speed, 0)
		set_user_gravity(i,  cfg_zombie_gravity)		
	}
	
	//update_team()
	ExecuteForward(g_forwards[FORWARD_GAMESTART], g_fwDummyResult, g_gamestart)	
	ExecuteForward(g_forwards[FORWARD_GAMESTART2], g_fwDummyResult, g_gamestart)	
}

public client_PostThink(id)
{
	if(!is_user_connected(id))
		return
	
	if(get_gametime() - 1.0 > delay_hud[id])
	{
		// Show Score
		//set_hudmessage(255, 255, 255, -1.0, 0.0, 0, 2.0, 2.0)
		//ShowSyncHudMsg(id, score_hud, "%L", OFFICIAL_LANG, "HUD_SCORE", g_team_score[TEAM_T], g_team_score[TEAM_CT])
		
		// Add Point for Who is Running Fast
		if(!g_zombie[id])
		{
			static Float:Velocity[3], Speed
			
			pev(id, pev_velocity, Velocity)
			Speed = floatround(vector_length(Velocity))
			
			switch(Speed)
			{
				case 210..229: g_escape_point[id] += 1
				case 230..249: g_escape_point[id] += 2
				case 250..300: g_escape_point[id] += 3
			}
		}
		
		// Show Stat
		//show_stat(id)
		delay_hud[id] = get_gametime()
	}
	
	if(!g_gamestart && g_started)
	{
		if(!is_user_connected(id) || !is_user_alive(id))
			return
		
		cs_set_player_maxspeed(id, 0.1, 0)
	} 
	else {
		if(cs_get_user_team(id) == CS_TEAM_T && !g_zombie[id]) 
			set_human_stuff(id)
	}
}

public show_stat(id)
{
	get_stat()
	new temp_string_first[64], temp_string_second[64], temp_string_third[64], curid, Player_Name[64], none[32]
	
	formatex(none, sizeof(none), "%L", OFFICIAL_LANG, "RANK_NONE")
	
	// Rank First
	curid = g_escape_rank[RANK_FIRST]
	if(is_user_alive(curid) && !g_zombie[curid] && g_escape_point[curid] != 0)
	{
		get_user_name(curid, Player_Name, sizeof(Player_Name))
		formatex(temp_string_first, sizeof(temp_string_first), "%L", OFFICIAL_LANG, "RANK_FIRST", Player_Name)
	} else {
		get_user_name(curid, Player_Name, sizeof(Player_Name))
		formatex(temp_string_first, sizeof(temp_string_first), "%L", OFFICIAL_LANG, "RANK_FIRST", none)	
	}
	
	// Rank Second
	curid = g_escape_rank[RANK_SECOND]
	if(is_user_alive(curid) && !g_zombie[curid] && g_escape_point[curid] != 0)
	{
		get_user_name(curid, Player_Name, sizeof(Player_Name))
		formatex(temp_string_second, sizeof(temp_string_second), "%L", OFFICIAL_LANG, "RANK_SECOND", Player_Name)
	} else {
		get_user_name(curid, Player_Name, sizeof(Player_Name))
		formatex(temp_string_second, sizeof(temp_string_second), "%L", OFFICIAL_LANG, "RANK_SECOND", none)	
	}
	
	// Rank Third
	curid = g_escape_rank[RANK_THIRD]
	if(is_user_alive(curid) && !g_zombie[curid] && g_escape_point[curid] != 0)
	{
		get_user_name(curid, Player_Name, sizeof(Player_Name))
		formatex(temp_string_third, sizeof(temp_string_third), "%L", OFFICIAL_LANG, "RANK_THIRD", Player_Name)
	} else {
		get_user_name(curid, Player_Name, sizeof(Player_Name))
		formatex(temp_string_third, sizeof(temp_string_third), "%L", OFFICIAL_LANG, "RANK_THIRD", none)	
	}	

	set_hudmessage(0, 255, 0, 0.05, 0.30, 0, 2.0, 2.0)
	ShowSyncHudMsg(id, stat_hud, "%L^n%s^n%s^n%s", OFFICIAL_LANG, "RANK_INFO", temp_string_first, temp_string_second, temp_string_third)	
}

public get_stat()
{
	static highest, current
	highest = current = 0
	
	// Rank First
	for(new i = 0; i < g_MaxPlayers; i++)
	{
		if(!is_user_connected(i))
			continue
		if(!is_user_alive(i))
			continue
		if(g_zombie)
			continue
			
		if(g_escape_point > highest)
		{
			current = i
			highest = g_escape_point
		}
	}
	g_escape_rank[RANK_FIRST] = current
	
	// Rank Second
	highest = current = 0	
	for(new i = 0; i < g_MaxPlayers; i++)
	{
		if(!is_user_connected(i))
			continue
		if(!is_user_alive(i))
			continue
		if(g_zombie)
			continue			
		if(g_escape_rank[RANK_FIRST] == i)
			continue
			
		if(g_escape_point > highest)
		{
			current = i
			highest = g_escape_point
		}
	}
	g_escape_rank[RANK_SECOND] = current		
	
	// Rank Third
	highest = current = 0	
	for(new i = 0; i < g_MaxPlayers; i++)
	{
		if(!is_user_connected(i))
			continue
		if(!is_user_alive(i))
			continue
		if(g_zombie)
			continue			
		if(g_escape_rank[RANK_FIRST] == i || g_escape_rank[RANK_SECOND] == i)
			continue
			
		if(g_escape_point[i] > highest)
		{
			current = i
			highest = g_escape_point[i]
		}
	}
	g_escape_rank[RANK_THIRD] = current	
}
public delay_team(id) if(is_user_alive(id) && g_zombie[id]) cs_set_user_team(id, CS_TEAM_T)
public set_user_zombie(id, zombie_type, forward_exec)
{
	g_zombie[id] = true
	g_zombie_type[id] = zombie_type
	set_task(0.1, "delay_team", id)
	
	set_user_health(id, zombie_type == 0 ? floatround(float(cfg_zombie_health) / 2.0) : cfg_zombie_health)
	set_user_armor(id, cfg_zombie_armor)
	
	if(zombie_type == ZOMBIE_TYPE_HOST)
	{
		cs_set_player_maxspeed(id, cfg_zombie_speed, 0)
		set_user_gravity(id, cfg_zombie_gravity)
	} else {
		if(!forward_exec)
			cs_set_player_maxspeed(id, 0.1, 0)
		else
			cs_set_player_maxspeed(id, cfg_zombie_speed, 0)
		set_user_gravity(id, cfg_zombie_gravity)		
	}
	
	static temp_string[128], temp_string2[128], random1
	if(!zombie_type) // Host
	{
		random1 = random_num(0, ArraySize(origin_zombie_model) - 1)
		
		ArrayGetString(host_zombie_model, random1, temp_string, sizeof(temp_string))
		cs_set_player_model(id, temp_string)
		
	} 
	else 
	{ 
		// Origin
		random1 = random_num(0, ArraySize(origin_zombie_model) - 1)
		
		ArrayGetString(origin_zombie_model, random1, temp_string, sizeof(temp_string))
		cs_set_player_model(id, temp_string)	
	}
	
	set_default_zombie(id, zombie_type)
	
	ArrayGetString(zombieinfect_sound, random_num(0, ArraySize(zombieinfect_sound) - 1), temp_string, sizeof(temp_string))
	ArrayGetString(zombieappear_sound, random_num(0, ArraySize(zombieappear_sound) - 1), temp_string2, sizeof(temp_string2))
	
	emit_sound(id, CHAN_BODY, temp_string, 1.0, ATTN_NORM, 0, PITCH_NORM)
	PlaySound(0, temp_string2)
	
	SwitchNvg(id, 1)
	PlaySound(id, sound_nvg[1])	
	
	//update_team()	
	//check_win_con()
}

public set_player_model(id)
{
	if(!is_user_alive(id))
		return
	
	if(!g_zombie[id])
		return
	
	static temp_string[128], random1
	if(!g_zombie_type[id]) // Host
	{
		random1 = random_num(0, ArraySize(origin_zombie_model) - 1)
		
		ArrayGetString(host_zombie_model, random1, temp_string, sizeof(temp_string))
		cs_set_player_model(id, temp_string)
		
	} 
	else 
	{ 
		// Origin
		random1 = random_num(0, ArraySize(origin_zombie_model) - 1)
		
		ArrayGetString(origin_zombie_model, random1, temp_string, sizeof(temp_string))
		cs_set_player_model(id, temp_string)	
	}
}

stock set_default_zombie(id, zombie_type)
{
	if(!is_user_alive(id))
		return
	if(!g_zombie[id])
		return
	
	// Set Spawn Origin
	if(zombie_type == ZOMBIE_TYPE_ORIGIN) set_pev(id, pev_origin, g_spawn_origin[id])
	
	// Remove any zoom (bugfix)
	cs_set_user_zoom(id, CS_RESET_ZOOM, 1)
	
	// Remove armor
	cs_set_user_armor(id, 0, CS_ARMOR_NONE)
	
	// Drop weapons when infected
	drop_weapons(id, 1)
	drop_weapons(id, 2)
	
	// Strip zombies from guns and give them a knife
	strip_user_weapons(id)
	give_item(id, "weapon_knife")
}

public event_CurWeapon(id)
{
	if(!is_user_alive(id))
		return 1
	
	if(g_zombie[id]) 
	{
		if(get_user_weapon(id) != CSW_KNIFE)
		{
			drop_weapons(id, 1)
			drop_weapons(id, 2)
			
			engclient_cmd(id, "weapon_knife")
		} 
		else 
		{
			static temp_string[128]
			if(!g_zombie_type[id]) ArrayGetString(host_zombie_claws_model, random_num(0, ArraySize(host_zombie_claws_model) - 1), temp_string, sizeof(temp_string))
			else ArrayGetString(zombie_claws_model, random_num(0, ArraySize(zombie_claws_model) - 1), temp_string, sizeof(temp_string))
			
			set_pev(id, pev_viewmodel2, temp_string)
			set_pev(id, pev_weaponmodel2, "")
		}
	}
	else {
		if(get_user_weapon(id) == CSW_KNIFE) {
			static temp_string[128], kid
			kid = random_num(0, ArraySize(v_knife_human) - 1)
	
			ArrayGetString(v_knife_human, kid, temp_string, sizeof(temp_string))
			set_pev(id, pev_viewmodel2, temp_string)
			
			ArrayGetString(p_knife_human, kid, temp_string, sizeof(temp_string))
			set_pev(id, pev_weaponmodel2, temp_string)
		}
	}

	return 0
}

// End of Game Main
/*public check_win_con()
{
	if(g_endround)
		return
	if(!g_gamestart)
		return
	
	if(get_player_num(TEAM_T, AL_ALIVE) == 0)
	{
		End_Round(5.0, 0, CS_TEAM_CT)
	} 
	else if(get_player_num(TEAM_CT, AL_ALIVE) == 0) 
	{
		End_Round(5.0, 0, CS_TEAM_T)
	}
}

public do_zombie_win()
{
	End_Round(5.0, 0, CS_TEAM_T)
}
*/
// Message
public message_StatusIcon(msg_id, msg_dest, msg_entity)
{
	static szMsg[8];
	get_msg_arg_string(2, szMsg ,7);
	
	if(equal(szMsg, "buyzone") && get_msg_arg_int(1))
	{
		set_pdata_int(msg_entity, 235, get_pdata_int(msg_entity, 235) & ~(1<<0));
		return PLUGIN_HANDLED;
	}
	
	return PLUGIN_CONTINUE;
}

public message_health(msg_id, msg_dest, msg_entity)
{
	static health
	health = get_msg_arg_int(1)
	
	if(health > 255)	
		set_msg_arg_int(1, get_msg_argtype(1), 255)
}
// End of Message

// Ham
public fw_EmitSound(id, channel, const sample[], Float:volume, Float:attn, flags, pitch)
{
	// Block all those unneeeded hostage sounds
	if (sample[0] == 'h' && sample[1] == 'o' && sample[2] == 's' && sample[3] == 't' && sample[4] == 'a' && sample[5] == 'g' && sample[6] == 'e')
		return FMRES_SUPERCEDE;
	
	// Replace these next sounds for zombies only
	if (!is_user_connected(id) || !g_zombie[id])
		return FMRES_IGNORED;
	
	static temp_string[128]
	
	// Zombie being hit
	if (sample[7] == 'b' && sample[8] == 'h' && sample[9] == 'i' && sample[10] == 't' ||
	sample[7] == 'h' && sample[8] == 'e' && sample[9] == 'a' && sample[10] == 'd')
	{
		ArrayGetString(zombiepain_sound, random_num(0, ArraySize(zombiepain_sound) - 1), temp_string, sizeof(temp_string))
		emit_sound(id, channel, temp_string, volume, attn, flags, pitch)
		
		return FMRES_SUPERCEDE;
	}
	
	// Zombie Attack
	new attack_type
	if (equal(sample,"weapons/knife_hitwall1.wav")) attack_type = 1
	else if (equal(sample,"weapons/knife_hit1.wav") ||
	equal(sample,"weapons/knife_hit3.wav") ||
	equal(sample,"weapons/knife_hit2.wav") ||
	equal(sample,"weapons/knife_hit4.wav") ||
	equal(sample,"weapons/knife_stab.wav")) attack_type = 2
	else if(equal(sample,"weapons/knife_slash1.wav") ||
		equal(sample,"weapons/knife_slash2.wav")) attack_type = 3
	if (attack_type)
	{
		if (attack_type == 1)
		{
			ArrayGetString(zombiewall_sound, random_num(0, ArraySize(zombiewall_sound) - 1), temp_string, sizeof(temp_string))
			emit_sound(id, channel, temp_string, volume, attn, flags, pitch)
			} else if (attack_type == 2) {
			ArrayGetString(zombieattack_sound, random_num(0, ArraySize(zombieattack_sound) - 1), temp_string, sizeof(temp_string))
			emit_sound(id, channel, temp_string, volume, attn, flags, pitch)
			} else if (attack_type == 3) {
			ArrayGetString(zombieswing_sound, random_num(0, ArraySize(zombieswing_sound) - 1), temp_string, sizeof(temp_string))
			emit_sound(id, channel, temp_string, volume, attn, flags, pitch)
		}
		
		return FMRES_SUPERCEDE;
	}
	
	return FMRES_IGNORED;
}

public fw_GetGameDesc()
{
	static GameName[64]
	formatex(GameName, sizeof(GameName), "%s %s", PLUGIN, VERSION)
	
	forward_return(FMV_STRING, GameName)
	return FMRES_SUPERCEDE
}

public fw_Spawn_Post(id)
{
	if (get_player_num(TEAM_ALL, AL_ALIVE) > 1 && !g_started)
	{
		g_started = 1
		server_cmd("sv_restart 1")
	}		
	
	if(!is_user_connected(id))
		return HAM_IGNORED
	
	if(!cs_get_user_team(id))
		return HAM_IGNORED
	
	// Get Your Origin
	pev(id, pev_origin, g_spawn_origin[id])
	
	if(g_gamestart)
	{
		set_user_zombie(id, ZOMBIE_TYPE_ORIGIN, g_gamestart == 2 ? 1 : 0)
		set_task(0.5, "set_player_model", id)
		return HAM_IGNORED
	}	

	g_zombie[id] = false
	g_zombie_type[id] = 0
	g_nvg[id] = 0
	g_menufailsafe[id] = false
	g_escape_point[id] = 0
	
	if(TASKID_WEAPONSMENU + id) remove_task(TASKID_WEAPONSMENU + id)
	
	set_task(random_float(0.1, 0.5), "set_user_nvision", id)
	set_human_stuff(id)
	
	if(g_showmenu[id])
		display_equipmenu(id)
	else
	{
		equipweapon(id, EQUIP_ALL)
	}
	
	ExecuteForward(g_forwards[FORWARD_SPAWN], g_fwDummyResult, id)
	
	//return HAM_HANDLED
	return HAM_IGNORED
}

public display_equipmenu(id)
{
	static menubody[512], len
	len = formatex(menubody, 511, "\y%L^n^n", OFFICIAL_LANG, "WPNMENU_NAME")
	
	static bool:hasweap
	hasweap = ((g_player_weapons[id][0]) != -1 && (g_player_weapons[id][1] != -1)) ? true : false
	
	len += formatex(menubody[len], 511 - len,"\w1. %L^n", OFFICIAL_LANG, "MENU_NEW_WEAPON")
	len += formatex(menubody[len], 511 - len,"\w2. %L^n^n", OFFICIAL_LANG, "MENU_PRE_WEAPON")
	len += formatex(menubody[len], 511 - len,"\w3. %L^n^n", OFFICIAL_LANG, "MENU_PRE_DONTSHOW")
	len += formatex(menubody[len], 511 - len,"\w5. %L^n", OFFICIAL_LANG, "MENU_EXIT")
	
	static keys
	keys = (MENU_KEY_1|MENU_KEY_5)
	
	if(hasweap) 
		keys |= (MENU_KEY_2|MENU_KEY_3)
	
	static string[128]
	formatex(string, sizeof(string), "%L", OFFICIAL_LANG, "EQUIPMENT_NAME")
	
	show_menu(id, keys, menubody, -1, string)
}

public action_equip(id, key)
{
	if(!is_user_alive(id) || g_zombie[id])
		return PLUGIN_HANDLED
	
	switch(key)
	{
		case 0: display_weaponmenu(id, 1, g_menuposition[id] = 0)
			case 1: equipweapon(id, EQUIP_ALL)
			case 2:
		{
			g_showmenu[id] = false
			equipweapon(id, EQUIP_ALL)
			zp_colored_print(id, "!g[Zombie Escape]!n %L", OFFICIAL_LANG, "HOW_ENA_EQUIPMENU")
		}
	}
	
	if(key > 0)
	{
		g_menufailsafe[id] = false
		remove_task(TASKID_WEAPONSMENU + id)
	}
	return PLUGIN_HANDLED
}


public display_weaponmenu(id, menuid, pos)
{
	if(pos < 0 || menuid < 0)
		return
	
	static start
	start = pos * 8
	
	static maxitem
	maxitem = menuid == 1 ? sizeof g_primaryweapons : sizeof g_secondaryweapons
	
	if(start >= maxitem)
		start = pos = g_menuposition[id]
	
	static menubody[512], len, primary[64], secondary[64]
	
	formatex(primary, sizeof(primary), "%L", OFFICIAL_LANG, "WPN_PRIMARY")
	formatex(secondary, sizeof(secondary), "%L", OFFICIAL_LANG, "WPN_SECONDARY")
	
	len = formatex(menubody, 511, "\y%s\w^n^n", menuid == 1 ? primary : secondary)
	
	static end
	end = start + 8
	if(end > maxitem)
		end = maxitem
	
	static keys
	keys = MENU_KEY_0
	
	static a, b
	b = 0
	
	static string_next[32], string_back[32], string_exit[32]
	
	formatex(string_next, sizeof(string_next), "%L", OFFICIAL_LANG, "MENU_NEXT")
	formatex(string_back, sizeof(string_back), "%L", OFFICIAL_LANG, "MENU_BACK")
	formatex(string_exit, sizeof(string_exit), "%L", OFFICIAL_LANG, "MENU_EXIT")
	
	for(a = start; a < end; ++a) 
	{
		keys |= (1<<b)
		len += formatex(menubody[len], 511 - len,"%d. %s^n", ++b, menuid == 1 ? g_primaryweapons[a][0]: g_secondaryweapons[a][0])
	}
	
	if(end != maxitem)
	{
		formatex(menubody[len], 511 - len, "^n9. %s^n0. %s", string_next, pos ? string_back : string_exit)
		keys |= MENU_KEY_9
	}
	else	
		formatex(menubody[len], 511 - len, "^n0. %s", pos ? string_back : string_exit)
	
	show_menu(id, keys, menubody, -1, menuid == 1 ? primary : secondary)
}

public action_prim(id, key)
{
	if(!is_user_alive(id) || g_zombie[id])
		return PLUGIN_HANDLED
	
	switch(key)
	{
		case 8: display_weaponmenu(id, 1, ++g_menuposition[id])
		case 9: display_weaponmenu(id, 1, --g_menuposition[id])
		default:
		{
			g_player_weapons[id][0] = g_menuposition[id] * 8 + key
			equipweapon(id, EQUIP_PRI)
			
			display_weaponmenu(id, 2, g_menuposition[id] = 0)
		}
	}
	return PLUGIN_HANDLED
}

public action_sec(id, key)
{
	if(!is_user_alive(id) || g_zombie[id])
		return PLUGIN_HANDLED
		
	switch(key) 
	{
		case 8: display_weaponmenu(id, 2, ++g_menuposition[id])
		case 9: display_weaponmenu(id, 2, --g_menuposition[id])
		default:
		{
			g_menufailsafe[id] = false
			remove_task(TASKID_WEAPONSMENU + id)
			
			g_player_weapons[id][1] = g_menuposition[id] * 8 + key
			equipweapon(id, EQUIP_SEC)
			equipweapon(id, EQUIP_GREN)
		}
	}
	return PLUGIN_HANDLED
}

public set_human_stuff(id)
{
	if(g_gamestart && !g_endround) 
		cs_set_user_team(id, CS_TEAM_CT)
	
	g_zombie[id] = false
	g_zombie_type[id] = 0
	
	set_user_health(id, cfg_human_health)
	set_user_armor(id, cfg_human_armor)
	set_task(random_float(0.1, 0.2), "do_set_human_model", id)
	
	if(g_gamestart < 1 && g_started) {
		cs_set_player_maxspeed(id, 0.1, 0)
	} else {
		cs_set_player_maxspeed(id, cfg_human_speed, 0)
	}
	
	ExecuteForward(g_forwards[FORWARD_HUMANIZED], g_fwDummyResult, id)
	ExecuteForward(g_forwards[FORWARD_HUMANIZED2], g_fwDummyResult, id)
}

public do_set_human_model(id)
{
	if(!is_user_alive(id))
		return
		
	static model[128], random1
	
	random1 = random_num(0, ArraySize(human_model) - 1)
	ArrayGetString(human_model, random1, model, sizeof(model))
	
	cs_set_player_model(id, model)	
}

public fw_TraceAttack(victim, attacker, Float:damage, Float:Dir[3], pentru, DamageType)
{
	if(g_gamestart < 2 || g_endround)
		return HAM_SUPERCEDE
		
	if(!is_user_connected(victim) || !is_user_connected(attacker))
		return HAM_IGNORED

	if(!g_zombie[victim] && !g_zombie[attacker])
		return HAM_SUPERCEDE

	if(g_zombie[victim] && g_zombie[attacker])
		return HAM_SUPERCEDE
		
	return HAM_IGNORED
}

public fw_TakeDamage(victim, inflictor, attacker, Float:damage, damagebits)
{
	if(g_gamestart < 2)
		return HAM_SUPERCEDE

	if(!is_user_connected(victim) || !is_user_connected(attacker))
		return HAM_IGNORED

	if(!g_zombie[victim] && !g_zombie[attacker])
		return HAM_SUPERCEDE

	if(g_zombie[victim] && g_zombie[attacker])
		return HAM_SUPERCEDE
	
	if(g_zombie[attacker] && get_user_weapon(attacker) == CSW_KNIFE)
	{
		if(damagebits == (1<<24))
			return HAM_SUPERCEDE
			
		if(fnGetHumans() <= 1) {
			ExecuteHamB(Ham_Killed, victim, attacker, 0)
			//update_team()
			return HAM_IGNORED;
		}
		
		message_begin(MSG_BROADCAST, g_MsgDeathMsg)
		write_byte(attacker) // killer
		write_byte(victim) // victim
		write_byte(0) // headshot flag
		write_string("knife") // killer's weapon
		message_end()
		
		FixDeadAttrib(victim)
		
		//update_frags(attacker, 1)
		//update_deaths(victim, 1)
		UpdateFrags(attacker, victim, 1, 1, 1)

		set_user_zombie(victim, ZOMBIE_TYPE_HOST, 0)
		
		ExecuteForward(g_forwards[FORWARD_INFECTED], g_fwDummyResult, victim, attacker)
		ExecuteForward(g_forwards[FORWARD_INFECTED2], g_fwDummyResult, victim, attacker)
	} 
	else if(g_zombie[victim] && !knock_back_immune[victim] && !g_zombie[attacker]) {
		set_pdata_float(victim, 108, 1.0, 50)
		
		static Float:MyOrigin[3]
		pev(attacker, pev_origin, MyOrigin)
		
		hook_ent2(victim, MyOrigin, cfg_zombie_kbpower, 2)
	}
	
	return HAM_HANDLED
}


// Update Player Frags and Deaths
UpdateFrags(attacker, victim, frags, deaths, scoreboard)
{
	// Set attacker frags
	//set_pev(attacker, pev_frags, float(pev(attacker, pev_frags) + frags))
	if(attacker)
		set_user_frags(attacker, get_user_frags(attacker) + frags)
	
	static team[2]
	if(attacker && victim) {
		team[0] = (cs_get_user_team(victim) == CS_TEAM_T) ? 1 : 2
		team[1] = (cs_get_user_team(attacker) == CS_TEAM_T) ? 1 : 2
	}
	
	// Set victim deaths
	if(victim) cs_set_user_deaths(victim, cs_get_user_deaths(victim) + deaths)
	
	// Update scoreboard with attacker and victim info
	if(scoreboard && attacker && victim)
	{
		message_begin(MSG_BROADCAST, g_MsgScoreInfo)
		write_byte(attacker) // id
		write_short(pev(attacker, pev_frags)) // frags
		write_short(cs_get_user_deaths(attacker)) // deaths
		write_short(0) // class?
		write_short(team[1]) // team
		message_end()
		
		message_begin(MSG_BROADCAST, g_MsgScoreInfo)
		write_byte(victim) // id
		write_short(pev(victim, pev_frags)) // frags
		write_short(cs_get_user_deaths(victim)) // deaths
		write_short(0) // class?
		write_short(team[0]) // team
		message_end()
	}
}

/*
public update_frags(id, frag)
{
	if(!is_user_connected(id))
		return
	
	set_pev(id, pev_frags, float(pev(id, pev_frags) + frag))
	
	message_begin(MSG_BROADCAST, get_user_msgid("ScoreInfo"))
	write_byte(id) // id
	write_short(pev(id, pev_frags)) // frags
	write_short(cs_get_user_deaths(id)) // deaths
	write_short(0) // class?
	write_short(get_pdata_int(id, 114, 5)) // team
	message_end()
}

public update_deaths(id, death)
{
	if(!is_user_connected(id))
		return
	
	cs_set_user_deaths(id, cs_get_user_deaths(id) + death)
	
	message_begin(MSG_BROADCAST, get_user_msgid("ScoreInfo"))
	write_byte(id) // id
	write_short(pev(id, pev_frags)) // frags
	write_short(cs_get_user_deaths(id)) // deaths
	write_short(0) // class?
	write_short(get_pdata_int(id, 114, 5)) // team
	message_end()		
}



public fw_PlayerResetMaxSpeed(id)
{
	if(!g_zombie[id])
		return HAM_IGNORED
	
	return HAM_SUPERCEDE
}
*/

public event_deathmsg(Float:damage)
{
	static attacker, victim
	attacker = read_data(1)
	victim = read_data(2)
	
	if(!is_user_connected(attacker) || !is_user_connected(victim))
		return
	
	if(!g_zombie[attacker] && get_pcvar_num(cvar_fragskill) > 1) {
		UpdateFrags(attacker, victim, get_pcvar_num(cvar_fragskill)-1, 0, 0)
	}
}

public fw_TouchWeapon(weapon, id)
{
	// Not a player
	if (!is_user_connected(id))
		return HAM_IGNORED
	if (g_zombie[id])
		return HAM_SUPERCEDE
	
	return HAM_IGNORED
}
// End of Ham

// Ambience Sounds Stop Task
public ambience_sound_stop(id)
{
	if(id == 0 || id == 123091293)
	{
		client_cmd(0, "mp3 stop; stopsound")
	} 
	else 
	{
		if(!is_user_connected(id))
			return
			
		client_cmd(id, "mp3 stop; stopsound")
	}
}

// ============================ STOCK =================================
stock get_player_num(team, alive)
{
	static player_num
	player_num = 0
	
	for(new i = 0; i < g_MaxPlayers; i++)
	{
		if(!is_user_connected(i))
			continue
		if(alive == AL_NOT)
		{
			if(is_user_alive(i))
				continue
			} else if(alive == AL_ALIVE) {
			if(!is_user_alive(i))
				continue	
		}
		
		if(team == TEAM_ALL)
		{
			if(cs_get_user_team(i) == CS_TEAM_UNASSIGNED || cs_get_user_team(i) == CS_TEAM_SPECTATOR)
				continue
			} else if(team == TEAM_T) {
			if(cs_get_user_team(i) != CS_TEAM_T)
				continue
			} else if(team == TEAM_CT) {
			if(cs_get_user_team(i) != CS_TEAM_CT)
				continue
		}
		
		player_num++
	}
	
	return player_num
}

stock get_random_player(team, alive)
{
	static list_player[33], list_player_num
	static total_player
	total_player = get_player_num(team, alive)
	
	for(new i = 0; i < total_player; i++)
		list_player[i] = 0
	
	list_player_num = 0
	
	for(new i = 0; i < g_MaxPlayers; i++)
	{
		if(!is_user_connected(i))
			continue
		
		if(alive == AL_NOT)
		{
			if(is_user_alive(i))
				continue
			} else if(alive == AL_ALIVE) {
			if(!is_user_alive(i))
				continue	
		}
		
		if(team == TEAM_ALL)
		{
			if(cs_get_user_team(i) == CS_TEAM_UNASSIGNED || cs_get_user_team(i) == CS_TEAM_SPECTATOR)
				continue
			} else if(team == TEAM_T) {
			if(cs_get_user_team(i) != CS_TEAM_T)
				continue
			} else if(team == TEAM_CT) {
			if(cs_get_user_team(i) != CS_TEAM_CT)
				continue
		}
		
		list_player[list_player_num] = i
		list_player_num++
	}
	
	static random_player; random_player = 0
	random_player = list_player[random_num(0, list_player_num - 1)]
	
	return random_player
}

stock PlaySound(id, const sound[])
{
	if(id == 0)
	{
		if (equal(sound[strlen(sound)-4], ".mp3"))
			client_cmd(0, "mp3 play ^"sound/%s^"", sound)
		else
			client_cmd(0, "spk ^"%s^"", sound)
		} 
	else 
	{
		if(is_user_connected(id))//&& is_user_alive(id))
		{
			if (equal(sound[strlen(sound)-4], ".mp3"))
				client_cmd(id, "mp3 play ^"sound/%s^"", sound)
			else
				client_cmd(id, "spk ^"%s^"", sound)			
		}
	}
}

stock require_zombie()
{
	switch(get_player_num(TEAM_CT, 1))
	{
		case 1..9: return 1
		case 10..17: return 2
		case 18..27: return 3
		case 28..32: return 4
	}
	return 0
}

stock check_spawn(Float:Origin[3])
{
	new Float:originE[3], Float:origin1[3], Float:origin2[3]
	new ent = -1
	while ((ent = engfunc(EngFunc_FindEntityByString, ent, "classname", "player")) != 0)
	{
		pev(ent, pev_origin, originE)
		
		// xoy
		origin1 = Origin
		origin2 = originE
		origin1[2] = origin2[2] = 0.0
		if (vector_distance(origin1, origin2) <= 2 * 16.0)
		{
			// oz
			origin1 = Origin
			origin2 = originE
			origin1[0] = origin2[0] = origin1[1] = origin2[1] = 0.0
			if (vector_distance(origin1, origin2) <= 72.0) return 0;
		}
	}
	
	return 1
}

// Drop primary/secondary weapons
stock drop_weapons(id, dropwhat)
{
	// Get user weapons
	static weapons[32], num, i, weaponid
	num = 0 // reset passed weapons count (bugfix)
	get_user_weapons(id, weapons, num)
	
	// Weapon bitsums
	const PRIMARY_WEAPONS_BIT_SUM = (1<<CSW_SCOUT)|(1<<CSW_XM1014)|(1<<CSW_MAC10)|(1<<CSW_AUG)|(1<<CSW_UMP45)|(1<<CSW_SG550)|(1<<CSW_GALIL)|(1<<CSW_FAMAS)|(1<<CSW_AWP)|(1<<CSW_MP5NAVY)|(1<<CSW_M249)|(1<<CSW_M3)|(1<<CSW_M4A1)|(1<<CSW_TMP)|(1<<CSW_G3SG1)|(1<<CSW_SG552)|(1<<CSW_AK47)|(1<<CSW_P90)
	const SECONDARY_WEAPONS_BIT_SUM = (1<<CSW_P228)|(1<<CSW_ELITE)|(1<<CSW_FIVESEVEN)|(1<<CSW_USP)|(1<<CSW_GLOCK18)|(1<<CSW_DEAGLE)	
	
	// Loop through them and drop primaries or secondaries
	for (i = 0; i < num; i++)
	{
		// Prevent re-indexing the array
		weaponid = weapons[i]
		
		if ((dropwhat == 1 && ((1<<weaponid) & PRIMARY_WEAPONS_BIT_SUM)) || (dropwhat == 2 && ((1<<weaponid) & SECONDARY_WEAPONS_BIT_SUM)))
		{
			// Get weapon entity
			static wname[32], weapon_ent
			get_weaponname(weaponid, wname, charsmax(wname))
			weapon_ent = fm_find_ent_by_owner(-1, wname, id)
			
			// Hack: store weapon bpammo on PEV_ADDITIONAL_AMMO
			set_pev(weapon_ent, pev_iuser1, cs_get_user_bpammo(id, weaponid))
			
			// Player drops the weapon and looses his bpammo
			engclient_cmd(id, "drop", wname)
			cs_set_user_bpammo(id, weaponid, 0)
		}
	}
}

public End_Round()
{
	if(g_endround) return
	
	static random_music, music_name[128], sound[128], Team
	if(!fnGetZombies()) 
	{
		g_team_score[TEAM_CT]++
		last_win = 1
		Team = 2

		random_music = random_num(0, ArraySize(sound_win_humans) - 1)

		ArrayGetString(sound_win_humans, random_music, sound, charsmax(sound))
		ArrayGetString(sound_win_humans_name, random_music, music_name, charsmax(music_name))

		zp_colored_print(0, "!g[ZE]!y %L", LANG_PLAYER, "PLAYING_NOW", music_name)

		for (new id = 0; id <= g_MaxPlayers; id++)
		{
			if(!current_playing[id] && !rs_disable[id]) {
				if(equal(sound[strlen(sound)-4], ".mp3")) client_cmd(id, "volume 0.5")
				PlaySound(id, sound)
			}
		}
		
		
		
		client_print(0, print_center, "%L", OFFICIAL_LANG, "ESCAPE_SUCCESS")
	}
	else
	{
		g_team_score[TEAM_T]++
		last_win = 2
		Team = 1

		random_music = random_num(0, ArraySize(sound_win_zombies) - 1)

		ArrayGetString(sound_win_zombies, random_music, sound, charsmax(sound))
		ArrayGetString(sound_win_zombies_name, random_music, music_name, charsmax(music_name))
		
		zp_colored_print(0, "!g[ZE]!y %L", LANG_PLAYER, "PLAYING_NOW", music_name)
		for (new id = 0; id <= g_MaxPlayers; id++) {
			if(!current_playing[id] && !rs_disable[id]) {
				if(equal(sound[strlen(sound)-4], ".mp3")) client_cmd(id, "volume 0.5")
				PlaySound(id, sound)
			}
		}
					
		client_print(0, print_center, "%L", OFFICIAL_LANG, "ESCAPE_FAIL")
	} 

	for(new i = 0; i < g_MaxPlayers; i++)
	{
		if(!is_user_connected(i) || !is_user_alive(i))
			continue
		
		if(!g_zombie[i] && Team == 1 || g_zombie[i] && Team == 2)
		{
			UpdateFrags(0, i, 0, 0, 0)
		} 
		else 
		{
			UpdateFrags(i, 0, 3, 0, 0)
		}
	}
	
	ExecuteForward(g_forwards[FORWARD_ROUNDEND], g_fwDummyResult, Team)	
	ExecuteForward(g_forwards[FORWARD_ROUNDEND2], g_fwDummyResult, Team)
	
	last_music = random_music+1	
	g_endround = 1
}

public rs_menu(id)
{
	if(!is_user_connected(id))
		return
	
	static music_name[64], szItem[555], music_name2[64]
	
	if(last_win)
		ArrayGetString(last_win == 1 ? sound_win_humans_name : sound_win_zombies_name, last_music-1, music_name, charsmax(music_name))
	else
		formatex(music_name, charsmax(music_name), "None")
		
	if(music_team[id])
		ArrayGetString(music_team[id] == 1 ? sound_win_humans_name : sound_win_zombies_name, current_playing[id]-1, music_name2, charsmax(music_name2))
	else
		formatex(music_name2, charsmax(music_name2), "None")
		
		
	formatex(szItem, charsmax(szItem), "%L", id, "RS_MENU_TITLE", music_name, music_name2)
	new menu = menu_create(szItem, "rs_menu_hand");
	
	formatex(szItem, charsmax(szItem), "%s%L", last_win ? "\w" : "\d", id, "RS_MENU_ITEM_1")
	menu_additem(menu, szItem , "1", 0);
	
	formatex(szItem, charsmax(szItem), "%L", id, "RS_MENU_ITEM_2")
	menu_additem(menu, szItem , "2", 0);
	
	formatex(szItem, charsmax(szItem), "%L", id, "RS_MENU_ITEM_3")
	menu_additem(menu, szItem , "3", 0);
	
	formatex(szItem, charsmax(szItem), "%L", id, rs_disable[id] ? "RS_MENU_ITEM_4A" : "RS_MENU_ITEM_4B")
	menu_additem(menu, szItem, "4", 0);
	
	formatex(szItem, charsmax(szItem), "%L", id, "MENU_EXIT")
	menu_setprop(menu, MPROP_EXITNAME, szItem)

	// Fix for AMXX custom menus
	if (pev_valid(id) == PDATA_SAFE)
		set_pdata_int(id, OFFSET_CSMENUCODE, 0, OFFSET_LINUX)
	
	menu_display(id, menu, 0); 
	
}

public rs_menu_hand(id, menu, item)
{
	if(item == MENU_EXIT || !is_user_connected(id)) 
	{ 
		menu_destroy(menu); 
		return PLUGIN_HANDLED;
	} 
	
	new data[6], iName[64], access, callback, sound[64], music_name[64]
	menu_item_getinfo(menu, item, access, data,5, iName, 63, callback);
	new item_id = str_to_num(data)

	switch(item_id)
	{
		case 1: {
			if(last_win) {
				ArrayGetString(last_win == 1 ? sound_win_humans : sound_win_zombies, last_music-1, sound, charsmax(sound))
				ArrayGetString(last_win == 1 ? sound_win_humans_name : sound_win_zombies_name, last_music-1, music_name, charsmax(music_name))
				
				if(equal(sound[strlen(sound)-4], ".mp3")) client_cmd(id, "volume 0.5")
				PlaySound(id, sound)
				
				current_playing[id] = last_music
				music_team[id] = last_win
				
				zp_colored_print(id, "!g[ZE]!y %L", id, "PLAYING_NOW", music_name)
				remove_task(id+321134)
				set_task(60.0, "stop_sound", id+321134)
			}
			else rs_menu(id)
		}
		case 2: rs_menu_choose(id)
		case 3: 
		{
			client_cmd(id, "mp3 stop")
			client_cmd(id, "stopsound")
			client_cmd(id, "volume 0.8")
			current_playing[id] = 0
			music_team[id] = 0
			remove_task(id+321134)
			rs_menu(id)
		}
		case 4: { 
			rs_disable[id] = rs_disable[id] ? false : true
			rs_menu(id)
		}
	}
	
	menu_destroy(menu); 
	return PLUGIN_HANDLED;
}

public rs_menu_choose(id)
{
	if(!is_user_connected(id))
		return
		
	static music_name[64], szItem[64], szKey[20], i
	
	formatex(szItem, charsmax(szItem), "%L", id, "RS_CHOOSE_MUSIC_MENU_TITLE")
	new menu = menu_create(szItem, "rs_menu_choose_hand");
	
	for (i = 0; i < ArraySize(sound_win_humans); i++)
	{
		ArrayGetString(sound_win_humans_name, i, music_name, charsmax(music_name))
		formatex(szItem, charsmax(szItem), "%s%s %s", (music_team[id] == 1 && current_playing[id]-1 == i) ? "\d" : "\w", music_name, (music_team[id] == 1 && current_playing[id]-1 == i) ? "\r[X]" : "\r[]")
		formatex(szKey, charsmax(szKey), "H:%d", i)
		menu_additem(menu, szItem, szKey, 0);
	}
	
	for (i = 0; i < ArraySize(sound_win_zombies); i++)
	{
		ArrayGetString(sound_win_zombies_name, i, music_name, charsmax(music_name))
		formatex(szItem, charsmax(szItem), "%s%s %s", (music_team[id] == 2 && current_playing[id]-1 == i) ? "\d" : "\w", music_name, (music_team[id] == 2 && current_playing[id]-1 == i) ? "\r[X]" : "\r[]")
		formatex(szKey, charsmax(szKey), "Z:%d", i)
		menu_additem(menu, szItem, szKey, 0);
	}
	
	formatex(szItem, charsmax(szItem), "%L", id, "MENU_BACK")
	menu_setprop(menu, MPROP_BACKNAME, szItem)
	formatex(szItem, charsmax(szItem), "%L", id, "MENU_NEXT")
	menu_setprop(menu, MPROP_NEXTNAME, szItem)
	formatex(szItem, charsmax(szItem), "%L", id, "MENU_EXIT")
	menu_setprop(menu, MPROP_EXITNAME, szItem)
	
	// Fix for AMXX custom menus
	if (pev_valid(id) == PDATA_SAFE)
		set_pdata_int(id, OFFSET_CSMENUCODE, 0, OFFSET_LINUX)
	
	menu_display(id, menu, 0); 
}

public rs_menu_choose_hand(id, menu, item) 
{ 
	if(item == MENU_EXIT || !is_user_connected(id)) 
	{ 
		menu_destroy(menu);
		rs_menu(id)
		return PLUGIN_HANDLED;
	} 
	
	new data[6], iName[64], access, callback, sound[64], music_name[64];
	menu_item_getinfo(menu, item, access, data,5, iName, 63, callback);
	new item_id = str_to_num(data[2])

	if(equal(data, "H:", 2))
	{
		ArrayGetString(sound_win_humans, item_id, sound, charsmax(sound))
		ArrayGetString(sound_win_humans_name, item_id, music_name, charsmax(music_name))
		
		if(equal(sound[strlen(sound)-4], ".mp3")) client_cmd(id, "volume 0.5")
		PlaySound(id, sound)
		zp_colored_print(id, "!g[ZE]!y %L", id, "PLAYING_NOW", music_name)
		remove_task(id+321134)
		set_task(60.0, "stop_sound", id+321134)
		current_playing[id] = item_id+1
		music_team[id] = 1
	}
	else if(equal(data, "Z:", 2))
	{
		ArrayGetString(sound_win_zombies, item_id, sound, charsmax(sound))
		ArrayGetString(sound_win_zombies_name, item_id, music_name, charsmax(music_name))
		
		if(equal(sound[strlen(sound)-4], ".mp3")) client_cmd(id, "volume 0.5")
		PlaySound(id, sound)
		zp_colored_print(id, "!g[ZE]!y %L", id, "PLAYING_NOW", music_name)
		remove_task(id+321134)
		set_task(60.0, "stop_sound", id+321134)
		current_playing[id] = item_id+1
		music_team[id] = 2
	}
	
	menu_destroy(menu);
	rs_menu(id)
	return PLUGIN_HANDLED;
}

public stop_sound(id)
{
	id -= 321134
	
	if(!is_user_connected(id))
		return
		
	client_cmd(id, "mp3 stop")
	client_cmd(id, "stopsound")
	client_cmd(id, "volume 0.8")
	current_playing[id] = 0
	music_team[id] = 0
	rs_menu(id)
	zp_colored_print(id, "!g[ZE]!y %L", id, "MUSIC_ENDED")
}

stock hook_ent2(ent, Float:VicOrigin[3], Float:speed, type)
{
	static Float:fl_Velocity[3]
	static Float:EntOrigin[3]
	
	pev(ent, pev_origin, EntOrigin)
	static Float:distance_f
	distance_f = get_distance_f(EntOrigin, VicOrigin)
	
	new Float:fl_Time = distance_f / speed
	
	if(type == 1)
	{
		fl_Velocity[0] = ((VicOrigin[0] - EntOrigin[0]) / fl_Time) * 1.5
		fl_Velocity[1] = ((VicOrigin[1] - EntOrigin[1]) / fl_Time) * 1.5
		fl_Velocity[2] = (VicOrigin[2] - EntOrigin[2]) / fl_Time		
		} else if(type == 2) {
		fl_Velocity[0] = ((EntOrigin[0] - VicOrigin[0]) / fl_Time) * 1.5
		fl_Velocity[1] = ((EntOrigin[1] - VicOrigin[1]) / fl_Time) * 1.5
		fl_Velocity[2] = (EntOrigin[2] - VicOrigin[2]) / fl_Time
	}
	
	entity_set_vector(ent, EV_VEC_velocity, fl_Velocity)
}

stock equipweapon(id, weapon)
{
	if(!is_user_alive(id) || !is_user_connected(id)) 
		return
	
	static weaponid[2], weaponent
	
	if(weapon & EQUIP_PRI)
	{
		weaponent = fm_lastprimary(id)
		weaponid[1] = get_weaponid(g_primaryweapons[g_player_weapons[id][0]][1])
		
		if(pev_valid(weaponent))
		{
			weaponid[0] = fm_get_weapon_id(weaponent)
			if(weaponid[0] != weaponid[1])
				fm_strip_user_gun(id, weaponid[0])
		}
		else
			weaponid[0] = -1
		
		if(weaponid[0] != weaponid[1])
			give_item(id, g_primaryweapons[g_player_weapons[id][0]][1])
		
		cs_set_user_bpammo(id, weaponid[1], g_weapon_ammo[weaponid[1]][1])
	}
	
	if(weapon & EQUIP_SEC)
	{
		weaponent = fm_lastsecondry(id)
		weaponid[1] = get_weaponid(g_secondaryweapons[g_player_weapons[id][1]][1])
		
		if(pev_valid(weaponent))
		{
			weaponid[0] = fm_get_weapon_id(weaponent)
			if(weaponid[0] != weaponid[1])
				fm_strip_user_gun(id, weaponid[0])
		}
		else
			weaponid[0] = -1
		
		if(weaponid[0] != weaponid[1])
			give_item(id, g_secondaryweapons[g_player_weapons[id][1]][1])
		
		cs_set_user_bpammo(id, weaponid[1], g_weapon_ammo[weaponid[1]][1])
	}
	
	if(weapon & EQUIP_GREN)
	{
		static i
		for(i = 0; i < sizeof g_grenades; i++)  {
			if(!user_has_weapon(id, get_weaponid(g_grenades[i])))
				give_item(id, g_grenades[i])
		}
		
		if(get_user_flags(id) & ADMIN_LEVEL_F && !user_has_weapon(id, CSW_FLASHBANG))
			give_item(id, "weapon_flashbang")
	}
}

stock FixDeadAttrib(id)
{
	message_begin(MSG_BROADCAST, get_user_msgid("ScoreAttrib"))
	write_byte(id) // id
	write_byte(0) // attrib
	message_end()
}
stock zp_colored_print(const id,const input[], any:...)
{
	new msg[191], players[32], count = 1; vformat(msg,190,input,3);
	replace_all(msg,190,"!g","^4");    // green
	replace_all(msg,190,"!n","^1");    // normal
	replace_all(msg,190,"!y","^1");    // normal
	replace_all(msg,190,"!t","^3");    // team
	
	if (id) players[0] = id; else get_players(players,count,"ch");
	
	for (new i=0;i<count;i++)
	{
		if (is_user_connected(players[i]))
		{
			message_begin(MSG_ONE_UNRELIABLE,get_user_msgid("SayText"),_,players[i]);
			write_byte(players[i]);
			write_string(msg);
			message_end();
		}
	}
} 

public native_do_random(id)
	set_pev(id, pev_origin, g_spawn_origin[id])
	
public native_round_start()
	return g_gamestart
	
public Float:native_get_maxspeed(id)
	return get_user_maxspeed(id)
	
public Message_TeamScore()
{
	static team[2]
	get_msg_arg_string(1, team, charsmax(team))
	
	switch (team[0])
	{
		// CT
		case 'C': set_msg_arg_int(2, get_msg_argtype(2), g_team_score[TEAM_CT])
		// Terrorist
		case 'T': set_msg_arg_int(2, get_msg_argtype(2), g_team_score[TEAM_T])
	}
}

// Balance Teams Task
balance_teams()
{
	// Get amount of users playing
	static iPlayersnum
	iPlayersnum = fnGetPlaying()
	
	// No players, don't bother
	if(iPlayersnum < 1) return;
	
	// Split players evenly
	static iTerrors, iMaxTerrors, id
	iMaxTerrors = iPlayersnum/2
	iTerrors = 0
	
	// First, set everyone to CT
	for (id = 0; id <= g_MaxPlayers; id++)
	{
		// Skip if not connected
		if(!is_user_connected(id))
			continue;

		// Skip if not playing
		if(cs_get_user_team(id) == CS_TEAM_SPECTATOR || cs_get_user_team(id) == CS_TEAM_UNASSIGNED)
			continue;
		
		// Set team
		remove_task(id+TASK_TEAM)
		cs_set_user_team(id, CS_TEAM_CT)
	}
	
	// Then randomly set half of the players to Terrorists
	while (iTerrors < iMaxTerrors)
	{
		// Keep looping through all players
		if(++id > g_MaxPlayers) id = 1
		
		// Skip if not connected
		if(!is_user_connected(id))
			continue;
		
		// Skip if not playing or already a Terrorist
		if(cs_get_user_team(id) != CS_TEAM_CT)
			continue;
		
		// Random chance
		if(random_num(0, 1))
		{
			cs_set_user_team(id, CS_TEAM_T)
			iTerrors++
		}
	}
}



// Get Playing -returns number of users playing-
fnGetPlaying()
{
	static iPlaying, id
	iPlaying = 0
	
	for (id = 0; id <= g_MaxPlayers; id++)
	{
		if(is_user_connected(id))
		{
			if(cs_get_user_team(id) != CS_TEAM_SPECTATOR && cs_get_user_team(id) != CS_TEAM_UNASSIGNED)
				iPlaying++
		}
	}
	
	return iPlaying;
}

fnGetZombies()
{
	static iZombies, id
	iZombies = 0
	
	for (id = 0; id <= g_MaxPlayers; id++)
	{
		if(is_user_alive(id) && g_zombie[id])
			iZombies++
	}
	
	return iZombies;
}

fnGetHumans()
{
	static iZombies, id
	iZombies = 0
	
	for (id = 0; id <= g_MaxPlayers; id++)
	{
		if(is_user_alive(id) && !g_zombie[id])
			iZombies++
	}
	
	return iZombies;
}

public update_team()
{
	static players[32], count, id
	count = 1
	get_players(players,count,"ch");
	
	for (new i=0;i<count;i++)
	{
		id = players[i]

		if(!is_user_connected(id))
			return
			
		if(cs_get_user_team(id) == CS_TEAM_UNASSIGNED || cs_get_user_team(id) == CS_TEAM_SPECTATOR)
			continue
			
		if(!g_zombie[id] && cs_get_user_team(id) != CS_TEAM_CT)
		{
			cs_set_user_team(id, CS_TEAM_CT)
		}
		
		else if(g_zombie[id] && cs_get_user_team(id) != CS_TEAM_T)
		{
			cs_set_user_team(id, CS_TEAM_T)
		}
	}
}

// Native: zp_set_extra_damage
public native_set_extra_damage(victim, attacker, damage, const weaponDescription[])
{
	param_convert(4)
	
	if (!is_user_alive(attacker) || !is_user_alive(victim)) 
		return false;

	if(pev(victim, pev_takedamage) == DAMAGE_NO || damage <= 0) 
		return false;

	if(get_user_health(victim) - damage <= 0 ) 
	{
		set_msg_block(get_user_msgid("DeathMsg"), BLOCK_SET);
		ExecuteHamB(Ham_Killed, victim, attacker, 2);
		set_msg_block(get_user_msgid("DeathMsg"), BLOCK_NOT);

		message_begin(MSG_BROADCAST, get_user_msgid("DeathMsg"));
		write_byte(attacker);
		write_byte(victim);
		write_byte(0);
		write_string(weaponDescription);
		message_end();
		
		set_pev(attacker, pev_frags, float(get_user_frags(attacker) + 1));
		
		new kname[32], vname[32], kauthid[32], vauthid[32], kteam[10], vteam[10];
		get_user_name(attacker, kname, 31); get_user_team(attacker, kteam, 9); get_user_authid(attacker, kauthid, 31);
		get_user_name(victim, vname, 31); get_user_team(victim, vteam, 9); get_user_authid(victim, vauthid, 31);
		
		log_message("^"%s<%d><%s><%s>^" killed ^"%s<%d><%s><%s>^" with ^"%s^"", kname, get_user_userid(attacker), kauthid, kteam, 
		vname, get_user_userid(victim), vauthid, vteam, weaponDescription);
	}
	else  {
		ExecuteHam(Ham_TakeDamage, victim, 0, attacker, float(damage), DMG_BLAST)
	}
	
	return true
}

public message_textmsg()
{
	static textmsg[22]
	get_msg_arg_string(2, textmsg, charsmax(textmsg))
	
	// Block round end related messages
	if (equal(textmsg, "#Hostages_Not_Rescued") || equal(textmsg, "#Round_Draw") || equal(textmsg, "#Terrorists_Win") || equal(textmsg, "#CTs_Win"))
	{
		return PLUGIN_HANDLED;
	}
	
	return PLUGIN_CONTINUE;
}

public native_has_round_ended()
	return g_endround
	
public native_return(id)
	return false

public native_last_h(id)
{
	if(!g_zombie[id] && fnGetHumans() == 1)
		return true
		
	return false
}

public native_last_z(id)
{
	if(g_zombie[id] && fnGetZombies() == 1)
		return true
		
	return false
}

public native_return_positive()
	return true

public native_set_knock_immune(id, set)
{
	knock_back_immune[id] = set > 0 ? true : false
}

public native_get_knock_immune(id) return knock_back_immune[id]

precache_player_model(const modelname[]) 
{
	static longname[128] , index
	formatex(longname, charsmax(longname), "models/player/%s/%s.mdl", modelname, modelname)  	
	index = precache_model(longname) 
	
	copy(longname[strlen(longname)-4], charsmax(longname) - (strlen(longname)-4), "T.mdl") 
	if (file_exists(longname)) precache_model(longname) 
	
	return index
}


Mulțumesc.
ImageImage
RoyalServer 2
User avatar
Laurentiu P.
Fost moderator
Fost moderator
Posts: 2549
Joined: 10 Jul 2013, 21:26
Detinator Steam: Da
Reputatie: Fost super moderator
Fond eXtream: 100
Has thanked: 26 times
Been thanked: 62 times
Contact:

06 Sep 2018, 10:26

Vezi că modul e compatibil cu amxmodx 1.8.3
no...
User avatar
alexnovac18
Utilizator neserios (tepar)
Utilizator neserios (tepar)
Posts: 35
Joined: 17 Mar 2018, 15:46
Detinator Steam: Da
CS Status: Citesc forumul eXtreamCS.com...!
Detinator server CS: ZE.WSTRIKE.RO
SteamID: alexnovac18
Reputatie: Utilizator neserios (tepar!)
Utilizator vechi: novac-alex
Fond eXtream: 0
Contact:

08 Sep 2018, 06:53

S-a Rezolvat, puteți da T.c
ImageImage
Post Reply

Return to “Modificari pluginuri”

  • Information
  • Who is online

    Users browsing this forum: No registered users and 4 guests