zeli

#include <amxmodx>
#include <amxmisc>
#include <engine>
#include <fakemeta>
#include <fakemeta_util>
#include <cstrike>
#include <hamsandwich>
#include <fun>
#include <xs>
#include <infinitygame>

#define PLUGIN "Zombie Elimination"
#define VERSION "1.0"
#define AUTHOR "Joseph Rias de Dias Pendragon Leon"

// =============== Game Config
#define GAME_FOLDER "ZombieElimination"
#define LANG_FILE "ZombieElimination.txt"

#define MIN_PLAYER 2
#define COUNTDOWN_TIME 0 // 20 Seconds
#define ENV_LIGHT "f"
#define ENV_WEATHER 0 // 0 - Disable | 1 - Rain | 2 - Snow
#define ENV_FOG_DENSITY 10 // 0 ~ 100
#define ENV_FOG_COLOR "0 255 0"
#define ENV_SKY "neb6"

#define BASE_CLASSNAME "teambase"
#define HUMANBASE_HEALTH 100.0
#define ZOMBIEBASE_HEALTH 200.0

#define HEALTHBAR_SPR "sprites/zombie_elimination/healthbar.spr"

new const HumanBase_Model[] = "models/zombie_elimination/HumanBase.mdl"
new const ZombieBase_Model[] = "models/zombie_elimination/ZombieBase.mdl"

new const StartSound[] = "zombie_elimination/ZB4_Start.wav"
new const CountSound[] = "zombie_elimination/count/%i.wav"

new const ZombieBase_HitSound[3][] =
{
	"zombie_elimination/base/hive_hit1.wav",
	"zombie_elimination/base/hive_hit2.wav",
	"zombie_elimination/base/hive_hit3.wav"
}

new const ZombieBase_DeathSound[3][] =
{
	"zombie_elimination/base/hive_death1.wav",
	"zombie_elimination/base/hive_death2.wav",
	"zombie_elimination/base/zombie_base_death.wav"
}

new const HumanBase_DeathSound1[] = "zombie_elimination/base/armory_death1.wav"
new const HumanBase_DeathSound2[] = "zombie_elimination/base/armory_death2.wav"

new const Human_WinSound[] = "zombie_elimination/win_human_2.wav"
new const Zombie_WinSound[] = "zombie_elimination/win_zombi_2.wav"

new const Zombie_DeathSpr[] = "sprites/zombie_elimination/zomb_death.spr"
new const Tutorial_MessageSound[] = "zombie_elimination/tutorial_message.wav"

new const LevelUpH_Sound[] = "zombie_elimination/h_levelup.wav"
new const LevelUpZ_Sound[] = "zombie_elimination/z_levelup.wav"

#define MAX_LEVEL 10
new const Level_Experience[MAX_LEVEL+1] =
{
	150,
	250,
	350,
	475,
	600,
	650,
	715,
	790,
	900,
	1100,

	999999
}

#define KILL_SP 3
#define KILL_EXP 10

// =============== End of: Game Config
#define GAME_LANG LANG_SERVER

#define HUD_WIN_X -1.0
#define HUD_WIN_Y 0.20

#define NOTICE_X -1.0
#define NOTICE_Y 0.25

new GameName[64] = "Zombie Elimination"

// Marcros
#define Get_BitVar(%1,%2)		(%1 & (1 << (%2 & 31)))
#define Set_BitVar(%1,%2)		(%1 |= (1 << (%2 & 31)));
#define UnSet_BitVar(%1,%2)		(%1 &= ~(1 << (%2 & 31)));

// Task
#define TASK_COUNTDOWN 283151
#define TASK_BASEDEATH 283152

// Block Round Event
new g_BlockedObj_Forward
new g_BlockedObj[15][32] =
{
        "func_bomb_target",
        "info_bomb_target",
        "info_vip_start",
        "func_vip_safetyzone",
        "func_escapezone",
        "hostage_entity",
        "monster_scientist",
        "func_hostage_rescue",
        "info_hostage_rescue",
        "env_fog",
        "env_rain",
        "env_snow",
        "item_longjump",
        "func_vehicle",
        "func_buyzone"
}

new const SoundNVG[2][] = { "items/nvg_off.wav", "items/nvg_on.wav"}
new const WEAPONENTNAMES[][] = { "", "weapon_p228", "", "weapon_scout", "weapon_hegrenade", "weapon_xm1014", "weapon_c4", "weapon_mac10",
			"weapon_aug", "weapon_smokegrenade", "weapon_elite", "weapon_fiveseven", "weapon_ump45", "weapon_sg550",
			"weapon_galil", "weapon_famas", "weapon_usp", "weapon_glock18", "weapon_awp", "weapon_mp5navy", "weapon_m249",
			"weapon_m3", "weapon_m4a1", "weapon_tmp", "weapon_g3sg1", "weapon_flashbang", "weapon_deagle", "weapon_sg552",
			"weapon_ak47", "weapon_knife", "weapon_p90" }

enum
{
	TEAM_NONE = 0,
	TEAM_ZOMBIE,
	TEAM_HUMAN
}

// Shared Code
#define PDATA_SAFE 2
const OFFSET_PLAYER_LINUX = 5
const OFFSET_WEAPON_LINUX = 4
const OFFSET_WEAPONOWNER = 41

// Vars
new g_GameAvailable, g_GameStart, g_GameEnd, g_Joined, g_DataLoad, g_CountTime, g_TeamScore[3]
new g_HumanBase, g_ZombieBase, g_IsZombie, g_SkillPoint[33], g_Level[33], g_Experience[33]
new Float:g_CTSpawn_Point[64][3], Float:g_TSpawn_Point[64][3], g_CTSpawn_Count, g_TSpawn_Count
new g_FogColor[3]
new g_MaxPlayers, g_BaseCreation, m_iBlood[2], g_iSprLightning, g_MsgScreenShake, g_Exp_SprID,
g_GibModelID, g_ZombieDeath_SprId, g_Hud_Notice, g_MsgHideWeapon, g_Hud_Game

// Map Configs
new Float:MyOrigin[3], Float:MyAngles[3], Float:g_HumanBar_Dis[33], Float:g_ZombieBar_Dis[33]
new g_HumanBar, g_ZombieBar
new Float:ZombieBase_Origin[3], Float:HumanBase_Origin[3]
new Float:ZombieBase_Angles[3], Float:HumanBase_Angles[3]

// Safety
new g_HamBot
new g_IsConnected, g_IsAlive, g_PlayerWeapon[33]

public plugin_init()
{
	register_plugin(PLUGIN, VERSION, AUTHOR)

	register_dictionary(LANG_FILE)
	Register_SafetyFunc()

	// Event
	register_event("HLTV", "Event_NewRound", "a", "1=0", "2=0")
	register_event("TextMsg", "Event_RoundRestart", "a", "2=#Game_will_restart_in")
	register_logevent("Event_RoundStart", 2, "1=Round_Start")
	register_logevent("Event_RoundEnd", 2, "1=Round_End")
	register_event("ResetHUD", "Event_ResetHUD", "b")

	// Forward
	register_think("healthbar", "fw_HealthBar_Think")
	register_think(BASE_CLASSNAME, "fw_Base_Think")
	/*
	register_forward(FM_GetGameDescription, "fw_GetGameDesc")
	register_forward(FM_EmitSound, "fw_EmitSound")
	register_forward(FM_TraceLine, "fw_TraceLine")
	register_forward(FM_TraceHull, "fw_TraceHull")*/
	unregister_forward(FM_Spawn, g_BlockedObj_Forward)
	register_forward(FM_AddToFullPack, "fw_CapitalSaigon_Post", 1)

	// Hamsandwich
	RegisterHam(Ham_Spawn, "player", "fw_PlayerSpawn_Post", 1)
	RegisterHam(Ham_Killed, "player", "fw_PlayerKilled_Post", 1)
	RegisterHam(Ham_TakeDamage, "player", "fw_PlayerTakeDamage")
	RegisterHam(Ham_TraceAttack, "player", "fw_PlayerTraceAttack")
	RegisterHam(Ham_Use, "func_tank", "fw_UseStationary")
	RegisterHam(Ham_Use, "func_tankmortar", "fw_UseStationary")
	RegisterHam(Ham_Use, "func_tankrocket", "fw_UseStationary")
	RegisterHam(Ham_Use, "func_tanklaser", "fw_UseStationary")
	RegisterHam(Ham_Use, "func_tank", "fw_UseStationary_Post", 1)
	RegisterHam(Ham_Use, "func_tankmortar", "fw_UseStationary_Post", 1)
	RegisterHam(Ham_Use, "func_tankrocket", "fw_UseStationary_Post", 1)
	RegisterHam(Ham_Use, "func_tanklaser", "fw_UseStationary_Post", 1)
	RegisterHam(Ham_Touch, "weaponbox", "fw_TouchWeapon")
	RegisterHam(Ham_Touch, "armoury_entity", "fw_TouchWeapon")
	RegisterHam(Ham_Touch, "weapon_shield", "fw_TouchWeapon")
	for (new i = 1; i < sizeof WEAPONENTNAMES; i++)
		if (WEAPONENTNAMES[i][0]) RegisterHam(Ham_Item_Deploy, WEAPONENTNAMES[i], "fw_Item_Deploy_Post", 1)

	// Message
	register_message(get_user_msgid("StatusIcon"), "Message_StatusIcon")
	register_message(get_user_msgid("TeamScore"), "Message_TeamScore")
	register_message(get_user_msgid("ClCorpse"), "Message_ClCorpse")
	register_message(g_MsgHideWeapon, "Message_HideWeapon")

	// CMD ?
	register_clcmd("nightvision", "CMD_NightVision")
	register_clcmd("radio1", "CMD_Radio")
	register_clcmd("radio2", "CMD_Radio")
	register_clcmd("radio3", "CMD_Radio")

	// Team Mananger
	register_clcmd("chooseteam", "CMD_JoinTeam")
	register_clcmd("jointeam", "CMD_JoinTeam")
	register_clcmd("joinclass", "CMD_JoinTeam")

	// Get Message
	/*
	g_MsgScreenFade = get_user_msgid("ScreenFade")
	g_MsgBarTime = get_user_msgid("BarTime")
	g_MsgScoreAttrib = get_user_msgid("ScoreAttrib")
	g_MsgFlashlight = get_user_msgid("Flashlight")*/
	g_MsgScreenShake = get_user_msgid("ScreenShake")
	g_MsgHideWeapon = get_user_msgid("HideWeapon")
	g_MaxPlayers = get_maxplayers()
	g_Hud_Notice = CreateHudSyncObj(1)
	g_Hud_Game = CreateHudSyncObj(2)

	// Forwards
	/*
	g_Forwards[FW_TRANSGHOST_PRE] = CreateMultiForward("gf_user_transghost_pre", ET_IGNORE, FP_CELL, FP_CELL, FP_CELL)
	g_Forwards[FW_TRANSGHOST_POST] = CreateMultiForward("gf_user_transghost_post", ET_IGNORE, FP_CELL, FP_CELL, FP_CELL)
	g_Forwards[FW_USER_SPAWN] = CreateMultiForward("gf_user_spawn", ET_IGNORE, FP_CELL)
	g_Forwards[FW_USER_DIED] = CreateMultiForward("gf_user_died", ET_IGNORE, FP_CELL, FP_CELL)
	g_Forwards[FW_USER_NVG] = CreateMultiForward("gf_user_nvg", ET_IGNORE, FP_CELL, FP_CELL, FP_CELL)
	g_Forwards[FW_ROUND_NEW] = CreateMultiForward("gf_round_new", ET_IGNORE)
	g_Forwards[FW_ROUND_START] = CreateMultiForward("gf_round_start", ET_IGNORE)
	g_Forwards[FW_GAME_START] = CreateMultiForward("gf_game_start", ET_IGNORE)
	g_Forwards[FW_ROUND_END] = CreateMultiForward("gf_round_end", ET_IGNORE)
	g_Forwards[FW_ROUND_TIME] = CreateMultiForward("gf_round_time", ET_IGNORE, FP_CELL)*/

	// Collect Spawns Point
	Collect_SpawnPoint()

	formatex(GameName, sizeof(GameName), "%L", GAME_LANG, "GAME_NAME")
	IG_EndRound_Block(true, true)

	register_clcmd("say /test", "Test")
	register_clcmd("zeli_base_origin", "BaseOrigin_Handle", ADMIN_ADMIN)
}

public Test(id)
{
	Level_GainExp(id, 100, 1)
}

public plugin_precache()
{
	new BufferB[128], i

	precache_model(HumanBase_Model)
	precache_model(ZombieBase_Model)
	precache_model(HEALTHBAR_SPR)

	precache_sound(StartSound)
	for(i = 1; i <= 10; i++)
	{
		formatex(BufferB, charsmax(BufferB), CountSound, i);
		precache_sound(BufferB);
	}
	for(i = 0; i < sizeof(ZombieBase_HitSound); i++) precache_sound(ZombieBase_HitSound[i])
	for(i = 0; i < sizeof(ZombieBase_DeathSound); i++) precache_sound(ZombieBase_DeathSound[i])
	precache_sound(HumanBase_DeathSound1)
	precache_sound(HumanBase_DeathSound2)

	precache_sound(Human_WinSound)
	precache_sound(Zombie_WinSound)

	g_ZombieDeath_SprId = precache_model(Zombie_DeathSpr)
	precache_sound(Tutorial_MessageSound)

	precache_sound(LevelUpZ_Sound)
	precache_sound(LevelUpH_Sound)

	// Preache custom sky files
	formatex(BufferB, charsmax(BufferB), "gfx/env/%sbk.tga", ENV_SKY); engfunc(EngFunc_PrecacheGeneric, BufferB)
	formatex(BufferB, charsmax(BufferB), "gfx/env/%sdn.tga", ENV_SKY); engfunc(EngFunc_PrecacheGeneric, BufferB)
	formatex(BufferB, charsmax(BufferB), "gfx/env/%sft.tga", ENV_SKY); engfunc(EngFunc_PrecacheGeneric, BufferB)
	formatex(BufferB, charsmax(BufferB), "gfx/env/%slf.tga", ENV_SKY); engfunc(EngFunc_PrecacheGeneric, BufferB)
	formatex(BufferB, charsmax(BufferB), "gfx/env/%srt.tga", ENV_SKY); engfunc(EngFunc_PrecacheGeneric, BufferB)
	formatex(BufferB, charsmax(BufferB), "gfx/env/%sup.tga", ENV_SKY); engfunc(EngFunc_PrecacheGeneric, BufferB)

	// Weather
	new Weather; Weather = ENV_WEATHER
	new Buffer2[16]

	if(Weather == 1) engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "env_rain"))
	else if(Weather == 2) engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "env_snow"))

	parse(ENV_FOG_COLOR, Buffer2[0], 7, Buffer2[1], 7, Buffer2[2], 7)
	g_FogColor[0] = str_to_num(Buffer2[0])
	g_FogColor[1] = str_to_num(Buffer2[1])
	g_FogColor[2] = str_to_num(Buffer2[2])

	// Cache
	m_iBlood[0] = precache_model("sprites/blood.spr")
	m_iBlood[1] = precache_model("sprites/bloodspray.spr")
	g_iSprLightning = precache_model("sprites/laserbeam.spr")
	g_Exp_SprID = precache_model("sprites/zombie_elimination/he_efx12.spr")
	g_GibModelID = precache_model("models/metalplategibs.mdl")

	// Register Forward
	g_BlockedObj_Forward = register_forward(FM_Spawn, "fw_BlockedObj_Spawn")

	// Handle Map
	Read_MapConfig()
}

public plugin_cfg()
{
	// Default Cvars
	set_cvar_num("mp_limitteams", 1)
	set_cvar_num("mp_autoteambalance", 0)
	set_cvar_num("sv_maxspeed", 999)
	set_cvar_num("mp_freezetime", COUNTDOWN_TIME + 2)

	set_cvar_num("mp_flashlight", 1)

	set_cvar_num("sv_skycolor_r", 0)
	set_cvar_num("sv_skycolor_g", 0)
	set_cvar_num("sv_skycolor_b", 0)

	// Exec
	server_exec()
	set_cvar_string("sv_skyname", ENV_SKY)

	// New Round
	Event_NewRound()
}

public fw_BlockedObj_Spawn(ent)
{
	if (!pev_valid(ent))
		return FMRES_IGNORED

	static Ent_Classname[64]
	pev(ent, pev_classname, Ent_Classname, sizeof(Ent_Classname))

	for(new i = 0; i < sizeof g_BlockedObj; i++)
	{
		if (equal(Ent_Classname, g_BlockedObj[i]))
		{
			engfunc(EngFunc_RemoveEntity, ent)
			return FMRES_SUPERCEDE
		}
	}

	return FMRES_IGNORED
}

public Read_MapConfig()
{
	new Path[128]; get_configsdir(Path, charsmax(Path))
	new MapName[64]; get_mapname(MapName, 63)
	format(Path, 63, "%s/%s/%s.base", Path, GAME_FOLDER, MapName)

	if(file_exists(Path))
	{
		new LineData[128], Line
		new File = fopen(Path, "rt")
		new Key[64], Value[64]
		new HandleData[3][48]

		if(!File) return

		while(!feof(File))
		{
			fgets(File, LineData, 127)
			replace(LineData, 127, "^n", "")

			if(LineData[0] == ';' || !LineData[0]) continue

			// Get key and value
			strtok(LineData, Key, 63, Value, 63, '=')

			// Trim spaces
			trim(Key)
			//trim(Value)

			// Base
			if(equal(Key, "HUMAN_BASE_ORIGIN"))
			{
				parse(Value, HandleData[0], 47, HandleData[1], 47, HandleData[2], 47)
				HumanBase_Origin[0] = str_to_float(HandleData[0])
				HumanBase_Origin[1] = str_to_float(HandleData[1])
				HumanBase_Origin[2] = str_to_float(HandleData[2])
			} else if(equal(Key, "HUMAN_BASE_ANGLES")) {
				parse(Value, HandleData[0], 47, HandleData[1], 47, HandleData[2], 47)
				HumanBase_Angles[0] = str_to_float(HandleData[0])
				HumanBase_Angles[1] = str_to_float(HandleData[1])
				HumanBase_Angles[2] = str_to_float(HandleData[2])
			} else if(equal(Key, "ZOMBIE_BASE_ORIGIN")) {
				parse(Value, HandleData[0], 47, HandleData[1], 47, HandleData[2], 47)
				ZombieBase_Origin[0] = str_to_float(HandleData[0])
				ZombieBase_Origin[1] = str_to_float(HandleData[1])
				ZombieBase_Origin[2] = str_to_float(HandleData[2])
			}else if(equal(Key, "ZOMBIE_BASE_ANGLES")) {
				parse(Value, HandleData[0], 47, HandleData[1], 47, HandleData[2], 47)
				ZombieBase_Angles[0] = str_to_float(HandleData[0])
				ZombieBase_Angles[1] = str_to_float(HandleData[1])
				ZombieBase_Angles[2] = str_to_float(HandleData[2])
			}

			Line++
		}

		fclose(File)
		g_DataLoad = 1
	} else {
		g_DataLoad = 0
	}
}

public client_putinserver(id)
{
	Safety_Connected(id)
	set_task(0.25, "Set_ConnectInfo", id)

	Reset_Player(id, 1)

	if(!g_HamBot && is_user_bot(id))
	{
		g_HamBot = 1
		set_task(0.1, "Register_HamBot", id)
	}
}

public Set_ConnectInfo(id)
{
	if(!is_connected(id))
		return

	SetPlayerLight(id, ENV_LIGHT)
	IG_Fog(id, g_FogColor[0], g_FogColor[1], g_FogColor[2], ENV_FOG_DENSITY)
}

public Register_HamBot(id)
{
	Register_SafetyFuncBot(id)

	RegisterHamFromEntity(Ham_Spawn, id, "fw_PlayerSpawn_Post", 1)
	RegisterHamFromEntity(Ham_Killed, id, "fw_PlayerKilled_Post", 1)
	RegisterHamFromEntity(Ham_TraceAttack, id, "fw_PlayerTraceAttack")
	RegisterHamFromEntity(Ham_TakeDamage, id, "fw_PlayerTakeDamage")
}

public client_disconnect(id)
{
	Safety_Disconnected(id)
	Reset_Player(id, 1)

	UnSet_BitVar(g_Joined, id)
}

public IG_RunningTime()
{
	if(g_GameAvailable && (Get_TotalInPlayer(2) < MIN_PLAYER))
	{
		g_GameAvailable = 0
		g_GameStart = 0
		g_GameEnd = 0
	} else if(!g_GameAvailable && (Get_TotalInPlayer(2) >= MIN_PLAYER) && Get_PlayerCount(2, 1) >= 1 && Get_PlayerCount(2, 2) >= 1) { // START GAME NOW :D
		g_GameAvailable = 1
		g_GameStart = 0
		g_GameEnd = 0

		Game_Ending(5.0, 1, CS_TEAM_UNASSIGNED)
	} else if(!g_GameAvailable  && Get_TotalInPlayer(2) < MIN_PLAYER) {
		client_print(0, print_center, "%L", GAME_LANG, "NOTICE_PLAYERREQUIRED", MIN_PLAYER)
	} else if(!g_DataLoad) {
		client_print(0, print_center, "%L", GAME_LANG, "NOTICE_CANTLOAD")
	}
	// Player
	Loop_Player()

	// Check Gameplay
	Check_Gameplay()
}

public Loop_Player()
{
	static PlayerClass[32];
	formatex(PlayerClass, 31, "Berserker")

	for(new id = 0; id < g_MaxPlayers; id++)
	{
		if(!is_alive(id))
			continue

		if(Get_BitVar(g_IsZombie, id))
		{
			set_hudmessage(255, 0, 0, 0.02, 0.925, 0, 1.25, 1.25)
			ShowSyncHudMsg(id, g_Hud_Game, "%L", GAME_LANG, "HUD_LAYOUT_ZOMBIE", get_user_health(id), get_user_armor(id), g_SkillPoint[id], PlayerClass, g_Level[id], g_Experience[id], Level_Experience[min(g_Level[id], MAX_LEVEL-1)])
		} else {
			set_hudmessage(0, 255, 0, 0.02, 0.925, 0, 1.25, 1.25)
			ShowSyncHudMsg(id, g_Hud_Game, "%L", GAME_LANG, "HUD_LAYOUT_HUMAN", get_user_health(id), get_user_armor(id), g_SkillPoint[id], PlayerClass, g_Level[id], g_Experience[id], Level_Experience[min(g_Level[id], MAX_LEVEL-1)])
		}
	}
}

public Check_Gameplay()
{
	if(!g_GameAvailable || !g_GameStart || g_GameEnd)
		return

	if((Get_PlayerCount(1, 1) <= 0) && !pev_valid(g_ZombieBase)) // All zombies are dead
	{
		StopSound(0)
		Game_Ending(5.0, 0, CS_TEAM_CT)

		return
	} else if((Get_PlayerCount(1, 2) <= 0) && !pev_valid(g_HumanBase)) { // All humans are dead
		StopSound(0)
		Game_Ending(5.0, 0, CS_TEAM_T)

		return
	}
}

public Level_GainExp(id, Exp, CheckLvUp)
{
	if(g_Level[id] >= MAX_LEVEL)
		return

	g_Experience[id] = min(g_Experience[id] += Exp, Level_Experience[MAX_LEVEL])
	if(CheckLvUp) Level_CheckUp(id)
}

public Level_CheckUp(id)
{
	if(g_Level[id] >= MAX_LEVEL)
		return

	static HadLevelUp; HadLevelUp = 0
	while(g_Experience[id] >= Level_Experience[g_Level[id]])
	{
		g_Level[id]++
		HadLevelUp = 1
	}

	if(HadLevelUp)
	{ // Player Level Up!
		PlaySound(id, Get_BitVar(g_IsZombie, id) ? LevelUpZ_Sound : LevelUpH_Sound)

		set_hudmessage(0, 255, 0, NOTICE_X, NOTICE_Y, 0, 3.0, 3.0)
		ShowSyncHudMsg(id, g_Hud_Notice, "%L", GAME_LANG, "NOTICE_LEVELUP", g_Level[id])
	}
}

public Event_NewRound()
{
	if(!g_DataLoad) return

	g_GameEnd = 0
	g_GameStart = 0

	if(pev_valid(g_HumanBase)) remove_entity(g_HumanBase)
	if(pev_valid(g_ZombieBase)) remove_entity(g_ZombieBase)

	remove_task(TASK_COUNTDOWN)
	remove_task(TASK_BASEDEATH)

	StopSound(0)

	if(!g_GameAvailable || g_GameEnd)
		return

	PlaySound(0, StartSound)
	Start_Countdown()

	//ExecuteForward(g_Forwards[FW_ROUND_NEW], g_fwResult)
}

public Event_RoundStart()
{
	if(!g_DataLoad) return
	if(!g_GameAvailable || g_GameEnd)
		return

	g_GameStart = 1

	// Set Map time
	static MapTime; MapTime = get_timeleft()
	static Round; Round = MapTime / 60
	IG_RoundTime_Set(Round, clamp(MapTime - (Round * 60), 0, 60))

	// Initialize Base
	Create_TeamBase()
}

public Event_RoundEnd()
{
	g_GameEnd = 1
	g_GameStart = 0
}

public Event_RoundRestart() Event_RoundEnd()
public Event_ResetHUD(id)
{
	message_begin(MSG_ONE_UNRELIABLE, g_MsgHideWeapon, _, id)
	write_byte((1<<3))
	message_end()
}

public Reset_Player(id, NewPlayer)
{
	if(NewPlayer)
	{
		UnSet_BitVar(g_Joined, id)
		g_SkillPoint[id] = g_Level[id] = g_Experience[id] = 0
	}

	UnSet_BitVar(g_IsZombie, id)
}

public Start_Countdown()
{
	g_CountTime = COUNTDOWN_TIME

	remove_task(TASK_COUNTDOWN)
	CountingDown()
}

public CountingDown()
{
	if(!g_GameAvailable || g_GameEnd)
		return
	if(g_CountTime  <= 0)
		return

	client_print(0, print_center, "%L", GAME_LANG, "NOTICE_COUNTDOWN", g_CountTime)

	switch(g_CountTime)
	{
		case 18: Send_Transcript(4.0, 0, "%L", GAME_LANG, "NOTICE_ROUNDSTART1")
		case 14: Send_Transcript(4.0, 0, "%L", GAME_LANG, "NOTICE_ROUNDSTART2")
		case 10: Send_Transcript(4.0, 0, "%L", GAME_LANG, "NOTICE_ROUNDSTART3")
	}

	if(g_CountTime <= 10)
	{
		static Sound[64]; format(Sound, charsmax(Sound), CountSound, g_CountTime)
		PlaySound(0, Sound)
	}

	g_CountTime--
	set_task(1.0, "CountingDown", TASK_COUNTDOWN)
}

public Send_Transcript(Float:Time, Emergency, const Text[], any:...)
{
	static szMsg[128]; vformat(szMsg, sizeof(szMsg) - 1, Text, 4)

	for(new i = 0; i < g_MaxPlayers; i++)
	{
		if(!is_connected(i))
			continue

		set_hudmessage(255, 42, 0, NOTICE_X, NOTICE_Y, Emergency, Time, Time)
		ShowSyncHudMsg(i, g_Hud_Notice, szMsg)

		PlaySound(i, Tutorial_MessageSound)
	}
}


public Game_Ending(Float:EndTime, RoundDraw, CsTeams:Team)
// RoundDraw: Draw or Team Win
// Team: 1 - T | 2 - CT
{
	if(g_GameEnd) return
	if(RoundDraw)
	{
		IG_TerminateRound(WIN_DRAW, EndTime, 0)
		//ExecuteForward(g_Forward_RoundEnd, g_fwResult, CS_TEAM_UNASSIGNED)

		client_print(0, print_center, "%L", GAME_LANG, "NOTICE_GAMESTART")
	} else {
		if(Team == CS_TEAM_T)
		{
			g_TeamScore[TEAM_ZOMBIE]++

			IG_TerminateRound(WIN_TERRORIST, EndTime, 0)
			//ExecuteForward(g_Forward_RoundEnd, g_fwResult, CS_TEAM_T)

			PlaySound(0, Zombie_WinSound)

			set_dhudmessage(200, 0, 0, HUD_WIN_X, HUD_WIN_Y, 0, EndTime, EndTime, 0.0, 1.5)
			show_dhudmessage(0, "%L", GAME_LANG, "NOTICE_WIN_ZOMBIE")
		} else if(Team == CS_TEAM_CT) {
			g_TeamScore[TEAM_HUMAN]++

			IG_TerminateRound(WIN_CT, EndTime, 0)
			//ExecuteForward(g_Forward_RoundEnd, g_fwResult, CS_TEAM_CT)

			PlaySound(0, Human_WinSound)

			set_dhudmessage(0, 200, 0, HUD_WIN_X, HUD_WIN_Y, 0, EndTime, EndTime, 0.0, 1.5)
			show_dhudmessage(0, "%L", GAME_LANG, "NOTICE_WIN_HUMAN")
		}
	}

	//Reward_Team()

	g_GameEnd = 1
}

public BaseOrigin_Handle(id)
{
	static MenuTitle[32]; formatex(MenuTitle, sizeof(MenuTitle), "\y%L\w", GAME_LANG, "MENU_BASEORIGIN")
	new MenuId; MenuId = menu_create(MenuTitle, "MenuHandle_BaseOrigin")

	static Data[64];

	formatex(Data, 63, "Current Origin \r[%i %i %i]\w", floatround(MyOrigin[0]), floatround(MyOrigin[1]), floatround(MyOrigin[2]))
	menu_additem(MenuId, Data, "geto")
	formatex(Data, 63, "Current Angles \r[%i %i %i]\w^n", floatround(MyAngles[0]), floatround(MyAngles[1]), floatround(MyAngles[2]))
	menu_additem(MenuId, Data, "geta")

	formatex(Data, 63, "\yUpdate Origin:\w Human Base \r[%i %i %i]\w", floatround(HumanBase_Origin[0]), floatround(HumanBase_Origin[1]), floatround(HumanBase_Origin[2]))
	menu_additem(MenuId, Data, "uphmo")
	formatex(Data, 63, "\yUpdate Origin:\w Zombie Base \r[%i %i %i]\w", floatround(ZombieBase_Origin[0]), floatround(ZombieBase_Origin[1]), floatround(ZombieBase_Origin[2]))
	menu_additem(MenuId, Data, "upzmo")

	formatex(Data, 63, "\yUpdate Angles:\w Human Base \r[%i %i %i]\w", floatround(HumanBase_Angles[0]), floatround(HumanBase_Angles[1]), floatround(HumanBase_Angles[2]))
	menu_additem(MenuId, Data, "uphma")
	formatex(Data, 63, "\yUpdate Angles:\w Zombie Base \r[%i %i %i]\w^n", floatround(ZombieBase_Angles[0]), floatround(ZombieBase_Angles[1]), floatround(ZombieBase_Angles[2]))
	menu_additem(MenuId, Data, "upzma")

	menu_additem(MenuId, "\rSave Data\w", "save")

	if(pev_valid(id) == 2) set_pdata_int(id, 205, 0, 5)
	menu_display(id, MenuId, 0)
}

public MenuHandle_BaseOrigin(id, Menu, Item)
{
	if((Item == MENU_EXIT) || !is_connected(id))
	{
		menu_destroy(Menu)

		MyOrigin[0] = MyOrigin[1] = MyOrigin[2] = 0.0
		MyAngles[0] = MyAngles[1] = MyAngles[2] = 0.0

		return
	}

	static Data[6], Name[64], ItemAccess, ItemCallback
	menu_item_getinfo(Menu, Item, ItemAccess, Data, charsmax(Data), Name, charsmax(Name), ItemCallback)

	if(equal(Data, "geto"))
	{
		pev(id, pev_origin, MyOrigin)
	} else if(equal(Data, "geta"))
	{
		pev(id, pev_v_angle, MyAngles)
		MyAngles[0] = 0.0
	} else if(equal(Data, "uphmo")) HumanBase_Origin = MyOrigin
	else if(equal(Data, "uphma")) HumanBase_Angles = MyAngles
	else if(equal(Data, "upzmo")) ZombieBase_Origin = MyOrigin
	else if(equal(Data, "upzma")) ZombieBase_Angles = MyAngles
	else if(equal(Data, "save"))
	{
		Save_MapData(id)
	}

	menu_destroy(Menu)
	BaseOrigin_Handle(id)
}

public Save_MapData(id)
{
	new Path[128]; get_configsdir(Path, charsmax(Path))
	new MapName[64]; get_mapname(MapName, 63)
	format(Path, 63, "%s/%s/%s.base", Path, GAME_FOLDER, MapName)

	static LineData[128]

	formatex(LineData, 127, "HUMAN_BASE_ORIGIN = %f %f %f", HumanBase_Origin[0], HumanBase_Origin[1], HumanBase_Origin[2])
	write_file(Path, LineData, 0)
	formatex(LineData, 127, "HUMAN_BASE_ANGLES = %f %f %f", HumanBase_Angles[0], HumanBase_Angles[1], HumanBase_Angles[2])
	write_file(Path, LineData, 1)

	formatex(LineData, 127, "ZOMBIE_BASE_ORIGIN = %f %f %f", ZombieBase_Origin[0], ZombieBase_Origin[1], ZombieBase_Origin[2])
	write_file(Path, LineData, 2)
	formatex(LineData, 127, "ZOMBIE_BASE_ANGLES = %f %f %f", ZombieBase_Angles[0], ZombieBase_Angles[1], ZombieBase_Angles[2])
	write_file(Path, LineData, 3)

	// Notice
	client_print(id, print_chat, "Map Config Updated!")
}

public Create_TeamBase()
{
	static Float:BarOrigin[3]

	// Human Base
	g_HumanBase = create_entity("info_target")

	set_pev(g_HumanBase, pev_origin, HumanBase_Origin)
	set_pev(g_HumanBase, pev_angles, HumanBase_Angles)

	set_pev(g_HumanBase, pev_classname, BASE_CLASSNAME)
	engfunc(EngFunc_SetModel, g_HumanBase, HumanBase_Model)
	set_pev(g_HumanBase, pev_modelindex, engfunc(EngFunc_ModelIndex, HumanBase_Model))

	set_pev(g_HumanBase, pev_gamestate, 1)
	set_pev(g_HumanBase, pev_solid, SOLID_BBOX)
	set_pev(g_HumanBase, pev_movetype, MOVETYPE_NONE)
	set_pev(g_HumanBase, pev_iuser1, 2) // Team
	set_pev(g_HumanBase, pev_iuser2, 0) // Death

	new Float:maxs[3] = {40.0, 40.0, 60.0}
	new Float:mins[3] = {-40.0, -40.0, 0.0}
	engfunc(EngFunc_SetSize, g_HumanBase, mins, maxs)

	set_pev(g_HumanBase, pev_takedamage, DAMAGE_YES)
	set_pev(g_HumanBase, pev_health, 10000.0 + HUMANBASE_HEALTH)

	set_pev(g_HumanBase, pev_animtime, get_gametime())
	set_pev(g_HumanBase, pev_framerate, 1.0)
	set_pev(g_HumanBase, pev_sequence, 0)

	set_pev(g_HumanBase, pev_nextthink, get_gametime() + 0.1)
	drop_to_floor(g_HumanBase)

	BarOrigin = HumanBase_Origin; BarOrigin[2] += 60
	Create_HealthBar(g_HumanBase, BarOrigin, 2)

	// Zombie Base
	g_ZombieBase = create_entity("info_target")

	set_pev(g_ZombieBase, pev_origin, ZombieBase_Origin)
	set_pev(g_ZombieBase, pev_angles, ZombieBase_Angles)
	set_pev(g_ZombieBase, pev_v_angle, ZombieBase_Angles)

	set_pev(g_ZombieBase, pev_classname, BASE_CLASSNAME)
	engfunc(EngFunc_SetModel, g_ZombieBase, ZombieBase_Model)
	set_pev(g_ZombieBase, pev_modelindex, engfunc(EngFunc_ModelIndex, ZombieBase_Model))

	set_pev(g_ZombieBase, pev_gamestate, 1)
	set_pev(g_ZombieBase, pev_solid, SOLID_BBOX)
	set_pev(g_ZombieBase, pev_movetype, MOVETYPE_NONE)
	set_pev(g_ZombieBase, pev_iuser1, 1) // Team
	set_pev(g_ZombieBase, pev_iuser2, 0) // Death

	new Float:maxs2[3] = {80.0, 80.0, 240.0}
	new Float:mins2[3] = {-80.0, -80.0, 0.0}
	engfunc(EngFunc_SetSize, g_ZombieBase, mins2, maxs2)

	set_pev(g_ZombieBase, pev_takedamage, DAMAGE_YES)
	set_pev(g_ZombieBase, pev_health, 10000.0 + ZOMBIEBASE_HEALTH)

	set_pev(g_ZombieBase, pev_animtime, get_gametime())
	set_pev(g_ZombieBase, pev_framerate, 1.0)
	set_pev(g_ZombieBase, pev_sequence, 1)

	set_pev(g_ZombieBase, pev_nextthink, get_gametime() + 0.1)
	drop_to_floor(g_ZombieBase)

	get_position(g_ZombieBase, 100.0, 0.0, 280.0, BarOrigin)
	Create_HealthBar(g_ZombieBase, BarOrigin, 1)

	// Base Creation
	if(!g_BaseCreation)
	{
		g_BaseCreation = 1
		RegisterHamFromEntity(Ham_TraceAttack, g_HumanBase, "fw_Base_TraceAttack_Post", 1)
		RegisterHamFromEntity(Ham_TraceAttack, g_ZombieBase, "fw_Base_TraceAttack_Post", 1)
	}
}

public Create_HealthBar(Ent, Float:Origin[3], Team)
{
	new Bar = create_entity("info_target")

	entity_set_string(Bar, EV_SZ_classname, "healthbar")

	entity_set_int(Bar, EV_INT_solid, SOLID_NOT)
	entity_set_int(Bar, EV_INT_movetype, MOVETYPE_NOCLIP)
	entity_set_edict(Bar, EV_ENT_owner, Ent)
	entity_set_float(Bar, EV_FL_scale, 0.0)
	entity_set_model(Bar, HEALTHBAR_SPR)

	entity_set_origin(Bar, Origin)
	entity_set_float(Bar, EV_FL_frame, 99.0)

	set_pev(Bar, pev_iuser1, Team)
	set_pev(Bar, pev_fuser1, Origin[0])
	set_pev(Bar, pev_fuser2, Origin[1])
	set_pev(Bar, pev_fuser3, Origin[2])

	entity_set_float(Bar, EV_FL_nextthink, halflife_time() + 0.01)
}

/* ===============================
------------ FAKEMETA ------------
=================================*/
public fw_HealthBar_Think(Ent)
{
	static Owner; Owner = entity_get_edict(Ent, EV_ENT_owner)
	if(!is_valid_ent(Owner))
	{
		remove_entity(Ent)
		return
	}

	static Float:Origin[3];
	pev(Ent, pev_fuser1, Origin[0])
	pev(Ent, pev_fuser2, Origin[1])
	pev(Ent, pev_fuser3, Origin[2])

	entity_set_origin(Ent, Origin)
	static Float:MaxHealth

	if(pev(Ent, pev_iuser1) == 1)
	{
		for(new i = 0; i <= g_MaxPlayers; i++)
		{
			if(!is_connected(i))
				continue
			g_ZombieBar_Dis[i] = entity_range(i, Ent)
		}

		MaxHealth = ZOMBIEBASE_HEALTH
		g_ZombieBar = Ent
	} else if(pev(Ent, pev_iuser1) == 2) {
		for(new i = 0; i <= g_MaxPlayers; i++)
		{
			if(!is_connected(i))
				continue
			g_HumanBar_Dis[i] = entity_range(i, Ent)
		}

		MaxHealth = HUMANBASE_HEALTH
		g_HumanBar = Ent
	}

	new Float:Health = entity_get_float(Owner, EV_FL_health) - 10000.0
	new Float:Frame = (Health / MaxHealth) * 99.0

	entity_set_float(Ent, EV_FL_frame, Frame)
	entity_set_float(Ent, EV_FL_nextthink, get_gametime() + 0.01)
}

public fw_Base_Think(Ent)
{
	if(!pev_valid(Ent))
		return
	if(pev(Ent, pev_iuser2))
		return
	if((pev(Ent, pev_health) - 10000.0) <= 0.0)
	{
		if(pev(Ent, pev_iuser1) == 1) ZombieBase_Death(Ent)
		else if(pev(Ent, pev_iuser1) == 2) HumanBase_Death(Ent)

		return
	}

	entity_set_float(Ent, EV_FL_nextthink, get_gametime() + 0.01)
}

public fw_CapitalSaigon_Post(es_handle,e,ent,host,hostflags,player,pSet)
{
	if(!is_connected(host))
		return

	if(ent == g_HumanBar)
	{
		static Float:Scale; Scale = g_HumanBar_Dis[host] / 750.0
		set_es(es_handle, ES_Scale, Scale)
	} else if(ent == g_ZombieBar) {
		static Float:Scale; Scale = g_ZombieBar_Dis[host] / 750.0
		set_es(es_handle, ES_Scale, Scale)
	}
}

public ZombieBase_Death(Ent)
{
	PlaySound(0, ZombieBase_DeathSound[random_num(0, sizeof(ZombieBase_DeathSound) - 1)])

	for(new i = 0; i < g_MaxPlayers; i++)
	{
		if(!is_alive(i))
			continue
		if(entity_range(g_ZombieBase, i) > 640.0)
			continue

		Make_PlayerShake(i)
	}

	set_task(0.1, "ZombieBase_Effect", TASK_BASEDEATH)
	set_task(3.0, "ZombieBase_Death2", TASK_BASEDEATH)
}

public ZombieBase_Effect()
{
	if(!pev_valid(g_ZombieBase))
		return

	// Special Blood
	static Float:Origin[3]

	get_position(g_ZombieBase, 80.0, 0.0, 200.0, Origin);
	MakeBlood(Origin)

	get_position(g_ZombieBase, -80.0, 0.0, 200.0, Origin);
	MakeBlood(Origin)

	//get_position(g_ZombieBase, 0.0, 60.0, 170.0, Origin);
	//MakeBlood(Origin)

	//get_position(g_ZombieBase, 0.0, -60.0, 170.0, Origin);
	//MakeBlood(Origin)

	set_task(0.25, "ZombieBase_Effect", TASK_BASEDEATH)
}

public ZombieBase_Death2()
{
	if(!pev_valid(g_ZombieBase))
		return

	static Float:Origin[3]
	pev(g_ZombieBase, pev_origin, Origin); Origin[2] += 26.0

	message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
	write_byte(TE_EXPLOSION)
	engfunc(EngFunc_WriteCoord, Origin[0])
	engfunc(EngFunc_WriteCoord, Origin[1])
	engfunc(EngFunc_WriteCoord, Origin[2] + 50.0)
	write_short(g_ZombieDeath_SprId)	// sprite index
	write_byte(35)	// scale in 0.1's
	write_byte(10)	// framerate
	write_byte(TE_EXPLFLAG_NOSOUND)	// flags
	message_end()

	/*
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_BREAKMODEL)
	engfunc(EngFunc_WriteCoord, Origin[0])
	engfunc(EngFunc_WriteCoord, Origin[1])
	engfunc(EngFunc_WriteCoord, Origin[2] + 100.0)
	write_coord(256); // size x
	write_coord(256); // size y
	write_coord(256); // size z
	write_coord(random_num(-128,128)); // velocity x
	write_coord(random_num(-128,128)); // velocity y
	write_coord(75); // velocity z
	write_byte(75); // random velocity
	write_short(g_GibModelID2); // model index that you want to break
	write_byte(128); // count
	write_byte(50); // life
	write_byte(0x01); // flags: BREAK_GLASS
	message_end();  */

	remove_entity(g_ZombieBase); g_ZombieBase = 0
}

public HumanBase_Death(Ent)
{
	emit_sound(Ent, CHAN_BODY, HumanBase_DeathSound1, VOL_NORM, ATTN_NORM, 0, PITCH_NORM)

	set_task(0.1, "HumanBase_Effect", TASK_BASEDEATH)
	set_task(2.0, "HumanBase_Death2", TASK_BASEDEATH)

	// Game_Ending(7.0, 0, CS_TEAM_T)
}

public HumanBase_Effect()
{
	if(!pev_valid(g_HumanBase))
		return

	static Float:Origin[3], Float:Origin2[3];

	pev(g_HumanBase, pev_origin, Origin); Origin[2] += 26.0
	get_position(g_HumanBase, random_float(-360.0, 360.0), random_float(-360.0, 360.0), 0.0, Origin2)

	message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
	write_byte(TE_BEAMPOINTS)
	engfunc(EngFunc_WriteCoord, Origin[0])
	engfunc(EngFunc_WriteCoord, Origin[1])
	engfunc(EngFunc_WriteCoord, Origin[2])
	engfunc(EngFunc_WriteCoord, Origin2[0])
	engfunc(EngFunc_WriteCoord, Origin2[1])
	engfunc(EngFunc_WriteCoord, Origin2[2])
	write_short(g_iSprLightning)
	write_byte(0)	// starting frame
	write_byte(0)	// frame rate in 0.1's
	write_byte(10)	// life in 0.1's
	write_byte(10)	// line width in 0.1's
	write_byte(100)	// noise amplitude in 0.01's
	write_byte(42)	// Red
	write_byte(85)	// Green
	write_byte(255)	// Blue
	write_byte(255)	// brightness
	write_byte(25)	// scroll speed in 0.1's
	message_end()

	set_task(0.1, "HumanBase_Effect", TASK_BASEDEATH)
}

public HumanBase_Death2()
{
	if(!pev_valid(g_HumanBase))
		return

	emit_sound(g_HumanBase, CHAN_STATIC, HumanBase_DeathSound2, VOL_NORM, ATTN_NORM, 0, PITCH_NORM)

	static Float:Origin[3]; pev(g_HumanBase, pev_origin, Origin)

	for(new i = 0; i < g_MaxPlayers; i++)
	{
		if(!is_alive(i))
			continue
		if(entity_range(g_HumanBase, i) > 640.0)
			continue

		Make_PlayerShake(i)
		ExecuteHamB(Ham_TakeDamage, i, 0, 0, 99.0, DMG_BLAST)
	}

	remove_entity(g_HumanBase); g_HumanBase = 0

	message_begin(MSG_BROADCAST ,SVC_TEMPENTITY)
	write_byte(TE_EXPLOSION)
	engfunc(EngFunc_WriteCoord, Origin[0])
	engfunc(EngFunc_WriteCoord, Origin[1])
	engfunc(EngFunc_WriteCoord, Origin[2])
	write_short(g_Exp_SprID)	// sprite index
	write_byte(25)	// scale in 0.1's
	write_byte(30)	// framerate
	write_byte(TE_EXPLFLAG_NOSOUND)	// flags
	message_end()

	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_BREAKMODEL)
	engfunc(EngFunc_WriteCoord, Origin[0])
	engfunc(EngFunc_WriteCoord, Origin[1])
	engfunc(EngFunc_WriteCoord, Origin[2] + 26.0)
	write_coord(64); // size x
	write_coord(64); // size y
	write_coord(64); // size z
	write_coord(random_num(-64,64)); // velocity x
	write_coord(random_num(-64,64)); // velocity y
	write_coord(25); // velocity z
	write_byte(25); // random velocity
	write_short(g_GibModelID); // model index that you want to break
	write_byte(32); // count
	write_byte(25); // life
	write_byte(0x01); // flags: BREAK_GLASS
	message_end();
}

public Make_PlayerShake(id)
{
	if(!id)
	{
		message_begin(MSG_BROADCAST, g_MsgScreenShake)
		write_short(8<<12)
		write_short(5<<12)
		write_short(4<<12)
		message_end()
	} else {
		if(!is_user_connected(id))
			return

		message_begin(MSG_BROADCAST, g_MsgScreenShake, _, id)
		write_short(8<<12)
		write_short(5<<12)
		write_short(4<<12)
		message_end()
	}
}

/* ===============================
-------------- HAMS --------------
=================================*/
public fw_PlayerSpawn_Post(id)
{
	if(!is_connected(id)) return

	if(!Get_BitVar(g_Joined, id)) Set_BitVar(g_Joined, id)

	Reset_Player(id, 0)
	Spawn_PlayerRandom(id, cs_get_user_team(id) == CS_TEAM_T ? 1 : 0)

	/*
	// Set Human
	Set_PlayerNVG(id, 0, 0, 0, 1)
	fm_set_user_rendering(id)
	set_task(0.01, "Set_LightStart", id)
	IG_DLight_Reset(id)
	IG_Fog(id, g_FogColor_Human[0], g_FogColor_Human[1], g_FogColor_Human[2], 1)

	set_pdata_int(id, m_iRadiosLeft, RADIO_MAXSEND, OFFSET_PLAYER_LINUX)

	Set_PlayerHealth(id, g_HumanHealth, 1)
	set_pev(id, pev_gravity, g_HumanGravity)
	cs_set_user_armor(id, g_HumanArmor, CS_ARMOR_KEVLAR)
	IG_SpeedReset(id)

	// Start Weapon
	fm_strip_user_weapons(id)
	fm_give_item(id, "weapon_knife")
	fm_give_item(id, "weapon_usp")
	give_ammo(id, 1, CSW_USP)
	give_ammo(id, 1, CSW_USP)

	IG_TeamSet(id, CS_TEAM_CT)
	g_MyCSTeam[id] = CS_TEAM_CT

	IG_ModelSet(id, g_PlayerOwnModel[id], 1)

	// Fade Out
	message_begin(MSG_ONE_UNRELIABLE, g_MsgScreenFade, {0,0,0}, id)
	write_short(FixedUnsigned16(2.5, 1<<12))
	write_short(FixedUnsigned16(2.5, 1<<12))
	write_short((0x0000))
	write_byte(0)
	write_byte(0)
	write_byte(0)
	write_byte(255)
	message_end()

	//ExecuteForward(g_Forwards[FW_USER_SPAWN], g_fwResult, id)

	// Show Info
	static String[96]
	formatex(String, sizeof(String), "!g[%s]!n %L", GameName, GAME_LANG, "GAME_NOTICE_REMINDHELP")
	IG_ClientPrintColor(id, String)*/
}


public fw_PlayerTraceAttack(Victim, Attacker, Float:Damage, Float:Direction[3], Trace, DamageBits)
{
	if(!g_GameAvailable || g_GameEnd || !g_GameStart)
		return HAM_SUPERCEDE
	if(Victim == Attacker)
		return HAM_SUPERCEDE

	return HAM_HANDLED
}

public fw_PlayerTakeDamage(Victim, Inflictor, Attacker, Float:Damage, DamageBits)
{
	if(!g_GameAvailable || g_GameEnd || !g_GameStart)
		return HAM_SUPERCEDE
	if(Victim == Attacker)
		return HAM_SUPERCEDE

	return HAM_HANDLED
}

public fw_Base_TraceAttack_Post(Victim, Attacker, Float:Damage, Float:Direction[3], Trace, DamageBits)
{
	if(!g_GameAvailable || g_GameEnd || !g_GameStart)
		return HAM_SUPERCEDE
	if(Victim == Attacker)
		return HAM_SUPERCEDE

	static Classname[32]; pev(Victim, pev_classname, Classname, 31)
	if(!equal(Classname, BASE_CLASSNAME))
		return HAM_IGNORED

	if(pev(Victim, pev_iuser1) == 1)
	{ // Zombie Base

		// Special Blood
		static Float:Origin[3], Float:EndPoint[3]
		get_tr2(Trace, TR_vecEndPos, EndPoint)

		get_position(Victim, 80.0, 0.0, 200.0, Origin); Origin[2] = EndPoint[2]
		MakeBlood(Origin)

		get_position(Victim, -80.0, 0.0, 200.0, Origin); Origin[2] = EndPoint[2]
		MakeBlood(Origin)

		get_position(Victim, 0.0, 60.0, 170.0, Origin); Origin[2] = EndPoint[2]
		MakeBlood(Origin)

		get_position(Victim, 0.0, -60.0, 170.0, Origin); Origin[2] = EndPoint[2]
		MakeBlood(Origin)

		emit_sound(Victim, CHAN_BODY, ZombieBase_HitSound[random_num(0, sizeof(ZombieBase_HitSound) - 1)], VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
	} else if(pev(Victim, pev_iuser1) == 2) { // Human Base

	}

	return HAM_HANDLED
}

public fw_UseStationary(entity, caller, activator, use_type)
{
	if (use_type == 2 && is_connected(caller) && is_zombie(caller))
		return HAM_SUPERCEDE

	return HAM_IGNORED
}

public fw_UseStationary_Post(entity, caller, activator, use_type)
{
	if(use_type == 0 && is_connected(caller) && is_zombie(caller))
	{
		//if(!Get_BitVar(g_IsGhoulEx, caller)) set_pev(caller, pev_viewmodel2, Ar_GhoulClawModel)
		//else set_pev(caller, pev_viewmodel2, Ar_GhoulexClawModel)
		//set_pev(caller, pev_weaponmodel2, "")
	}
}

public fw_TouchWeapon(weapon, id)
{
	if(!is_connected(id))
		return HAM_IGNORED
	if(is_zombie(id))
		return HAM_SUPERCEDE

	return HAM_IGNORED
}

public fw_Item_Deploy_Post(weapon_ent)
{
	new owner = fm_cs_get_weapon_ent_owner(weapon_ent)
	if (!is_alive(owner))
		return;

	new CSWID; CSWID = cs_get_weapon_id(weapon_ent)
	if(is_zombie(owner))
	{
		/*
		if(CSWID == CSW_KNIFE)
		{
			static Hand[32], Hand2[64]; ArrayGetString(Get_BitVar(g_IsGhoulEx, owner) ? Ar_GhoulexClawModel : Ar_GhoulClawModel, g_MyGhoulHand[owner], Hand, sizeof(Hand))
			formatex(Hand2, sizeof(Hand2), "models/%s/%s", GAME_FOLDER, Hand)

			if(!Get_BitVar(g_IsGhoulEx, owner)) set_pev(owner, pev_viewmodel2, Hand2)
			else set_pev(owner, pev_viewmodel2, Hand2)
			set_pev(owner, pev_weaponmodel2, "")
		} else {
			strip_user_weapons(owner)
			give_item(owner, "weapon_knife")

			engclient_cmd(owner, "weapon_knife")
		}*/
	}
}

public fw_PlayerKilled_Post(Victim, Attacker)
{
	//ExecuteForward(g_Forwards[FW_USER_DIED], g_fwResult, Victim, Attacker)

	// Check Gameplay
	Check_Gameplay()
}

public MakeBlood(const Float:Origin[3])
{
	message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
	write_byte(TE_BLOODSPRITE)
	engfunc(EngFunc_WriteCoord, Origin[0])
	engfunc(EngFunc_WriteCoord, Origin[1])
	engfunc(EngFunc_WriteCoord, Origin[2])
	write_short(m_iBlood[1])
	write_short(m_iBlood[0])
	write_byte(75)
	write_byte(25)
	message_end()
}

public Spawn_PlayerRandom(id, TERRORIST) // TERRORIST = 1, CT = 0
{
	if(TERRORIST)
	{
		if(!g_TSpawn_Count)
			return

		static hull, sp_index, i

		hull = (pev(id, pev_flags) & FL_DUCKING) ? HULL_HEAD : HULL_HUMAN
		sp_index = random_num(0, g_TSpawn_Count - 1)

		for (i = sp_index + 1; /*no condition*/; i++)
		{
			if(i >= g_TSpawn_Count) i = 0

			if(is_hull_vacant(g_TSpawn_Point[i], hull))
			{
				engfunc(EngFunc_SetOrigin, id, g_TSpawn_Point[i])
				break
			}

			if (i == sp_index) break
		}
	} else {
		if(!g_CTSpawn_Count)
			return

		static hull, sp_index, i

		hull = (pev(id, pev_flags) & FL_DUCKING) ? HULL_HEAD : HULL_HUMAN
		sp_index = random_num(0, g_CTSpawn_Count - 1)

		for (i = sp_index + 1; /*no condition*/; i++)
		{
			if(i >= g_CTSpawn_Count) i = 0

			if(is_hull_vacant(g_CTSpawn_Point[i], hull))
			{
				engfunc(EngFunc_SetOrigin, id, g_CTSpawn_Point[i])
				break
			}

			if (i == sp_index) break
		}
	}
}

public Collect_SpawnPoint()
{
	static ent; ent = -1
	while ((ent = engfunc(EngFunc_FindEntityByString, ent, "classname", "info_player_start")) != 0)
	{
		// get origin
		static Float:originF[3]
		pev(ent, pev_origin, originF)

		g_CTSpawn_Point[g_CTSpawn_Count][0] = originF[0]
		g_CTSpawn_Point[g_CTSpawn_Count][1] = originF[1]
		g_CTSpawn_Point[g_CTSpawn_Count][2] = originF[2]

		// increase spawn count
		g_CTSpawn_Count++
		if(g_CTSpawn_Count >= sizeof g_CTSpawn_Point) break;
	}

	ent = 1;
	while ((ent = engfunc(EngFunc_FindEntityByString, ent, "classname", "info_player_deathmatch")) != 0)
	{
		// get origin
		static Float:originF[3]
		pev(ent, pev_origin, originF)

		g_TSpawn_Point[g_TSpawn_Count][0] = originF[0]
		g_TSpawn_Point[g_TSpawn_Count][1] = originF[1]
		g_TSpawn_Point[g_TSpawn_Count][2] = originF[2]

		// increase spawn count
		g_TSpawn_Count++
		if(g_CTSpawn_Count >= sizeof g_TSpawn_Point) break;
	}
}

/* ===============================
----------- CMD & MSG ------------
=================================*/
public CMD_Radio(id)
{
	if(!is_alive(id))
		return PLUGIN_CONTINUE
	if(is_zombie(id))
		return PLUGIN_HANDLED

	return PLUGIN_CONTINUE
}

public CMD_JoinTeam(id)
{
	if(!Get_BitVar(g_Joined, id))
		return PLUGIN_CONTINUE

	//Open_GameMenu(id)

	return PLUGIN_HANDLED
}


public CMD_NightVision(id)
{
	//if(!Get_BitVar(g_Has_NightVision, id))
	//	return PLUGIN_HANDLED

	//if(!Get_BitVar(g_UsingNVG, id)) set_user_nightvision(id, 1, 1, 0)
	//else set_user_nightvision(id, 0, 1, 0)

	return PLUGIN_HANDLED;
}


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))
	{
		if(pev_valid(msg_entity) != PDATA_SAFE)
			return  PLUGIN_CONTINUE;

		set_pdata_int(msg_entity, 235, get_pdata_int(msg_entity, 235) & ~(1<<0))
		return PLUGIN_HANDLED;
	}

	return PLUGIN_CONTINUE;
}

public Message_TeamScore()
{
	static Team[2]
	get_msg_arg_string(1, Team, charsmax(Team))

	switch(Team[0])
	{
		case 'C': set_msg_arg_int(2, get_msg_argtype(2), g_TeamScore[TEAM_HUMAN])
		case 'T': set_msg_arg_int(2, get_msg_argtype(2), g_TeamScore[TEAM_ZOMBIE])
	}
}

public Message_ClCorpse()
{
	return PLUGIN_HANDLED
}

public Message_HideWeapon()
{
	set_msg_arg_int(1, ARG_BYTE, get_msg_arg_int(1) | (1<<3))
}

/* ===============================
------------- SAFETY -------------
=================================*/
public Register_SafetyFunc()
{
	register_event("CurWeapon", "Safety_CurWeapon", "be", "1=1")

	RegisterHam(Ham_Spawn, "player", "fw_Safety_Spawn_Post", 1)
	RegisterHam(Ham_Killed, "player", "fw_Safety_Killed_Post", 1)
}

public Register_SafetyFuncBot(id)
{
	RegisterHamFromEntity(Ham_Spawn, id, "fw_Safety_Spawn_Post", 1)
	RegisterHamFromEntity(Ham_Killed, id, "fw_Safety_Killed_Post", 1)
}

public Safety_Connected(id)
{
	Set_BitVar(g_IsConnected, id)
	UnSet_BitVar(g_IsAlive, id)

	g_PlayerWeapon[id] = 0
}

public Safety_Disconnected(id)
{
	UnSet_BitVar(g_IsConnected, id)
	UnSet_BitVar(g_IsAlive, id)

	g_PlayerWeapon[id] = 0
}

public Safety_CurWeapon(id)
{
	if(!is_alive(id))
		return

	static CSW; CSW = read_data(2)
	if(g_PlayerWeapon[id] != CSW) g_PlayerWeapon[id] = CSW
}

public fw_Safety_Spawn_Post(id)
{
	if(!is_user_alive(id))
		return

	Set_BitVar(g_IsAlive, id)
}

public fw_Safety_Killed_Post(id)
{
	UnSet_BitVar(g_IsAlive, id)
}

public is_connected(id)
{
	if(!(1 <= id <= 32))
		return 0
	if(!Get_BitVar(g_IsConnected, id))
		return 0

	return 1
}

public is_alive(id)
{
	if(!is_connected(id))
		return 0
	if(!Get_BitVar(g_IsAlive, id))
		return 0

	return 1
}

public get_player_weapon(id)
{
	if(!is_alive(id))
		return 0

	return g_PlayerWeapon[id]
}


// ===================== STOCK.... =======================
// ======================================================
public is_zombie(id)
{
	return Get_BitVar(g_IsZombie, id)
}

stock Get_RandomArray(Array:ArrayName)
{
	return random_num(0, ArraySize(ArrayName) - 1)
}

stock Get_PlayerCount(Alive, Team)
// Alive: 0 - Dead | 1 - Alive | 2 - Both
// Team: 1 - T | 2 - CT
{
	new Flag[4], Flag2[12]
	new Players[32], PlayerNum

	if(!Alive) formatex(Flag, sizeof(Flag), "%sb", Flag)
	else if(Alive == 1) formatex(Flag, sizeof(Flag), "%sa", Flag)

	if(Team == 1)
	{
		formatex(Flag, sizeof(Flag), "%se", Flag)
		formatex(Flag2, sizeof(Flag2), "TERRORIST", Flag)
	} else if(Team == 2)
	{
		formatex(Flag, sizeof(Flag), "%se", Flag)
		formatex(Flag2, sizeof(Flag2), "CT", Flag)
	}

	get_players(Players, PlayerNum, Flag, Flag2)

	return PlayerNum
}

stock Get_TotalInPlayer(Alive)
{
	return Get_PlayerCount(Alive, 1) + Get_PlayerCount(Alive, 2)
}


stock PlaySound(id, const sound[])
{
	if(equal(sound[strlen(sound)-4], ".mp3")) client_cmd(id, "mp3 play ^"sound/%s^"", sound)
	else client_cmd(id, "spk ^"%s^"", sound)
}
stock StopSound(id) client_cmd(id, "mp3 stop; stopsound")
stock EmitSound(id, Channel, const Sound[]) emit_sound(id, Channel, Sound, VOL_NORM, ATTN_NORM, 0, PITCH_NORM)

stock is_hull_vacant(Float:Origin[3], hull)
{
	engfunc(EngFunc_TraceHull, Origin, Origin, 0, hull, 0, 0)

	if (!get_tr2(0, TR_StartSolid) && !get_tr2(0, TR_AllSolid) && get_tr2(0, TR_InOpen))
		return true

	return false
}

stock SetPlayerLight(id, const LightStyle[])
{
	if(id != 0)
	{
		message_begin(MSG_ONE_UNRELIABLE, SVC_LIGHTSTYLE, .player = id)
		write_byte(0)
		write_string(LightStyle)
		message_end()
	} else {
		message_begin(MSG_BROADCAST, SVC_LIGHTSTYLE)
		write_byte(0)
		write_string(LightStyle)
		message_end()
	}
}

stock FixedUnsigned16(Float:flValue, iScale)
{
	new iOutput;

	iOutput = floatround(flValue * iScale);

	if ( iOutput < 0 )
		iOutput = 0;

	if ( iOutput > 0xFFFF )
		iOutput = 0xFFFF;

	return iOutput;
}

stock fm_cs_get_weapon_ent_owner(ent)
{
	// Prevent server crash if entity's private data not initalized
	if (pev_valid(ent) != PDATA_SAFE)
		return -1;

	return get_pdata_cbase(ent, OFFSET_WEAPONOWNER, OFFSET_WEAPON_LINUX);
}

stock Set_WeaponAnim(id, anim)
{
	set_pev(id, pev_weaponanim, anim)

	message_begin(MSG_ONE_UNRELIABLE, SVC_WEAPONANIM, _, id)
	write_byte(anim)
	write_byte(0)
	message_end()
}

stock Set_Player_NextAttack(id, Float:Time)
{
	if(pev_valid(id) != PDATA_SAFE)
		return

	set_pdata_float(id, 83, Time, 5)
}

stock get_position(ent, Float:forw, Float:right, Float:up, Float:vStart[])
{
	if(!pev_valid(ent))
		return

	static Float:vOrigin[3], Float:vAngle[3], Float:vForward[3], Float:vRight[3], Float:vUp[3]

	pev(ent, pev_origin, vOrigin)
	pev(ent, pev_view_ofs,vUp) //for player
	xs_vec_add(vOrigin,vUp,vOrigin)
	pev(ent, pev_angles, vAngle) // if normal entity ,use pev_angles

	vAngle[0] = 0.0

	angle_vector(vAngle,ANGLEVECTOR_FORWARD,vForward) //or use EngFunc_AngleVectors
	angle_vector(vAngle,ANGLEVECTOR_RIGHT,vRight)
	angle_vector(vAngle,ANGLEVECTOR_UP,vUp)

	vStart[0] = vOrigin[0] + vForward[0] * forw + vRight[0] * right + vUp[0] * up
	vStart[1] = vOrigin[1] + vForward[1] * forw + vRight[1] * right + vUp[1] * up
	vStart[2] = vOrigin[2] + vForward[2] * forw + vRight[2] * right + vUp[2] * up
}