Problema [SVC_DIRECTOR] Server tried to send invalid command:

[MarcoReusNr1]

Salutare, am o problema, scoate playerii de pe server chiar si pe mine, in consola sv-ului nu arata nimic, dar in consola jocului imi apare asa:

| Afiseaza codul

[SVC_DIRECTOR] Server tried to send invalid command:.
Last 32 messages parsed.
126166 0029 svc_deltapacketentities
126166 0080 svc_temp_entity
126166 0106 svc_sound
126169 0008 svc_time
126169 0013 svc_clientdata
126169 0029 svc_deltapacketentities
126169 0079 svc_temp_entity
126171 0008 svc_time
126171 0013 svc_clientdata
126171 0029 svc_deltapacketentities
126171 0067 svc_temp_entity
126173 0008 DeathMsg
126173 0019 svc_stufftext
126173 0057 svc_stufftext
126173 0100 TeamInfo
126173 0113 SayText
126173 0191 Money
126173 0197 ScoreInfo
126173 0207 ScoreAttrib
126173 0210 TeamScore
126173 0217 TeamScore
126173 0231 TextMsg
126173 0249 svc_time
126173 0254 svc_clientdata
126173 0276 svc_deltapacketentities
126173 0341 svc_temp_entity
126173 0367 svc_temp_entity
126173 0381 svc_sound
126173 0393 svc_temp_entity
126173 0464 svc_temp_entity
126173 0513 svc_director
BAD: 519:svc_bad
Host_Error: CL_ParseServerMessage: Illegible serve 

Banuiesc ca mesajele sunt de pluginul de baza si as vrea sa stiu daca se poate rezolva, voi lasa aici sursa
Sursa:

| Afiseaza codul

 /* Biohazard mod
*   
*  by Cheap_Suit
*
*  This program is free software; you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by the
*  Free Software Foundation; either version 2 of the License, or (at
*  your option) any later version.
*
*  This program is distributed in the hope that it will be useful, but
*  WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
*  General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software Foundation,
*  Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*  In addition, as a special exception, the author gives permission to
*  link the code of this program with the Half-Life Game Engine ("HL
*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
*  L.L.C ("Valve"). You must obey the GNU General Public License in all
*  respects for all of the code used other than the HL Engine and MODs
*  from Valve. If you modify this file, you may extend this exception
*  to your version of the file, but you are not obligated to do so. If
*  you do not wish to do so, delete this exception statement from your
*  version.
*/

#define VERSION    "2.00 Beta 3"

#include <amxmodx>
#include <amxmisc>
#include <fakemeta>
#include <hamsandwich>
#include <xs>

#tryinclude "biohazard.cfg"

#if !defined _biohazardcfg_included
    #assert Biohazard configuration file required!
#elseif AMXX_VERSION_NUM < 180
    #assert AMX Mod X v1.8.0 or greater required!
#endif

#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 OFFSET_WEAPONOWNER 41
#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 OFFSET_LASTPRIM 368
#define OFFSET_LASTSEC 369
#define OFFSET_LASTKNI 370

#define TASKID_STRIPNGIVE 698
#define TASKID_NEWROUND 641
#define TASKID_INITROUND 222
#define TASKID_STARTROUND 153
#define TASKID_BALANCETEAM 375
#define TASKID_UPDATESCR 264
#define TASKID_SPAWNDELAY 786
#define TASKID_WEAPONSMENU 564
#define TASKID_CHECKSPAWN 423
#define TASKID_CZBOTPDATA 312
#define TASKID_GLOWSHELL 718
#define TASKID_RESPAWN 748
#define TASKID_MODEL 156

#define PEV_NADE_TYPE pev_flTimeStepSound
#define NADE_TYPE_FROST 3333

#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 HAS_NVG (1<<0)
#define ATTRIB_BOMB (1<<1)
#define DMG_HEGRENADE (1<<24)

#define IMPULSE_FLASHLIGHT 100

#define MAX_SPAWNS 128
#define MAX_CLASSES 10
#define MAX_DATA 11

#define DATA_HEALTH 0
#define DATA_SPEED 1
#define DATA_GRAVITY 2
#define DATA_ATTACK 3
#define DATA_DEFENCE 4
#define DATA_HEDEFENCE 5
#define DATA_HITSPEED 6
#define DATA_HITDELAY 7
#define DATA_REGENDLY 8
#define DATA_HITREGENDLY 9
#define DATA_KNOCKBACK 10

#define fm_get_user_team(%1) get_pdata_int(%1, OFFSET_TEAM)
#define fm_get_user_deaths(%1) get_pdata_int(%1, OFFSET_DEATH)
#define fm_set_user_deaths(%1,%2) set_pdata_int(%1, OFFSET_DEATH, %2)
#define fm_get_user_money(%1) get_pdata_int(%1, OFFSET_CSMONEY)
#define fm_get_user_armortype(%1) get_pdata_int(%1, OFFSET_ARMOR)
#define fm_set_user_armortype(%1,%2) set_pdata_int(%1, OFFSET_ARMOR, %2)
#define fm_get_weapon_id(%1) get_pdata_int(%1, OFFSET_WEAPONTYPE, EXTRAOFFSET_WEAPONS)
#define fm_get_weapon_ammo(%1) get_pdata_int(%1, OFFSET_CLIPAMMO, EXTRAOFFSET_WEAPONS)
#define fm_set_weapon_ammo(%1,%2) set_pdata_int(%1, OFFSET_CLIPAMMO, %2, EXTRAOFFSET_WEAPONS)
#define fm_reset_user_primary(%1) set_pdata_int(%1, OFFSET_PRIMARYWEAPON, 0)
#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 _random(%1) random_num(0, %1 - 1)
#define AMMOWP_NULL (1<<0 | 1<<CSW_KNIFE | 1<<CSW_FLASHBANG | 1<<CSW_HEGRENADE | 1<<CSW_SMOKEGRENADE | 1<<CSW_C4)

enum
{
    MAX_CLIP = 0,
    MAX_AMMO
}

enum
{
    MENU_PRIMARY = 1,
    MENU_SECONDARY
}

enum
{
    CS_TEAM_UNASSIGNED = 0,
    CS_TEAM_T,
    CS_TEAM_CT,
    CS_TEAM_SPECTATOR
}

enum
{
    CS_ARMOR_NONE = 0,
    CS_ARMOR_KEVLAR,
    CS_ARMOR_VESTHELM
}

enum
{
    KBPOWER_357SIG = 0,
    KBPOWER_762NATO,
    KBPOWER_BUCKSHOT,
    KBPOWER_45ACP,
    KBPOWER_556NATO,
    KBPOWER_9MM,
    KBPOWER_57MM,
    KBPOWER_338MAGNUM,
    KBPOWER_556NATOBOX,
    KBPOWER_50AE
}

const UNIT_SECOND = (1<<12)
const BREAK_GLASS = 0x01
const FFADE_IN = 0x0000
const FFADE_STAYOUT = 0x0004

new const g_weapon_ammo[][] =
{
    { -1, -1 },
    { 13, 52 },
    { -1, -1 },
    { 10, 90 },
    { -1, -1 },
    { 7, 32 },
    { -1, -1 },
    { 30, 100 },
    { 30, 90 },
    { -1, -1 },
    { 35, 140 },
    { 20, 100 },
    { 25, 100 },
    { 30, 90 },
    { 35, 105 },
    { 25, 90 },
    { 12, 100 },
    { 20, 120 },
    { 10, 30 },
    { 35, 140 },
    { 100, 200 },
    { 8, 32 },
    { 30, 90 },
    { 35, 140 },
    { 20, 90 },
    { -1, -1 },
    { 8, 40 },
    { 30, 90 },
    { 30, 90 },
    { -1, -1 },
    { 50, 100 }
}

new const g_weapon_knockback[] =
{
    -1, 
    KBPOWER_357SIG, 
    -1, 
    KBPOWER_762NATO, 
    -1, 
    KBPOWER_BUCKSHOT, 
    -1, 
    KBPOWER_45ACP, 
    KBPOWER_556NATO, 
    -1, 
    KBPOWER_9MM, 
    KBPOWER_57MM,
    KBPOWER_45ACP, 
    KBPOWER_556NATO, 
    KBPOWER_556NATO, 
    KBPOWER_556NATO, 
    KBPOWER_45ACP,
    KBPOWER_9MM, 
    KBPOWER_338MAGNUM,
    KBPOWER_9MM, 
    KBPOWER_556NATOBOX,
    KBPOWER_BUCKSHOT, 
    KBPOWER_556NATO, 
    KBPOWER_9MM, 
    KBPOWER_762NATO, 
    -1, 
    KBPOWER_50AE, 
    KBPOWER_556NATO, 
    KBPOWER_762NATO, 
    -1, 
    KBPOWER_57MM
}

new const sky_terminations[][] = 
{
    "bk",
    "dn",
    "ft",
    "lf",
    "rt",
    "up"
}

new const g_remove_entities[][] = 
{ 
    "func_bomb_target",    
    "info_bomb_target", 
    "hostage_entity",      
    "monster_scientist", 
    "func_hostage_rescue", 
    "info_hostage_rescue",
    "info_vip_start",      
    "func_vip_safetyzone", 
    "func_escapezone",     
    "func_buyzone"
}

new const g_dataname[][] = 
{ 
    "HEALTH", 
    "SPEED", 
    "GRAVITY", 
    "ATTACK", 
    "DEFENCE", 
    "HEDEFENCE", 
    "HITSPEED", 
    "HITDELAY", 
    "REGENDLY", 
    "HITREGENDLY", 
    "KNOCKBACK" 
}
new const g_teaminfo[][] = 
{ 
    "UNASSIGNED", 
    "TERRORIST",
    "CT",
    "SPECTATOR" 
}

new g_maxplayers, g_buyzone, g_botclient_pdata, bool:g_roundended, bool:g_czero
new g_spawncount, Float:g_spawns[MAX_SPAWNS+1][9]
new g_sync_hpdisplay, g_sync_msgdisplay
new g_fwd_spawn, g_fwd_result, g_fwd_infect, g_fwd_gamestart;
new g_msg_flashlight, g_msg_teaminfo, g_msg_scoreattrib, g_msg_money, g_msg_scoreinfo, g_msg_deathmsg , g_msg_screenfade, g_msg_statusicon
new Float:g_buytime, Float:g_vecvel[3]

new g_class_name[MAX_CLASSES+1][32], g_classcount, g_class_desc[MAX_CLASSES+1][32], g_class_pmodel[MAX_CLASSES+1][64], 
g_class_wmodel[MAX_CLASSES+1][64], Float:g_class_data[MAX_CLASSES+1][MAX_DATA], g_player_class[33]

new bool:g_zombie[33], bool:g_preinfect[33], bool:g_falling[33], bool:g_disconnected[33], bool:g_showmenu[33],
bool:g_menufailsafe[33], bool:g_welcomemsg[33], bool:g_frozen[33]

new bool:g_brestorevel, bool:g_infecting, bool:g_gamestarted, bool:g_roundstarted
new Float:g_regendelay[33], Float:g_hitdelay[33]
new g_respawn[33], g_mutate[33], g_victim[33], g_menuposition[33], g_player_weapons[33][2]

new cvar_randomspawn, cvar_skyname, cvar_autoteambalance[4], cvar_starttime, cvar_autonvg, cvar_winsounds, 
cvar_weaponsmenu, cvar_lights, cvar_killbonus, cvar_enabled, cvar_gamedescription, cvar_botquota, cvar_maxzombies, 
cvar_flashbang, cvar_buytime, cvar_infectmoney, cvar_showtruehealth,
cvar_obeyarmor, cvar_impactexplode, cvar_caphealthdisplay, cvar_zombie_hpmulti, cvar_randomclass, cvar_zombiemulti, 
cvar_knockback, cvar_knockback_dist, cvar_ammo, cvar_knockback_duck, cvar_killreward, cvar_painshockfree, 
cvar_zombie_class, cvar_shootobjects, cvar_pushpwr_weapon, cvar_pushpwr_zombie, cvar_deathmatch, 
cvar_spawnprotection, cvar_spawndelay, cvar_respawnafterlast, cvar_freezeduration, cvar_frostgrenades

#if defined EFFECT_SPAWN
new sprite_spawn_effect
#endif

new g_explosfr, trailSpr, g_exploSpr, frostgib, g_glassSpr
new Ham:Ham_Player_ResetMaxSpeed = Ham_Item_PreFrame

new g_playermodel[33][32]
new Float:g_models_targettime, Float:g_modelchange_delay = 0.1

public plugin_precache()
{
    register_plugin("Biohazard", VERSION, "cheap_suit")
    register_cvar("bh_version", VERSION, FCVAR_SPONLY|FCVAR_SERVER)
    set_cvar_string("bh_version", VERSION)
    
    cvar_enabled = register_cvar("bh_enabled", "1")

    if(!get_pcvar_num(cvar_enabled)) 
        return
    
    cvar_gamedescription = register_cvar("bh_gamedescription", "Biohazard")
    cvar_skyname = register_cvar("bh_skyname", "xen8")
    cvar_lights = register_cvar("bh_lights", "d")
    cvar_starttime = register_cvar("bh_starttime", "15.0")
    cvar_buytime = register_cvar("bh_buytime", "0")
    cvar_randomspawn = register_cvar("bh_randomspawn", "1")
    cvar_winsounds = register_cvar("bh_winsounds", "1")
    cvar_autonvg = register_cvar("bh_autonvg", "1")
    cvar_painshockfree = register_cvar("bh_painshockfree", "1")
    cvar_knockback = register_cvar("bh_knockback", "1")
    cvar_knockback_duck = register_cvar("bh_knockback_duck", "1")
    cvar_knockback_dist = register_cvar("bh_knockback_dist", "280.0")
    cvar_obeyarmor = register_cvar("bh_obeyarmor", "1")
    cvar_infectmoney = register_cvar("bh_infectionmoney", "500")
    cvar_caphealthdisplay = register_cvar("bh_caphealthdisplay", "1")
    cvar_weaponsmenu = register_cvar("bh_weaponsmenu", "1")
    cvar_ammo = register_cvar("bh_ammo", "1")
    cvar_maxzombies = register_cvar("bh_maxzombies", "31")
    cvar_flashbang = register_cvar("bh_flashbang", "1")
    cvar_impactexplode = register_cvar("bh_impactexplode", "1")
    cvar_showtruehealth = register_cvar("bh_showtruehealth", "1")
    cvar_zombiemulti = register_cvar("bh_zombie_countmulti", "0.15")
    cvar_zombie_hpmulti = register_cvar("bh_zombie_hpmulti", "2.0")
    cvar_zombie_class = register_cvar("bh_zombie_class", "1")
    cvar_randomclass = register_cvar("bh_randomclass", "1")
    cvar_killbonus = register_cvar("bh_kill_bonus", "1")
    cvar_killreward = register_cvar("bh_kill_reward", "2")
    cvar_shootobjects = register_cvar("bh_shootobjects", "1")
    cvar_pushpwr_weapon = register_cvar("bh_pushpwr_weapon", "2.0")
    cvar_pushpwr_zombie = register_cvar("bh_pushpwr_zombie", "5.0")
    cvar_deathmatch = register_cvar("bh_deathmatch", "1")
    cvar_spawndelay = register_cvar("bh_spawn_delay", "3")
    cvar_spawnprotection = register_cvar("bh_spawn_protection", "2")
    cvar_respawnafterlast = register_cvar("bh_respawn_after_last_human", "1")
    cvar_frostgrenades = register_cvar("bh_frost_grenades", "1")
    cvar_freezeduration = register_cvar("bh_frost_duration", "3")
    
    set_pcvar_num(get_cvar_pointer("sv_airaccelerate"), 100)

    new file[64]
    get_configsdir(file, 63)
    format(file, 63, "%s/bh_cvars.cfg", file)
    
    if(file_exists(file)) 
        server_cmd("exec %s", file)
    
    new mapname[32]
    get_mapname(mapname, 31)
    register_spawnpoints(mapname)
        
    register_zombieclasses("bh_zombieclass.ini")
    register_dictionary("biohazard.txt")
    
    new model[128]
    formatex(model, charsmax(model), "models/player/%s/%s.mdl", DEFAULT_PMODEL, DEFAULT_PMODEL)
    precache_model(model)
    precache_model(DEFAULT_WMODEL)

    new model1[128];
    formatex(model1, charsmax(model1), "models/player/%s/%s.mdl", DEFAULT_HUMAN_MDL, DEFAULT_HUMAN_MDL)
    precache_model(model1)
    
    new i, model2[128]
    for(i = 0; i < g_classcount; i++)
    {
        formatex(model2, charsmax(model2), "models/player/%s/%s.mdl", g_class_pmodel, g_class_pmodel)
        precache_model(model2)
        precache_model(g_class_wmodel)
    }
    
    #if defined EFFECT_SPAWN
    sprite_spawn_effect = precache_model("sprites/smoke.spr")
    #endif
    
    g_exploSpr = precache_model(sprite_grenade_ring)
    g_glassSpr = precache_model(sprite_grenade_glass)
    trailSpr = precache_model(sprite_grenade_trail)
    g_explosfr = precache_model("sprites/biohazard/frost_exp.spr")
    frostgib = precache_model("sprites/biohazard/frostgib.spr")


    for(i = 0; i < sizeof g_zombie_miss_sounds; i++)
        precache_sound(g_zombie_miss_sounds)
    
    for(i = 0; i < sizeof g_zombie_hit_sounds; i++) 
        precache_sound(g_zombie_hit_sounds)
    
    for(i = 0; i < sizeof g_scream_sounds; i++) 
        precache_sound(g_scream_sounds)
    
    for(i = 0; i < sizeof g_zombie_die_sounds; i++)
        precache_sound(g_zombie_die_sounds)
    
    for(i = 0; i < sizeof g_zombie_win_sounds; i++) 
        precache_sound(g_zombie_win_sounds)
    
    for(i = 0; i < sizeof g_survivor_win_sounds; i++) 
        precache_sound(g_survivor_win_sounds)

    precache_sound(grenade_frost)
    precache_sound(grenade_frost_player)
    precache_sound(grenade_frost_break)

    new skyname[32], sky_name[64]
    get_pcvar_string(cvar_skyname, skyname, 31)

    for(i = 0; i < sizeof sky_terminations; i++)
    {
        formatex(sky_name, charsmax(sky_name), "gfx/env/%s%s.tga", skyname, sky_terminations)
        precache_generic(sky_name)
    }
        
    if(strlen(skyname) > 0)
        set_cvar_string("sv_skyname", skyname)

    g_fwd_spawn = register_forward(FM_Spawn, "fwd_spawn")
    
    g_buyzone = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "func_buyzone"))
    if(g_buyzone) 
    {
        dllfunc(DLLFunc_Spawn, g_buyzone)
        set_pev(g_buyzone, pev_solid, SOLID_NOT)
    }
    
    new ent
    ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_bomb_target"))
    if(ent) 
    {
        dllfunc(DLLFunc_Spawn, ent)
        set_pev(ent, pev_solid, SOLID_NOT)
    }

    #if defined FOG_ENABLE
    ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "env_fog"))
    if(ent)
    {
        fm_set_kvd(ent, "density", FOG_DENSITY, "env_fog")
        fm_set_kvd(ent, "rendercolor", FOG_COLOR, "env_fog")
    }
    #endif
}

public plugin_init()
{
    if(!get_pcvar_num(cvar_enabled)) 
        return
    
    cvar_botquota = get_cvar_pointer("bot_quota")
    cvar_autoteambalance[0] = get_cvar_pointer("mp_autoteambalance")
    cvar_autoteambalance[1] = get_pcvar_num(cvar_autoteambalance[0])
    set_pcvar_num(cvar_autoteambalance[0], 0)

    register_clcmd("jointeam", "cmd_jointeam")
    register_clcmd("say /class", "cmd_classmenu")
    register_clcmd("say /guns", "cmd_enablemenu")
    register_clcmd("say /help", "cmd_helpmotd")
    register_clcmd("say /respawn", "cmd_respawnzm");
    register_clcmd("amx_infect", "cmd_infectuser", ADMIN_BAN, "<name or #userid>")
    
    register_menu("Equipment", 1023, "action_equip")
    register_menu("Primary", 1023, "action_prim")
    register_menu("Secondary", 1023, "action_sec")
    register_menu("Class", 1023, "action_class")
    
    unregister_forward(FM_Spawn, g_fwd_spawn)
    register_forward(FM_CmdStart, "fwd_cmdstart")
    register_forward(FM_EmitSound, "fwd_emitsound")
    register_forward(FM_GetGameDescription, "fwd_gamedescription")
    register_forward(FM_CreateNamedEntity, "fwd_createnamedentity")
    register_forward(FM_PlayerPreThink, "fwd_player_prethink")
    register_forward(FM_PlayerPreThink, "fwd_player_prethink_post", 1)
    register_forward(FM_PlayerPostThink, "fwd_player_postthink")
    register_forward(FM_SetClientKeyValue, "fwd_set_client_key_value")
    register_forward(FM_ClientUserInfoChanged, "fwd_client_user_info_changed")
    register_forward(FM_SetModel, "fwd_set_model")

    RegisterHam(Ham_TakeDamage, "player", "bacon_takedamage_player")
    RegisterHam(Ham_Killed, "player", "bacon_killed_player")
    RegisterHam(Ham_Spawn, "player", "bacon_spawn_player_post", 1)
    RegisterHam(Ham_TraceAttack, "player", "bacon_traceattack_player")
    RegisterHam(Ham_TraceAttack, "func_pushable", "bacon_traceattack_pushable")
    RegisterHam(Ham_Use, "func_tank", "bacon_use_tank")
    RegisterHam(Ham_Use, "func_tankmortar", "bacon_use_tank")
    RegisterHam(Ham_Use, "func_tankrocket", "bacon_use_tank")
    RegisterHam(Ham_Use, "func_tanklaser", "bacon_use_tank")
    RegisterHam(Ham_Use, "func_pushable", "bacon_use_pushable")
    RegisterHam(Ham_Touch, "func_pushable", "bacon_touch_pushable")
    RegisterHam(Ham_Touch, "weaponbox", "bacon_touch_weapon")
    RegisterHam(Ham_Touch, "armoury_entity", "bacon_touch_weapon")
    RegisterHam(Ham_Touch, "weapon_shield", "bacon_touch_weapon")
    RegisterHam(Ham_Touch, "grenade", "bacon_touch_grenade")

    #if defined HUMAN_KNIFE_SPEED
    RegisterHam(Ham_CS_Item_GetMaxSpeed, "weapon_knife", "bacon_change_knife_speed")
    #endif

    RegisterHam(Ham_Player_ResetMaxSpeed, "player", "bacon_reset_maxspeed_post", 1)
    RegisterHam(Ham_Think, "grenade", "bacon_think_grenade")
    
    register_message(get_user_msgid("Health"), "msg_health")
    register_message(get_user_msgid("TextMsg"), "msg_textmsg")
    register_message(get_user_msgid("SendAudio"), "msg_sendaudio")
    register_message(get_user_msgid("StatusIcon"), "msg_statusicon")
    register_message(get_user_msgid("ScoreAttrib"), "msg_scoreattrib")
    register_message(get_user_msgid("DeathMsg"), "msg_deathmsg")
    register_message(get_user_msgid("ScreenFade"), "msg_screenfade")
    register_message(get_user_msgid("TeamInfo"), "msg_teaminfo")
    register_message(get_user_msgid("WeapPickup"), "msg_weaponpickup")
    register_message(get_user_msgid("AmmoPickup"), "msg_ammopickup")

    // from ConnorMc
    set_msg_block(get_user_msgid("HudTextArgs"), BLOCK_SET)
    
    register_event("TextMsg", "event_textmsg", "a", "2=#Game_will_restart_in")
    register_event("HLTV", "event_newround", "a", "1=0", "2=0")
    register_event("CurWeapon", "event_curweapon", "be", "1=1")
    register_event("ArmorType", "event_armortype", "be")
    register_event("Damage", "event_damage", "be")
    
    register_logevent("logevent_round_start", 2, "1=Round_Start")
    register_logevent("logevent_round_end", 2, "1=Round_End")
    
    g_msg_flashlight = get_user_msgid("Flashlight")
    g_msg_teaminfo = get_user_msgid("TeamInfo")
    g_msg_scoreattrib = get_user_msgid("ScoreAttrib")
    g_msg_scoreinfo = get_user_msgid("ScoreInfo")
    g_msg_deathmsg = get_user_msgid("DeathMsg")
    g_msg_money = get_user_msgid("Money")
    g_msg_screenfade = get_user_msgid("ScreenFade")
    g_msg_statusicon = get_user_msgid("StatusIcon")
    
    g_fwd_infect = CreateMultiForward("event_infect", ET_IGNORE, FP_CELL, FP_CELL)
    g_fwd_gamestart = CreateMultiForward("event_gamestart", ET_IGNORE)

    g_sync_hpdisplay = CreateHudSyncObj()
    g_sync_msgdisplay = CreateHudSyncObj()
    
    g_maxplayers = get_maxplayers()
    
    new mod[3]
    get_modname(mod, 2)
    
    g_czero = (mod[0] == 'c' && mod[1] == 'z') ? true : false
    
    new lights[2]
    get_pcvar_string(cvar_lights, lights, 1)
    
    if(strlen(lights) > 0)
    {
        set_task(3.0, "task_lights", _, _, _, "b")
        
        set_cvar_num("sv_skycolor_r", 0)
        set_cvar_num("sv_skycolor_g", 0)
        set_cvar_num("sv_skycolor_b", 0)
    }
    
    if(get_pcvar_num(cvar_showtruehealth))
        set_task(0.1, "task_showtruehealth", _, _, _, "b")
}

public plugin_end()
{
    if(get_pcvar_num(cvar_enabled))
        set_pcvar_num(cvar_autoteambalance[0], cvar_autoteambalance[1])
}

public plugin_natives()
{
    register_library("biohazardf")
    register_native("preinfect_user", "native_preinfect_user", 1)
    register_native("infect_user", "native_infect_user", 1)
    register_native("cure_user", "native_cure_user", 1)
    register_native("register_class", "native_register_class", 1)
    register_native("get_class_id", "native_get_class_id", 1)
    register_native("set_class_pmodel", "native_set_class_pmodel", 1)
    register_native("set_class_wmodel", "native_set_class_wmodel", 1)
    register_native("set_class_data", "native_set_class_data", 1)
    register_native("get_class_data", "native_get_class_data", 1)
    register_native("game_started", "native_game_started", 1)
    register_native("is_user_zombie", "native_is_user_zombie", 1)
    register_native("is_user_infected", "native_is_user_infected", 1)
    register_native("get_user_class", "native_get_user_class",  1)
}

public client_connect(id)
{
    g_showmenu[id] = true
    g_welcomemsg[id] = true
    g_zombie[id] = false
    g_preinfect[id] = false
    g_disconnected[id] = false
    g_falling[id] = false
    g_menufailsafe[id] = false
    g_victim[id] = 0
    g_mutate[id] = -1
    g_player_class[id] = 0
    g_player_weapons[id][0] = -1
    g_player_weapons[id][1] = -1
    g_regendelay[id] = 0.0
    g_hitdelay[id] = 0.0
    g_respawn[id] = false
    g_frozen[id] = false
}

public client_putinserver(id)
{
    if(!g_botclient_pdata && g_czero) 
    {
        static param[1]
        param[0] = id
        
        if(!task_exists(TASKID_CZBOTPDATA))
            set_task(1.0, "task_botclient_pdata", TASKID_CZBOTPDATA, param, 1)
    }
    
    if(get_pcvar_num(cvar_randomclass) && g_classcount > 1)
        g_player_class[id] = _random(g_classcount)
}

public client_disconnect(id)
{
    remove_task(TASKID_STRIPNGIVE + id)
    remove_task(TASKID_UPDATESCR + id)
    remove_task(TASKID_SPAWNDELAY + id)
    remove_task(TASKID_WEAPONSMENU + id)
    remove_task(TASKID_CHECKSPAWN + id)
    remove_task(TASKID_RESPAWN + id)
    remove_task(TASKID_MODEL + id)

    g_disconnected[id] = true
}

public cmd_jointeam(id)
{
    if(is_user_alive(id) && g_zombie[id])
    {
        ColorChat(id, "%L", id, "CMD_TEAMCHANGE")
        return PLUGIN_HANDLED
    }
    return PLUGIN_CONTINUE
}

public cmd_classmenu(id)
    if(g_classcount > 1) display_classmenu(id, g_menuposition[id] = 0)
    
public cmd_enablemenu(id)
{    
    if(get_pcvar_num(cvar_weaponsmenu))
    {
        ColorChat(id, "%L", id, g_showmenu[id] == false ? "MENU_REENABLED" : "MENU_ALENABLED")
        g_showmenu[id] = true
    }
}

public cmd_helpmotd(id)
{
    static motd[2048]
    formatex(motd, 2047, "%L", id, "HELP_MOTD")
    replace(motd, 2047, "#Version#", VERSION)
    
    show_motd(id, motd, "Biohazard Help")
}

public cmd_respawnzm(id)
{
    if(!is_user_connected(id))
        return PLUGIN_HANDLED

    if(is_user_alive(id))
    {
        ColorChat(id, "!4[Biohazard]!1 You must be dead to use this command.")
        return PLUGIN_HANDLED
    }

    if(!g_zombie[id])
    {
        ColorChat(id, "!4[Biohazard]!1 Only zombies can use this command.")
        return PLUGIN_HANDLED
    }

    g_respawn[id] = true
    set_task(get_pcvar_float(cvar_spawndelay), "task_respawnplayer", id + TASKID_RESPAWN)
    
    return PLUGIN_CONTINUE
}

public cmd_infectuser(id, level, cid)
{
    if(!cmd_access(id, level, cid, 2))
        return PLUGIN_HANDLED_MAIN
    
    static arg1[32]
    read_argv(1, arg1, 31)
    
    static target
    target = cmd_target(id, arg1, (CMDTARGET_OBEY_IMMUNITY|CMDTARGET_ALLOW_SELF|CMDTARGET_ONLY_ALIVE))
    
    if(!is_user_connected(target) || g_zombie[target])
        return PLUGIN_HANDLED_MAIN
    
    if(!allow_infection())
    {
        console_print(id, "%L", id, "CMD_MAXZOMBIES")
        return PLUGIN_HANDLED_MAIN
    }
    
    if(!g_gamestarted)
    {
        console_print(id, "%L", id, "CMD_GAMENOTSTARTED")
        return PLUGIN_HANDLED_MAIN
    }
            
    static name[32] 
    get_user_name(target, name, 31)
    
    console_print(id, "%L", id, "CMD_INFECTED", name)
    infect_user(target, 0)
    
    return PLUGIN_HANDLED_MAIN
}

public msg_teaminfo(msgid, dest, id)
{
    if(!g_gamestarted)
        return PLUGIN_CONTINUE

    static team[2]
    get_msg_arg_string(2, team, 1)
    
    if(team[0] != 'U')
        return PLUGIN_CONTINUE

    id = get_msg_arg_int(1)
    if(is_user_alive(id) || !g_disconnected[id])
        return PLUGIN_CONTINUE

    g_disconnected[id] = false
    id = randomly_pick_zombie()
    if(id)
    {
        fm_set_user_team(id, g_zombie[id] ? CS_TEAM_CT : CS_TEAM_T, 0)
        set_pev(id, pev_deadflag, DEAD_RESPAWNABLE)
    }
    return PLUGIN_CONTINUE
}

public msg_screenfade(msgid, dest, id)
{
    if(!get_pcvar_num(cvar_flashbang))
        return PLUGIN_CONTINUE
    
    if(!g_zombie[id] || !is_user_alive(id))
    {
        static data[4]
        data[0] = get_msg_arg_int(4)
        data[1] = get_msg_arg_int(5)
        data[2] = get_msg_arg_int(6)
        data[3] = get_msg_arg_int(7)
        
        if(data[0] == 255 && data[1] == 255 && data[2] == 255 && data[3] > 199)
            return PLUGIN_HANDLED
    }
    #if defined COLORED_FLASHBANGS
    else
    {
        set_msg_arg_int(4, get_msg_argtype(4), random_num(0, 255))
        set_msg_arg_int(5, get_msg_argtype(5), random_num(0, 255))
        set_msg_arg_int(6, get_msg_argtype(6), random_num(0, 255))
    }
    #endif
    return PLUGIN_CONTINUE
}

public msg_scoreattrib(msgid, dest, id)
{
    static attrib 
    attrib = get_msg_arg_int(2)
    
    if(attrib == ATTRIB_BOMB)
        set_msg_arg_int(2, ARG_BYTE, 0)
}

public msg_statusicon(msgid, dest, id)
{
    static icon[3]
    get_msg_arg_string(2, icon, 2)
    
    return (icon[0] == 'c' && icon[1] == '4') ? PLUGIN_HANDLED : PLUGIN_CONTINUE
}

public msg_weaponpickup(msgid, dest, id)
    return g_zombie[id] ? PLUGIN_HANDLED : PLUGIN_CONTINUE

public msg_ammopickup(msgid, dest, id)
    return g_zombie[id] ? PLUGIN_HANDLED : PLUGIN_CONTINUE

public msg_deathmsg(msgid, dest, id) 
{
    static killer
    killer = get_msg_arg_int(1)

    if(is_user_connected(killer) && g_zombie[killer])
        set_msg_arg_string(4, g_zombie_weapname)
}

public msg_sendaudio(msgid, dest, id)
{
    if(!get_pcvar_num(cvar_winsounds))
        return PLUGIN_CONTINUE
    
    static audiocode[22]
    get_msg_arg_string(2, audiocode, 21)
    
    if(equal(audiocode[7], "terwin"))
        set_msg_arg_string(2, g_zombie_win_sounds[_random(sizeof g_zombie_win_sounds)])
    else if(equal(audiocode[7], "ctwin"))
        set_msg_arg_string(2, g_survivor_win_sounds[_random(sizeof g_survivor_win_sounds)])
    
    return PLUGIN_CONTINUE
}

public msg_health(msgid, dest, id)
{
    if(!get_pcvar_num(cvar_caphealthdisplay))
        return PLUGIN_CONTINUE
    
    static health
    health = get_msg_arg_int(1)
        
    if(health > 255) 
        set_msg_arg_int(1, ARG_BYTE, 255)
    
    return PLUGIN_CONTINUE
}

public msg_textmsg(msgid, dest, id)
{
    if(get_msg_arg_int(1) != 4)
        return PLUGIN_CONTINUE
    
    static txtmsg[25], winmsg[32]
    get_msg_arg_string(2, txtmsg, 24)
    
    if(equal(txtmsg[1], "Game_bomb_drop"))
        return PLUGIN_HANDLED

    else if(equal(txtmsg[1], "Terrorists_Win"))
    {
        formatex(winmsg, 31, "%L", LANG_SERVER, "WIN_TXT_ZOMBIES")
        set_msg_arg_string(2, winmsg)
    }
    else if(equal(txtmsg[1], "Target_Saved") || equal(txtmsg[1], "CTs_Win"))
    {
        formatex(winmsg, 31, "%L", LANG_SERVER, "WIN_TXT_SURVIVORS")
        set_msg_arg_string(2, winmsg)
    }
    return PLUGIN_CONTINUE
}

public logevent_round_start()
{
    g_roundended = false
    g_roundstarted = true
    
    if(get_pcvar_num(cvar_weaponsmenu))
    {
        static id, team
        for(id = 1; id <= g_maxplayers; id++) if(is_user_alive(id))
        {
            team = fm_get_user_team(id)
            if(team == CS_TEAM_T || team == CS_TEAM_CT)
            {
                if(is_user_bot(id)) 
                    bot_weapons(id)
                else 
                {
                    if(g_showmenu[id])
                    {
                        add_delay(id, "display_equipmenu")
                        
                        g_menufailsafe[id] = true
                        set_task(10.0, "task_weaponsmenu", TASKID_WEAPONSMENU + id)
                    }
                    else    
                        equipweapon(id, EQUIP_ALL)
                }
            }
        }
    }
}

public logevent_round_end()
{
    g_gamestarted = false 
    g_roundstarted = false 
    g_roundended = true
    
    remove_task(TASKID_BALANCETEAM) 
    remove_task(TASKID_INITROUND)
    remove_task(TASKID_STARTROUND)
    
    set_task(0.1, "task_balanceteam", TASKID_BALANCETEAM)
}

public event_textmsg()
{
    g_gamestarted = false 
    g_roundstarted = false 
    g_roundended = true
    
    static seconds[5] 
    read_data(3, seconds, 4)
    
    static Float:tasktime 
    tasktime = float(str_to_num(seconds)) - 0.5
    
    remove_task(TASKID_BALANCETEAM)
    
    set_task(tasktime, "task_balanceteam", TASKID_BALANCETEAM)
}

public event_newround()
{
    g_gamestarted = false
    
    static buytime 
    buytime = get_pcvar_num(cvar_buytime)
    
    if(buytime) 
        g_buytime = buytime + get_gametime()
    
    remove_task(TASKID_NEWROUND) 
    remove_task(TASKID_INITROUND)
    remove_task(TASKID_STARTROUND)

    set_task(0.1, "task_newround", TASKID_NEWROUND)
    set_task(get_pcvar_float(cvar_starttime), "task_initround", TASKID_INITROUND)
}

public event_curweapon(id)
{
    if(!is_user_alive(id))
        return PLUGIN_CONTINUE
    
    static weapon
    weapon = read_data(2)
    
    if(g_zombie[id])
    {
        if(weapon != CSW_KNIFE && !task_exists(TASKID_STRIPNGIVE + id))
            set_task(0.1, "task_stripngive", TASKID_STRIPNGIVE + id)
        
        return PLUGIN_CONTINUE
    }

    static ammotype
    ammotype = get_pcvar_num(cvar_ammo)
    
    if(!ammotype || (AMMOWP_NULL & (1<<weapon)))
        return PLUGIN_CONTINUE

    static maxammo
    switch(ammotype)
    {
        case 1: maxammo = g_weapon_ammo[weapon][MAX_AMMO]
        case 2: maxammo = g_weapon_ammo[weapon][MAX_CLIP]
    }

    if(!maxammo)
        return PLUGIN_CONTINUE
    
    switch(ammotype)
    {
        case 1:
        {
            static ammo
            ammo = fm_get_user_bpammo(id, weapon)
            
            if(ammo < 1) 
                fm_set_user_bpammo(id, weapon, maxammo)
        }
        case 2:
        {
            static clip; clip = read_data(3)
            if(clip < 1)
            {
                static weaponname[32]
                get_weaponname(weapon, weaponname, 31)
                
                static ent 
                ent = fm_find_ent_by_owner(-1, weaponname, id)
                
                fm_set_weapon_ammo(ent, maxammo)
            }
        }
    }    
    return PLUGIN_CONTINUE
}

public event_armortype(id)
{
    if(!is_user_alive(id) || !g_zombie[id])
        return PLUGIN_CONTINUE
    
    if(fm_get_user_armortype(id) != CS_ARMOR_NONE)
        fm_set_user_armortype(id, CS_ARMOR_NONE)
    
    return PLUGIN_CONTINUE
}

public event_damage(victim)
{
    if(!is_user_alive(victim) || !g_gamestarted)
        return PLUGIN_CONTINUE
    
    if(g_zombie[victim])
    {
        static Float:gametime
        gametime = get_gametime()
        
        g_regendelay[victim] = gametime + g_class_data[g_player_class[victim]][DATA_HITREGENDLY]
        g_hitdelay[victim] = gametime + g_class_data[g_player_class[victim]][DATA_HITDELAY]
    }
    else
    {
        static attacker
        attacker = get_user_attacker(victim)
        
        if(!is_user_alive(attacker) || !g_zombie[attacker] || g_infecting)
            return PLUGIN_CONTINUE
        
        if(g_victim[attacker] == victim)
        {
            g_infecting = true
            g_victim[attacker] = 0

            message_begin(MSG_ALL, g_msg_deathmsg)
            write_byte(attacker)
            write_byte(victim)
            write_byte(0)
            write_string(g_infection_name)
            message_end()
            
            message_begin(MSG_ALL, g_msg_scoreattrib)
            write_byte(victim)
            write_byte(0)
            message_end()
            
            infect_user(victim, attacker)
            
            static Float:frags, deaths
            pev(attacker, pev_frags, frags)
            deaths = fm_get_user_deaths(victim)
            
            set_pev(attacker, pev_frags, frags  + 1.0)
            fm_set_user_deaths(victim, deaths + 1)
            
            fm_set_user_money(attacker, get_pcvar_num(cvar_infectmoney))
        
            static params[2]
            params[0] = attacker 
            params[1] = victim
    
            set_task(0.3, "task_updatescore", TASKID_UPDATESCR, params, 2)
        }
        g_infecting = false
    }
    return PLUGIN_CONTINUE
}

public fwd_player_prethink(id)
{
    if(!is_user_alive(id) || !g_zombie[id])
        return FMRES_IGNORED
    
    if(g_frozen[id])
        set_pev(id, pev_velocity, Float:{0.0,0.0,0.0})
    
    static flags
    flags = pev(id, pev_flags)
    
    if(flags & FL_ONGROUND)
    {
        if(get_pcvar_num(cvar_painshockfree))
        {
            pev(id, pev_velocity, g_vecvel)
            g_brestorevel = true
        }
    }
    else
    {
        static Float:fallvelocity
        pev(id, pev_flFallVelocity, fallvelocity)
        
        g_falling[id] = fallvelocity >= 350.0 ? true : false
    }
        
    if(g_gamestarted)
    {    
        static Float:gametime
        gametime = get_gametime()
        
        static pclass
        pclass = g_player_class[id]

        static Float:health
        pev(id, pev_health, health)
        
        if(health < g_class_data[pclass][DATA_HEALTH] && g_regendelay[id] < gametime)
        {
            set_pev(id, pev_health, health + 1.0)
            g_regendelay[id] = gametime + g_class_data[pclass][DATA_REGENDLY]
        }
    }
    return FMRES_IGNORED
}

public fwd_player_prethink_post(id)
{
    if(!g_brestorevel)
        return FMRES_IGNORED

    g_brestorevel = false
        
    static flag
    flag = pev(id, pev_flags)
    
    if(!(flag & FL_ONTRAIN))
    {
        static ent
        ent = pev(id, pev_groundentity)
        
        if(pev_valid(ent) && (flag & FL_CONVEYOR))
        {
            static Float:vectemp[3]
            pev(id, pev_basevelocity, vectemp)
            
            xs_vec_add(g_vecvel, vectemp, g_vecvel)
        }

        if(g_hitdelay[id] > get_gametime() && (!(pev(id, pev_flags) & FL_DUCKING)))
            xs_vec_mul_scalar(g_vecvel, g_class_data[g_player_class[id]][DATA_HITSPEED], g_vecvel)
    
        set_pev(id, pev_velocity, g_vecvel)
        return FMRES_HANDLED
    }
    return FMRES_IGNORED
}

public fwd_player_postthink(id)
{ 
    if(!is_user_alive(id))
        return FMRES_IGNORED
    
    if(g_zombie[id] && g_falling[id] && (pev(id, pev_flags) & FL_ONGROUND))
    {    
        set_pev(id, pev_watertype, CONTENTS_WATER)
        g_falling[id] = false
    }
    
    if(get_pcvar_num(cvar_buytime))
    {
        if(pev_valid(g_buyzone) && g_buytime > get_gametime())
            dllfunc(DLLFunc_Touch, g_buyzone, id)
    }
    return FMRES_IGNORED
}

public fwd_emitsound(id, channel, sample[], Float:volume, Float:attn, flag, pitch)
{    
    if(channel == CHAN_ITEM && sample[6] == 'n' && sample[7] == 'v' && sample[8] == 'g')
        return FMRES_SUPERCEDE    
    
    if(!is_user_connected(id) || !g_zombie[id])
        return FMRES_IGNORED    

    if(sample[8] == 'k' && sample[9] == 'n' && sample[10] == 'i')
    {
        if(sample[14] == 's' && sample[15] == 'l' && sample[16] == 'a')
        {
            emit_sound(id, channel, g_zombie_miss_sounds[_random(sizeof g_zombie_miss_sounds)], volume, attn, flag, pitch)
            return FMRES_SUPERCEDE
        }
        else if(sample[14] == 'h' && sample[15] == 'i' && sample[16] == 't' || sample[14] == 's' && sample[15] == 't' && sample[16] == 'a')
        {
            if(sample[17] == 'w' && sample[18] == 'a' && sample[19] == 'l')
                emit_sound(id, channel, g_zombie_miss_sounds[_random(sizeof g_zombie_miss_sounds)], volume, attn, flag, pitch)
            else
                emit_sound(id, channel, g_zombie_hit_sounds[_random(sizeof g_zombie_hit_sounds)], volume, attn, flag, pitch)
            
            return FMRES_SUPERCEDE
        }
    }            
    else if(sample[7] == 'd' && (sample[8] == 'i' && sample[9] == 'e' || sample[12] == '6'))
    {
        emit_sound(id, channel, g_zombie_die_sounds[_random(sizeof g_zombie_die_sounds)], volume, attn, flag, pitch)
        return FMRES_SUPERCEDE
    }
    return FMRES_IGNORED
}

public fwd_cmdstart(id, handle, seed)
{
    if(!is_user_alive(id) || !g_zombie[id])
        return FMRES_IGNORED
    
    static impulse
    impulse = get_uc(handle, UC_Impulse)
    
    if(impulse == IMPULSE_FLASHLIGHT)
    {
        set_uc(handle, UC_Impulse, 0)
        return FMRES_SUPERCEDE
    }
    return FMRES_IGNORED
}

public fwd_spawn(ent)
{
    if(!pev_valid(ent)) 
        return FMRES_IGNORED
    
    static classname[32]
    pev(ent, pev_classname, classname, 31)

    static i
    for(i = 0; i < sizeof g_remove_entities; ++i)
    {
        if(equal(classname, g_remove_entities[i]))
        {
            engfunc(EngFunc_RemoveEntity, ent)
            return FMRES_SUPERCEDE
        }
    }
    return FMRES_IGNORED
}

public fwd_gamedescription() 
{ 
    static gamename[32]
    get_pcvar_string(cvar_gamedescription, gamename, 31)
    
    forward_return(FMV_STRING, gamename)
    
    return FMRES_SUPERCEDE
}  

public fwd_createnamedentity(entclassname)
{
    static classname[10]
    engfunc(EngFunc_SzFromIndex, entclassname, classname, 9)
    
    return (classname[7] == 'c' && classname[8] == '4') ? FMRES_SUPERCEDE : FMRES_IGNORED
}

public fwd_client_user_info_changed(id)
{
    static currentmodel[32]
    fm_cs_get_user_model(id, currentmodel, 31)
        
    if(!equal(currentmodel, g_playermodel[id]) && !task_exists(id + TASKID_MODEL))
        fm_cs_set_user_model(id + TASKID_MODEL)
}

public fwd_set_client_key_value(id, const infobuffer[], const key[])
{
    if(key[0] == 'm' && key[1] == 'o' && key[2] == 'd' && key[3] == 'e' && key[4] == 'l')
        return FMRES_SUPERCEDE
    
    return FMRES_IGNORED
}

public fwd_set_model(entity, const model[])
{
    if(strlen(model) < 8)
        return FMRES_HANDLED
    
    if(model[7] != 'w' || model[8] != '_')
        return FMRES_IGNORED
    
    static Float:dmgtime
    pev(entity, pev_dmgtime, dmgtime)
    
    if(dmgtime == 0.0)
        return FMRES_IGNORED
    
    if(model[9] == 's' && model[10] == 'm' && get_pcvar_num(cvar_frostgrenades))
    {
        fm_set_rendering(entity, kRenderFxGlowShell, 63, 148, 233, kRenderNormal, 16)
        
        message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
        write_byte(TE_BEAMFOLLOW)
        write_short(entity)
        write_short(trailSpr)
        write_byte(10)
        write_byte(10)
        write_byte(63)    // r
        write_byte(148)    // g
        write_byte(233)    // b
        write_byte(200)
        message_end()
        
        set_pev(entity, PEV_NADE_TYPE, NADE_TYPE_FROST)
    }
    
    return FMRES_IGNORED
}

public bacon_touch_weapon(ent, id)
    return (is_user_alive(id) && g_zombie[id]) ? HAM_SUPERCEDE : HAM_IGNORED

public bacon_use_tank(ent, caller, activator, use_type, Float:value)
    return (is_user_alive(caller) && g_zombie[caller]) ? HAM_SUPERCEDE : HAM_IGNORED

public bacon_use_pushable(ent, caller, activator, use_type, Float:value)
    return HAM_SUPERCEDE

public bacon_traceattack_player(victim, attacker, Float:damage, Float:direction[3], tracehandle, damagetype)
{
    if(!g_gamestarted) 
        return HAM_SUPERCEDE
    
    if(!get_pcvar_num(cvar_knockback) || !(damagetype & DMG_BULLET))
        return HAM_IGNORED
    
    if(!is_user_connected(attacker) || !g_zombie[victim])
        return HAM_IGNORED
    
    static kbpower
    kbpower = g_weapon_knockback[get_user_weapon(attacker)]
    
    if(kbpower != -1) 
    {
        static flags
        flags = pev(victim, pev_flags)
        
        if(get_pcvar_num(cvar_knockback_duck) && ((flags & FL_DUCKING) && (flags & FL_ONGROUND)))
            return HAM_IGNORED
        
        static Float:origins[2][3]
        pev(victim, pev_origin, origins[0])
        pev(attacker, pev_origin, origins[1])
        
        if(get_distance_f(origins[0], origins[1]) <= get_pcvar_float(cvar_knockback_dist))
        {
            static Float:velocity[3]
            pev(victim, pev_velocity, velocity)
            
            static Float:tempvec
            tempvec = velocity[2]    
            
            xs_vec_mul_scalar(direction, damage, direction)
            xs_vec_mul_scalar(direction, g_class_data[g_player_class[victim]][DATA_KNOCKBACK], direction)
            xs_vec_mul_scalar(direction, g_knockbackpower[kbpower], direction)
            
            xs_vec_add(direction, velocity, velocity)
            velocity[2] = tempvec
            
            set_pev(victim, pev_velocity, velocity)
            
            return HAM_HANDLED
        }
    }
    return HAM_IGNORED
}

public bacon_touch_grenade(ent, world)
{
    if(!get_pcvar_num(cvar_impactexplode))
        return HAM_IGNORED
    
    static model[12]
    pev(ent, pev_model, model, 11)
    
    if(model[9] == 'h' && model[10] == 'e')
    {
        set_pev(ent, pev_dmgtime, 0.0)
        return HAM_HANDLED
    }
    return HAM_IGNORED
}

public bacon_takedamage_player(victim, inflictor, attacker, Float:damage, damagetype)
{
    if(damagetype & DMG_GENERIC || victim == attacker || !is_user_alive(victim) || !is_user_connected(attacker))
        return HAM_IGNORED

    if(!g_gamestarted || (!g_zombie[victim] && !g_zombie[attacker]) || ((damagetype & DMG_HEGRENADE) && g_zombie[attacker]))
        return HAM_SUPERCEDE
    
    if(!g_zombie[attacker])
    {
        static pclass
        pclass = g_player_class[victim] 
        
        damage *= (damagetype & DMG_HEGRENADE) ? g_class_data[pclass][DATA_HEDEFENCE] : g_class_data[pclass][DATA_DEFENCE]
        SetHamParamFloat(4, damage)
    }
    else
    {
        if(get_user_weapon(attacker) != CSW_KNIFE)
            return HAM_SUPERCEDE

        damage *= g_class_data[g_player_class[attacker]][DATA_ATTACK]
        
        static Float:armor
        pev(victim, pev_armorvalue, armor)
        
        if(get_pcvar_num(cvar_obeyarmor) && armor > 0.0)
        {
            armor -= damage
            
            if(armor < 0.0) 
                armor = 0.0
            
            set_pev(victim, pev_armorvalue, armor)
            SetHamParamFloat(4, 0.0)
        }
        else
        {
            static bool:infect
            infect = allow_infection()
            
            g_victim[attacker] = infect ? victim : 0
                    
            if(!g_infecting)
                SetHamParamFloat(4, infect ? 0.0 : damage)
            else    
                SetHamParamFloat(4, 0.0)
        }
    }
    return HAM_HANDLED
}

public bacon_killed_player(victim, killer, shouldgib)
{
    if(get_pcvar_num(cvar_deathmatch))
    {
        if(!g_gamestarted)
            return HAM_IGNORED

        if(!g_zombie[victim])
            return HAM_IGNORED

        if(!get_pcvar_num(cvar_respawnafterlast) && !allow_infection())
            return HAM_IGNORED

        g_respawn[victim] = true
        set_task(get_pcvar_float(cvar_spawndelay), "task_respawnplayer", victim + TASKID_RESPAWN)
    }
    
    if(is_user_alive(killer))
    {
        if(g_zombie[killer])
            return HAM_IGNORED

        static killbonus
        killbonus = get_pcvar_num(cvar_killbonus)
    
        if(killbonus)
            set_pev(killer, pev_frags, pev(killer, pev_frags) + float(killbonus))
    
        static killreward
        killreward = get_pcvar_num(cvar_killreward)
    
        if(!killreward) 
            return HAM_IGNORED
    
        static weapon, maxclip, ent, weaponname[32]
        switch(killreward)
        {
            case 1: 
            {
                weapon = get_user_weapon(killer)
                maxclip = g_weapon_ammo[weapon][MAX_CLIP]
                if(maxclip)
                {
                    get_weaponname(weapon, weaponname, 31)
                    ent = fm_find_ent_by_owner(-1, weaponname, killer)
                    
                    fm_set_weapon_ammo(ent, maxclip)
                }
            }
            case 2:
            {
                if(!user_has_weapon(killer, CSW_HEGRENADE))
                    bacon_give_weapon(killer, "weapon_hegrenade")
            }
            case 3:
            {
                weapon = get_user_weapon(killer)
                maxclip = g_weapon_ammo[weapon][MAX_CLIP]
                if(maxclip)
                {
                    get_weaponname(weapon, weaponname, 31)
                    ent = fm_find_ent_by_owner(-1, weaponname, killer)
                    
                    fm_set_weapon_ammo(ent, maxclip)
                }
                
                if(!user_has_weapon(killer, CSW_HEGRENADE))
                    bacon_give_weapon(killer, "weapon_hegrenade")
            }
        }
    }

    return HAM_IGNORED
}

public bacon_spawn_player_post(id)
{    
    if(!is_user_alive(id))
        return HAM_IGNORED
    
    static team
    team = fm_get_user_team(id)
    
    if(team != CS_TEAM_T && team != CS_TEAM_CT)
        return HAM_IGNORED

    #if defined EFFECT_SPAWN
    spawn_effect(id)
    #endif
        
    if(g_respawn[id] && !g_roundended)
    {
        g_respawn[id] = false
        infect_user(id, 0)
        
        if(get_pcvar_float(cvar_spawnprotection) > 0.0)
        {
            fm_set_user_godmode(id, 1)
            set_task(get_pcvar_float(cvar_spawnprotection), "task_removeprotection", id + TASKID_RESPAWN)
        }
        return HAM_IGNORED
    }
    
    cure_user(id)
    
    set_task(0.3, "task_spawned", TASKID_SPAWNDELAY + id)
    set_task(5.0, "task_checkspawn", TASKID_CHECKSPAWN + id)
    
    return HAM_IGNORED
}

public bacon_touch_pushable(ent, id)
{
    static movetype
    pev(id, pev_movetype)
    
    if(movetype == MOVETYPE_NOCLIP || movetype == MOVETYPE_NONE)
        return HAM_IGNORED    
    
    if(is_user_alive(id))
    {
        set_pev(id, pev_movetype, MOVETYPE_WALK)
        
        if(!(pev(id, pev_flags) & FL_ONGROUND))
            return HAM_SUPERCEDE
    }
    
    if(!get_pcvar_num(cvar_shootobjects))
        return HAM_IGNORED
    
    static Float:velocity[2][3]
    pev(ent, pev_velocity, velocity[0])
    
    if(vector_length(velocity[0]) > 0.0)
    {
        pev(id, pev_velocity, velocity[1])
        velocity[1][0] += velocity[0][0]
        velocity[1][1] += velocity[0][1]
        
        set_pev(id, pev_velocity, velocity[1])
    }
    return HAM_SUPERCEDE
}

public bacon_traceattack_pushable(ent, attacker, Float:damage, Float:direction[3], tracehandle, damagetype)
{
    if(!get_pcvar_num(cvar_shootobjects) || !is_user_alive(attacker))
        return HAM_IGNORED
    
    static Float:velocity[3]
    pev(ent, pev_velocity, velocity)
            
    static Float:tempvec
    tempvec = velocity[2]
            
    xs_vec_mul_scalar(direction, damage, direction)
    xs_vec_mul_scalar(direction, g_zombie[attacker] ? get_pcvar_float(cvar_pushpwr_zombie) : get_pcvar_float(cvar_pushpwr_weapon), direction)
    xs_vec_add(direction, velocity, velocity)
    velocity[2] = tempvec
    
    set_pev(ent, pev_velocity, velocity)
    
    return HAM_HANDLED
}

#if defined HUMAN_KNIFE_SPEED
public bacon_change_knife_speed(const ent)
{
    static id
    id = get_pdata_cbase(ent, OFFSET_WEAPONOWNER, EXTRAOFFSET_WEAPONS)

    if(g_zombie[id])
        return HAM_IGNORED

    SetHamReturnFloat(KNIFE_SPEED)
    return HAM_SUPERCEDE
}
#endif

public bacon_reset_maxspeed_post(id)
{
    if(!g_zombie[id] || !is_user_alive(id))
        return HAM_HANDLED

    new Float:max_speed = g_class_data[g_player_class[id]][DATA_SPEED]
    set_pev(id, pev_maxspeed, max_speed)

    new command[128]
    formatex(command, charsmax(command), "cl_forwardspeed %.1f;cl_sidespeed %.1f;cl_backspeed %.1f", max_speed, max_speed, max_speed)
    client_cmd(id, command)

    return HAM_IGNORED
}

public bacon_think_grenade(entity)
{
    if(!pev_valid(entity))
        return HAM_IGNORED
    
    static Float:dmgtime, Float:current_time
    pev(entity, pev_dmgtime, dmgtime)
    current_time = get_gametime()
    
    if(dmgtime > current_time)
        return HAM_IGNORED
    
    if(pev(entity, PEV_NADE_TYPE) == NADE_TYPE_FROST)
    {
        frost_explode(entity)
        return HAM_SUPERCEDE
    }
    
    return HAM_IGNORED
}

public task_spawned(taskid)
{
    static id
    id = taskid - TASKID_SPAWNDELAY
    
    if(is_user_alive(id))
    {
        if(g_welcomemsg[id])
        {
            g_welcomemsg[id] = false
            
            static message[192]
            formatex(message, 191, "%L", id, "WELCOME_TXT")
            replace(message, 191, "#Version#", VERSION)
            
            ColorChat(id, message)
        }
        
        if(get_pcvar_num(cvar_weaponsmenu) && g_roundstarted && g_showmenu[id])
            is_user_bot(id) ? bot_weapons(id) : display_equipmenu(id)
        
        if(g_gamestarted)
        {
            static team
            team = fm_get_user_team(id)
            
            if(team == CS_TEAM_T)
                fm_set_user_team(id, CS_TEAM_CT)
        }
    }
}

public task_checkspawn(taskid)
{
    static id
    id = taskid - TASKID_CHECKSPAWN
    
    if(!is_user_connected(id) || is_user_alive(id) || g_roundended)
        return
    
    static team
    team = fm_get_user_team(id)
    
    if(team == CS_TEAM_T || team == CS_TEAM_CT)
        ExecuteHamB(Ham_CS_RoundRespawn, id)
}
    
public task_showtruehealth()
{
    set_hudmessage(_, _, _, 0.01, 0.93, _, 0.2, 0.2)
    
    static id, Float:health, class
    for(id = 1; id <= g_maxplayers; id++) if(is_user_alive(id) && !is_user_bot(id) && g_zombie[id])
    {
        pev(id, pev_health, health)
        class = g_player_class[id]
        
        if(g_classcount > 1)
            ShowSyncHudMsg(id, g_sync_hpdisplay, "Health: %0.f  Class: %s (%s)", health, g_class_name[class], g_class_desc[class])
        else
            ShowSyncHudMsg(id, g_sync_hpdisplay, "Health: %0.f", health)
    }
}

public task_lights()
{
    static light[2]
    get_pcvar_string(cvar_lights, light, 1)
    
    engfunc(EngFunc_LightStyle, 0, light)
}

public task_updatescore(params[])
{
    if(!g_gamestarted) 
        return
    
    static attacker
    attacker = params[0]
    
    static victim
    victim = params[1]
    
    if(!is_user_connected(attacker))
        return

    static frags, deaths, team
    frags  = get_user_frags(attacker)
    deaths = fm_get_user_deaths(attacker)
    team   = get_user_team(attacker)
    
    message_begin(MSG_BROADCAST, g_msg_scoreinfo)
    write_byte(attacker)
    write_short(frags)
    write_short(deaths)
    write_short(0)
    write_short(team)
    message_end()
    
    if(!is_user_connected(victim))
        return
    
    frags  = get_user_frags(victim)
    deaths = fm_get_user_deaths(victim)
    team   = get_user_team(victim)
    
    message_begin(MSG_BROADCAST, g_msg_scoreinfo)
    write_byte(victim)
    write_short(frags)
    write_short(deaths)
    write_short(0)
    write_short(team)
    message_end()
}

public task_weaponsmenu(taskid)
{
    static id
    id = taskid - TASKID_WEAPONSMENU
    
    if(is_user_alive(id) && !g_zombie[id] && g_menufailsafe[id])
        display_equipmenu(id)
}

public task_stripngive(taskid)
{
    static id
    id = taskid - TASKID_STRIPNGIVE
    
    if(is_user_alive(id))
    {
        fm_strip_user_weapons(id)
        fm_reset_user_primary(id)
        bacon_give_weapon(id, "weapon_knife")
        
        set_pev(id, pev_weaponmodel2, "")
        set_pev(id, pev_viewmodel2, g_class_wmodel[g_player_class[id]])
    }
}

public task_newround()
{
    static players[32], num, zombies, i, id
    get_players(players, num, "a")

    if(num > 1)
    {
        for(i = 0; i < num; i++) 
            g_preinfect[players[i]] = false
        
        zombies = clamp(floatround(num * get_pcvar_float(cvar_zombiemulti)), 1, 31)
        
        i = 0
        while(i < zombies)
        {
            id = players[_random(num)]
            if(!g_preinfect[id])
            {
                g_preinfect[id] = true
                i++
            }
        }
    }
    
    if(!get_pcvar_num(cvar_randomspawn) || g_spawncount <= 0) 
        return
    
    static team
    for(i = 0; i < num; i++)
    {
        id = players[i]
        
        team = fm_get_user_team(id)
        if(team != CS_TEAM_T && team != CS_TEAM_CT || pev(id, pev_iuser1))
            continue
        
        static spawn_index
        spawn_index = _random(g_spawncount)
    
        static Float:spawndata[3]
        spawndata[0] = g_spawns[spawn_index][0]
        spawndata[1] = g_spawns[spawn_index][1]
        spawndata[2] = g_spawns[spawn_index][2]
        
        if(!fm_is_hull_vacant(spawndata, HULL_HUMAN))
        {
            static i
            for(i = spawn_index + 1; i != spawn_index; i++)
            {
                if(i >= g_spawncount) i = 0

                spawndata[0] = g_spawns[i][0]
                spawndata[1] = g_spawns[i][1]
                spawndata[2] = g_spawns[i][2]

                if(fm_is_hull_vacant(spawndata, HULL_HUMAN))
                {
                    spawn_index = i
                    break
                }
            }
        }

        spawndata[0] = g_spawns[spawn_index][0]
        spawndata[1] = g_spawns[spawn_index][1]
        spawndata[2] = g_spawns[spawn_index][2]
        engfunc(EngFunc_SetOrigin, id, spawndata)

        spawndata[0] = g_spawns[spawn_index][3]
        spawndata[1] = g_spawns[spawn_index][4]
        spawndata[2] = g_spawns[spawn_index][5]
        set_pev(id, pev_angles, spawndata)

        spawndata[0] = g_spawns[spawn_index][6]
        spawndata[1] = g_spawns[spawn_index][7]
        spawndata[2] = g_spawns[spawn_index][8]
        set_pev(id, pev_v_angle, spawndata)

        set_pev(id, pev_fixangle, 1)
    }
}

public task_initround()
{
    static zombiecount, newzombie
    zombiecount = 0
    newzombie = 0

    static players[32], num, i, id
    get_players(players, num, "a")

    for(i = 0; i < num; i++) if(g_preinfect[players[i]])
    {
        newzombie = players[i]
        zombiecount++
    }
    
    if(zombiecount > 1) 
        newzombie = 0
    else if(zombiecount < 1) 
        newzombie = players[_random(num)]
    
    for(i = 0; i < num; i++)
    {
        id = players[i]
        if(id == newzombie || g_preinfect[id])
            infect_user(id, 0)
        else
        {
            fm_set_user_team(id, CS_TEAM_CT, 0)
            add_delay(id, "update_team")
        }
    }
    
    set_hudmessage(_, _, _, _, _, 1)
    if(newzombie)
    {
        static name[32]
        get_user_name(newzombie, name, 31)
        
        ShowSyncHudMsg(0, g_sync_msgdisplay, "%L", LANG_PLAYER, "INFECTED_HUD", name)
        ColorChat(0, "%L", LANG_PLAYER, "INFECTED_TXT", name)
    }
    else
    {
        ShowSyncHudMsg(0, g_sync_msgdisplay, "%L", LANG_PLAYER, "INFECTED_HUD2")
        ColorChat(0, "%L", LANG_PLAYER, "INFECTED_TXT2")
    }
    
    set_task(0.51, "task_startround", TASKID_STARTROUND)
}

public task_startround()
{
    g_gamestarted = true
    ExecuteForward(g_fwd_gamestart, g_fwd_result)
}

public task_balanceteam()
{
    static players[3][32], count[3]
    get_players(players[CS_TEAM_UNASSIGNED], count[CS_TEAM_UNASSIGNED])
    
    count[CS_TEAM_T] = 0
    count[CS_TEAM_CT] = 0
    
    static i, id, team
    for(i = 0; i < count[CS_TEAM_UNASSIGNED]; i++)
    {
        id = players[CS_TEAM_UNASSIGNED][i] 
        team = fm_get_user_team(id)
        
        if(team == CS_TEAM_T || team == CS_TEAM_CT)
            players[team][count[team]++] = id
    }

    if(abs(count[CS_TEAM_T] - count[CS_TEAM_CT]) <= 1) 
        return

    static maxplayers
    maxplayers = (count[CS_TEAM_T] + count[CS_TEAM_CT]) / 2
    
    if(count[CS_TEAM_T] > maxplayers)
    {
        for(i = 0; i < (count[CS_TEAM_T] - maxplayers); i++)
            fm_set_user_team(players[CS_TEAM_T][i], CS_TEAM_CT, 0)
    }
    else
    {
        for(i = 0; i < (count[CS_TEAM_CT] - maxplayers); i++)
            fm_set_user_team(players[CS_TEAM_CT][i], CS_TEAM_T, 0)
    }
}

public task_botclient_pdata(id) 
{
    if(g_botclient_pdata || !is_user_connected(id))
        return
    
    if(get_pcvar_num(cvar_botquota) && is_user_bot(id))
    {
        RegisterHamFromEntity(Ham_TakeDamage, id, "bacon_takedamage_player")
        RegisterHamFromEntity(Ham_Killed, id, "bacon_killed_player")
        RegisterHamFromEntity(Ham_TraceAttack, id, "bacon_traceattack_player")
        RegisterHamFromEntity(Ham_Spawn, id, "bacon_spawn_player_post", 1)
        RegisterHamFromEntity(Ham_Player_ResetMaxSpeed, id, "bacon_reset_maxspeed_post", 1)
        
        g_botclient_pdata = 1
    }
}

public task_respawnplayer(taskid)
{
    static id
    id = taskid - TASKID_RESPAWN
    
    static team
    team = fm_get_user_team(id)
    
    if(!g_roundended && team != CS_TEAM_SPECTATOR && team != CS_TEAM_UNASSIGNED && !is_user_alive(id))        
        respawn_player(id)
}

public task_removeprotection(taskid)
{
    static id
    id = taskid - TASKID_RESPAWN
    
    fm_set_user_godmode(id, 0)
}

#if defined FIRST_ZOMBIE_GLOW
public task_removeglowshell(taskid)
{
    new id = taskid - TASKID_GLOWSHELL
    fm_set_rendering(id)
    
    if(task_exists(taskid))
        remove_task(taskid)
}
#endif

public bot_weapons(id)
{
    g_player_weapons[id][0] = _random(sizeof g_primaryweapons)
    g_player_weapons[id][1] = _random(sizeof g_secondaryweapons)
    
    equipweapon(id, EQUIP_ALL)
}

public update_team(id)
{
    if(!is_user_connected(id))
        return
    
    static team
    team = fm_get_user_team(id)
    
    if(team == CS_TEAM_T || team == CS_TEAM_CT)
    {
        emessage_begin(MSG_ALL, g_msg_teaminfo)
        ewrite_byte(id)
        ewrite_string(g_teaminfo[team])
        emessage_end()
    }
}

public infect_user(victim, attacker)
{
    if(!is_user_alive(victim))
        return

    message_begin(MSG_ONE, g_msg_screenfade, _, victim)
    write_short(1<<10)
    write_short(1<<10)
    write_short(0)
    write_byte((g_mutate[victim] != -1) ? 255 : 100)
    write_byte(100)
    write_byte(100)
    write_byte(250)
    message_end()

    if(g_mutate[victim] != -1)
    {
        g_player_class[victim] = g_mutate[victim]
        g_mutate[victim] = -1
        
        set_hudmessage(_, _, _, _, _, 1)
        ShowSyncHudMsg(victim, g_sync_msgdisplay, "%L", victim, "MUTATION_HUD", g_class_name[g_player_class[victim]])
    }
    
    fm_set_user_team(victim, CS_TEAM_T)
    set_zombie_attibutes(victim)
    
    emit_sound(victim, CHAN_STATIC, g_scream_sounds[_random(sizeof g_scream_sounds)], VOL_NORM, ATTN_NONE, 0, PITCH_NORM)
    ExecuteForward(g_fwd_infect, g_fwd_result, victim, attacker)
}

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

    g_zombie[id] = false
    g_falling[id] = false
    g_frozen[id] = false
    
    remove_task(id + TASKID_MODEL)

    fm_set_user_nvg(id, 0)
    set_pev(id, pev_gravity, 1.0)
    
    static viewmodel[64]
    pev(id, pev_viewmodel2, viewmodel, 63)
    
    if(equal(viewmodel, g_class_wmodel[g_player_class[id]]))
    {
        static weapon
        weapon = fm_lastknife(id)

        if(pev_valid(weapon))
            ExecuteHam(Ham_Item_Deploy, weapon)
    }
    
    static currentmodel[32]
    fm_cs_get_user_model(id, currentmodel, charsmax(currentmodel))
    
    static already_has_model
    already_has_model = false
    
    if(equal(currentmodel, DEFAULT_HUMAN_MDL))
        already_has_model = true
        
    if(!already_has_model)
    {
        copy(g_playermodel[id], charsmax(g_playermodel[]), DEFAULT_HUMAN_MDL)
        
        if(g_roundstarted)
            set_task(5.0 * g_modelchange_delay, "fm_user_model_update", id + TASKID_MODEL)
        else
            fm_user_model_update(id + TASKID_MODEL)
    }
}

#if defined EFFECT_SPAWN
public spawn_effect(id)
{
    new Origin[3]
    get_user_origin(id, Origin)
    
    new Start[3], End[3], Height
    new Radius = 17, Counter = 0
    new x[2], y[2]
    
    while(Counter <= 7)
    {
        switch(Counter)
        {
            case 0, 8: x[0] = -Radius
            case 1, 7: x[0] = -Radius * 100 / 141
            case 2, 6: x[0] = 0
            case 3, 5: x[0] = Radius * 100 / 141
            case 4: x[0] = Radius
        }
        
        if(Counter <= 4)
            y[0] = sqroot(Radius * Radius -x[0] * x[0])
        else
            y[0] = -sqroot(Radius * Radius -x[0] * x[0])
        
        ++Counter
        
        switch(Counter)
        {
            case 0, 8: x[1] = -Radius
            case 1, 7: x[1] = -Radius * 100 / 141
            case 2, 6: x[1] = 0
            case 3, 5: x[1] = Radius * 100 / 141
            case 4: x[1] = Radius
        }
        
        if(Counter <= 4)
            y[1] = sqroot(Radius * Radius -x[1] * x[1])
        else
            y[1] = -sqroot(Radius * Radius -x[1] * x[1])
        
        Height = 16 + 2 * Counter
        
        while(Height > -40)
        {
            Start[0] = Origin[0] + (x[0] * 2)
            Start[1] = Origin[1] + (y[0] * 2)
            Start[2] = Origin[2] + (Height * 2)
            End[0] = Origin[0] + (x[1] * 2)
            End[1] = Origin[1] + (y[1] * 2)
            End[2] = Origin[2] + (Height * 2)
            
            message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
            write_byte(TE_BEAMPOINTS)
            write_coord(Start[0])
            write_coord(Start[1])
            write_coord(Start[2])
            write_coord(End[0])
            write_coord(End[1])
            write_coord(End[2])
            write_short(sprite_spawn_effect)
            write_byte(0)
            write_byte(0)
            write_byte(10)
            write_byte(30)
            write_byte(15)
            write_byte(g_zombie[id] ? 255 : 87)
            write_byte(g_zombie[id] ? 0 : 127)
            write_byte(g_zombie[id] ? 0 : 255)
            write_byte(200)
            write_byte(0)
            message_end()
            
            Height -= 16
        }
    }
}
#endif

public display_equipmenu(id)
{
    static menubody[512], len
      len = formatex(menubody, 511, "\y%L^n^n", id, "MENU_TITLE1")
    
    static bool:hasweap
    hasweap = ((g_player_weapons[id][0]) != -1 && (g_player_weapons[id][1] != -1)) ? true : false
    
    len += formatex(menubody[len], 511 - len,"\r1.\w %L^n", id, "MENU_NEWWEAPONS")
    len += formatex(menubody[len], 511 - len,"%s2.\w %L^n", hasweap ? "\r" : "\d", id, "MENU_PREVSETUP")
    len += formatex(menubody[len], 511 - len,"%s3.\w %L^n^n", hasweap ? "\r" : "\d", id, "MENU_DONTSHOW")
    len += formatex(menubody[len], 511 - len,"\r5.\w %L^n", id, "MENU_EXIT")
    
    static keys
    keys = (MENU_KEY_1|MENU_KEY_5)
    
    if(hasweap) 
        keys |= (MENU_KEY_2|MENU_KEY_3)
    
    show_menu(id, keys, menubody, -1, "Equipment")
}

public action_equip(id, key)
{
    if(!is_user_alive(id) || g_zombie[id])
        return PLUGIN_HANDLED
    
    switch(key)
    {
        case 0: display_weaponmenu(id, MENU_PRIMARY, g_menuposition[id] = 0)
        case 1: equipweapon(id, EQUIP_ALL)
        case 2:
        {
            g_showmenu[id] = false
            equipweapon(id, EQUIP_ALL)
            ColorChat(id, "%L", id, "MENU_CMDENABLE")
        }
    }
    
    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 == MENU_PRIMARY ? sizeof g_primaryweapons : sizeof g_secondaryweapons

      if(start >= maxitem)
            start = pos = g_menuposition[id]
    
    static menubody[512], len
      len = formatex(menubody, 511, "\y%L\w^n^n", id, menuid == MENU_PRIMARY ? "MENU_TITLE2" : "MENU_TITLE3")

    static end
    end = start + 8
    if(end > maxitem)
            end = maxitem
    
    static keys
    keys = MENU_KEY_0
    
    static a, b
    b = 0
    
      for(a = start; a < end; ++a) 
    {
        keys |= (1<<b)
        len += formatex(menubody[len], 511 - len,"\r%d.\w %s^n", ++b, menuid == MENU_PRIMARY ? g_primaryweapons[a][0]: g_secondaryweapons[a][0])
      }

      if(end != maxitem)
    {
            formatex(menubody[len], 511 - len, "^n\r9.\w %L^n\r0.\w %L", id, "MENU_MORE", id, pos ? "MENU_BACK" : "MENU_EXIT")
            keys |= MENU_KEY_9
      }
      else    
        formatex(menubody[len], 511 - len, "^n\r0.\w %L", id, pos ? "MENU_BACK" : "MENU_EXIT")
    
      show_menu(id, keys, menubody, -1, menuid == MENU_PRIMARY ? "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, MENU_PRIMARY, ++g_menuposition[id])
        case 9: display_weaponmenu(id, MENU_PRIMARY, --g_menuposition[id])
            default:
        {
            g_player_weapons[id][0] = g_menuposition[id] * 8 + key
            equipweapon(id, EQUIP_PRI)
            
            display_weaponmenu(id, MENU_SECONDARY, 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, MENU_SECONDARY, ++g_menuposition[id])
        case 9: display_weaponmenu(id, MENU_SECONDARY, --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 display_classmenu(id, pos)
{
    if(pos < 0)
        return
    
    static start
    start = pos * 8
    
    static maxitem
    maxitem = g_classcount

      if(start >= maxitem)
            start = pos = g_menuposition[id]
    
    static menubody[512], len
      len = formatex(menubody, 511, "\y%L\w^n^n", id, "MENU_TITLE4")

    static end
    end = start + 8
    
    if(end > maxitem)
            end = maxitem
    
    static keys
    keys = MENU_KEY_0
    
    static a, b
    b = 0
    
      for(a = start; a < end; ++a) 
    {
        keys |= (1<<b)
        len += formatex(menubody[len], 511 - len,"\r%d.\w %s\r -\y %s^n", ++b, g_class_name[a], g_class_desc[a])
      }

      if(end != maxitem)
    {
            formatex(menubody[len], 511 - len, "^n\r9.\w %L^n\r0.\w %L", id, "MENU_MORE", id, pos ? "MENU_BACK" : "MENU_EXIT")
            keys |= MENU_KEY_9
      }
      else    
        formatex(menubody[len], 511 - len, "^n\r0.\w %L", id, pos ? "MENU_BACK" : "MENU_EXIT")
    
      show_menu(id, keys, menubody, -1, "Zombie Class")
}

public action_class(id, key)
{
    switch(key) 
    {
            case 8: display_classmenu(id, ++g_menuposition[id])
        case 9: display_classmenu(id, --g_menuposition[id])
            default:
        {
            g_mutate[id] = g_menuposition[id] * 8 + key
            ColorChat(id, "%L", id, "MENU_CHANGECLASS", g_class_name[g_mutate[id]])
        }
    }
    return PLUGIN_HANDLED
}

public register_spawnpoints(const mapname[])
{
    new configdir[32]
    get_configsdir(configdir, 31)
    
    new csdmfile[64], line[64], data[10][6]
    formatex(csdmfile, 63, "%s/csdm/%s.spawns.cfg", configdir, mapname)

    if(file_exists(csdmfile))
    {
        new file
        file = fopen(csdmfile, "rt")
        
        while(file && !feof(file))
        {
            fgets(file, line, 63)
            if(!line[0] || str_count(line,' ') < 2) 
                continue

            parse(line, data[0], 5, data[1], 5, data[2], 5, data[3], 5, data[4], 5, data[5], 5, data[6], 5, data[7], 5, data[8], 5, data[9], 5)

            g_spawns[g_spawncount][0] = floatstr(data[0]), g_spawns[g_spawncount][1] = floatstr(data[1])
            g_spawns[g_spawncount][2] = floatstr(data[2]), g_spawns[g_spawncount][3] = floatstr(data[3])
            g_spawns[g_spawncount][4] = floatstr(data[4]), g_spawns[g_spawncount][5] = floatstr(data[5])
            g_spawns[g_spawncount][6] = floatstr(data[7]), g_spawns[g_spawncount][7] = floatstr(data[8])
            g_spawns[g_spawncount][8] = floatstr(data[9])
            
            if(++g_spawncount >= MAX_SPAWNS) 
                break
        }
        if(file) 
            fclose(file)
    }
}

public register_zombieclasses(filename[])
{
    new configdir[32]
    get_configsdir(configdir, 31)
    
    new configfile[64]
    formatex(configfile, 63, "%s/%s", configdir, filename)

    if(get_pcvar_num(cvar_zombie_class) && file_exists(configfile))
    {            
        new line[128], leftstr[32], rightstr[64],  classname[32], data[MAX_DATA], i
        
        new file
        file = fopen(configfile, "rt")
        
        while(file && !feof(file))
        {
            fgets(file, line, 127), trim(line)
            if(!line[0] || line[0] == ';') continue
            
            if(line[0] == '[' && line[strlen(line) - 1] == ']')
            {
                copy(classname, strlen(line) - 2, line[1])

                if(register_class(classname) == -1)
                    break
                
                continue
            }
            strtok(line, leftstr, 31, rightstr, 63, '=', 1)
                
            if(equali(leftstr, "DESC"))
                copy(g_class_desc[g_classcount - 1], 31, rightstr)
            else if(equali(leftstr, "PMODEL"))
                copy(g_class_pmodel[g_classcount - 1], 63, rightstr)
            else if(equali(leftstr, "WMODEL"))
                copy(g_class_wmodel[g_classcount - 1], 63, rightstr)
                
            for(i = 0; i < MAX_DATA; i++)
                data[i] = equali(leftstr, g_dataname[i])
                
            for(i = 0; i < MAX_DATA; i++) if(data[i])
            {
                g_class_data[g_classcount - 1][i] = floatstr(rightstr)
                break
            }
        }
        if(file) fclose(file)
    } 
    else 
        register_class("Default Class")
}

public register_class(classname[])
{
    if(g_classcount >= MAX_CLASSES)
        return -1
    
    copy(g_class_name[g_classcount], 31, classname)
    copy(g_class_pmodel[g_classcount], 63, DEFAULT_PMODEL)
    copy(g_class_wmodel[g_classcount], 63, DEFAULT_WMODEL)
        
    g_class_data[g_classcount][DATA_HEALTH] = DEFAULT_HEALTH
    g_class_data[g_classcount][DATA_SPEED] = DEFAULT_SPEED    
    g_class_data[g_classcount][DATA_GRAVITY] = DEFAULT_GRAVITY
    g_class_data[g_classcount][DATA_ATTACK] = DEFAULT_ATTACK
    g_class_data[g_classcount][DATA_DEFENCE] = DEFAULT_DEFENCE
    g_class_data[g_classcount][DATA_HEDEFENCE] = DEFAULT_HEDEFENCE
    g_class_data[g_classcount][DATA_HITSPEED] = DEFAULT_HITSPEED
    g_class_data[g_classcount][DATA_HITDELAY] = DEFAULT_HITDELAY
    g_class_data[g_classcount][DATA_REGENDLY] = DEFAULT_REGENDLY
    g_class_data[g_classcount][DATA_HITREGENDLY] = DEFAULT_HITREGENDLY
    g_class_data[g_classcount][DATA_KNOCKBACK] = DEFAULT_KNOCKBACK
    g_classcount++
    
    return (g_classcount - 1)
}

public native_register_class(classname[], description[])
{
    param_convert(1)
    param_convert(2)
    
    static classid
    classid = register_class(classname)
    
    if(classid != -1)
        copy(g_class_desc[classid], 31, description)

    return classid
}

public native_set_class_pmodel(classid, player_model[])
{
    param_convert(2)
    copy(g_class_pmodel[classid], 63, player_model)
}

public native_set_class_wmodel(classid, weapon_model[])
{
    param_convert(2)
    copy(g_class_wmodel[classid], 63, weapon_model) 
}

public native_is_user_zombie(index)
    return g_zombie[index] == true ? 1 : 0

public native_get_user_class(index)
    return g_player_class[index]

public native_is_user_infected(index)
    return g_preinfect[index] == true ? 1 : 0

public native_game_started()
    return g_gamestarted

public native_preinfect_user(index, bool:yesno)
{
    if(is_user_alive(index) && !g_gamestarted)
        g_preinfect[index] = yesno
}

public native_infect_user(victim, attacker)
{
    if(allow_infection() && g_gamestarted)
        infect_user(victim, attacker)
}

public native_cure_user(index)
    cure_user(index)

public native_get_class_id(classname[])
{
    param_convert(1)
    
    static i
    for(i = 0; i < g_classcount; i++)
    {
        if(equali(classname, g_class_name[i]))
            return i
    }
    return -1
}

public Float:native_get_class_data(classid, dataid)
    return g_class_data[classid][dataid]

public native_set_class_data(classid, dataid, Float:value)
    g_class_data[classid][dataid] = value

stock bool:fm_is_hull_vacant(const Float:origin[3], hull)
{
    static tr
    tr = 0
    
    engfunc(EngFunc_TraceHull, origin, origin, 0, hull, 0, tr)
    return (!get_tr2(tr, TR_StartSolid) && !get_tr2(tr, TR_AllSolid) && get_tr2(tr, TR_InOpen)) ? true : false
}

stock fm_set_kvd(entity, const key[], const value[], const classname[] = "") 
{
    set_kvd(0, KV_ClassName, classname)
    set_kvd(0, KV_KeyName, key)
    set_kvd(0, KV_Value, value)
    set_kvd(0, KV_fHandled, 0)

    return dllfunc(DLLFunc_KeyValue, entity, 0)
}

stock fm_strip_user_weapons(index) 
{
    static stripent
    if(!pev_valid(stripent))
    {
        stripent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "player_weaponstrip"))
        dllfunc(DLLFunc_Spawn, stripent), set_pev(stripent, pev_solid, SOLID_NOT)
    }
    dllfunc(DLLFunc_Use, stripent, index)
    
    return 1
}

stock fm_set_entity_visibility(index, visible = 1)
    set_pev(index, pev_effects, visible == 1 ? pev(index, pev_effects) & ~EF_NODRAW : pev(index, pev_effects) | EF_NODRAW)

stock fm_find_ent_by_owner(index, const classname[], owner) 
{
    static ent
    ent = index
    
    while((ent = engfunc(EngFunc_FindEntityByString, ent, "classname", classname)) && pev(ent, pev_owner) != owner) {}
    
    return ent
}

stock bacon_give_weapon(index, weapon[])
{
    if(!equal(weapon,"weapon_", 7))
        return 0

    static ent
    ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, weapon))
    
    if(!pev_valid(ent)) 
        return 0
    
    set_pev(ent, pev_spawnflags, SF_NORESPAWN)
    dllfunc(DLLFunc_Spawn, ent)
   
    if(!ExecuteHamB(Ham_AddPlayerItem, index, ent))
    {
        if(pev_valid(ent)) set_pev(ent, pev_flags, pev(ent, pev_flags) | FL_KILLME)
        return 0
    }
    ExecuteHamB(Ham_Item_AttachToPlayer, ent, index)

    return 1
}

stock bacon_strip_weapon(index, weapon[])
{
    if(!equal(weapon, "weapon_", 7)) 
        return 0

    static weaponid 
    weaponid = get_weaponid(weapon)
    
    if(!weaponid) 
        return 0

    static weaponent
    weaponent = fm_find_ent_by_owner(-1, weapon, index)
    
    if(!weaponent) 
        return 0

    if(get_user_weapon(index) == weaponid) 
        ExecuteHamB(Ham_Weapon_RetireWeapon, weaponent)

    if(!ExecuteHamB(Ham_RemovePlayerItem, index, weaponent)) 
        return 0
    
    ExecuteHamB(Ham_Item_Kill, weaponent)
    set_pev(index, pev_weapons, pev(index, pev_weapons) & ~(1<<weaponid))

    return 1
}

stock fm_set_user_team(index, team, update = 1)
{
    set_pdata_int(index, OFFSET_TEAM, team)
    if(update)
    {
        emessage_begin(MSG_ALL, g_msg_teaminfo)
        ewrite_byte(index)
        ewrite_string(g_teaminfo[team])
        emessage_end()
    }
    return 1
}

stock fm_get_user_bpammo(index, weapon)
{
    static offset
    switch(weapon)
    {
        case CSW_AWP: offset = OFFSET_AMMO_338MAGNUM
        case CSW_SCOUT, CSW_AK47, CSW_G3SG1: offset = OFFSET_AMMO_762NATO
        case CSW_M249: offset = OFFSET_AMMO_556NATOBOX
        case CSW_FAMAS, CSW_M4A1, CSW_AUG, CSW_SG550, CSW_GALI, CSW_SG552: offset = OFFSET_AMMO_556NATO
        case CSW_M3, CSW_XM1014: offset = OFFSET_AMMO_BUCKSHOT
        case CSW_USP, CSW_UMP45, CSW_MAC10: offset = OFFSET_AMMO_45ACP
        case CSW_FIVESEVEN, CSW_P90: offset = OFFSET_AMMO_57MM
        case CSW_DEAGLE: offset = OFFSET_AMMO_50AE
        case CSW_P228: offset = OFFSET_AMMO_357SIG
        case CSW_GLOCK18, CSW_TMP, CSW_ELITE, CSW_MP5NAVY: offset = OFFSET_AMMO_9MM
        default: offset = 0
    }
    return offset ? get_pdata_int(index, offset) : 0
}

stock fm_set_user_bpammo(index, weapon, amount)
{
    static offset
    switch(weapon)
    {
        case CSW_AWP: offset = OFFSET_AMMO_338MAGNUM
        case CSW_SCOUT, CSW_AK47, CSW_G3SG1: offset = OFFSET_AMMO_762NATO
        case CSW_M249: offset = OFFSET_AMMO_556NATOBOX
        case CSW_FAMAS, CSW_M4A1, CSW_AUG, CSW_SG550, CSW_GALI, CSW_SG552: offset = OFFSET_AMMO_556NATO
        case CSW_M3, CSW_XM1014: offset = OFFSET_AMMO_BUCKSHOT
        case CSW_USP, CSW_UMP45, CSW_MAC10: offset = OFFSET_AMMO_45ACP
        case CSW_FIVESEVEN, CSW_P90: offset = OFFSET_AMMO_57MM
        case CSW_DEAGLE: offset = OFFSET_AMMO_50AE
        case CSW_P228: offset = OFFSET_AMMO_357SIG
        case CSW_GLOCK18, CSW_TMP, CSW_ELITE, CSW_MP5NAVY: offset = OFFSET_AMMO_9MM
        default: offset = 0
    }
    
    if(offset) 
        set_pdata_int(index, offset, amount)
    
    return 1
}

stock fm_set_user_nvg(index, onoff = 1)
{
    static nvg
    nvg = get_pdata_int(index, OFFSET_NVG)
    
    set_pdata_int(index, OFFSET_NVG, onoff == 1 ? nvg | HAS_NVG : nvg & ~HAS_NVG)
    return 1
}

stock fm_set_user_money(index, addmoney, update = 1)
{
    static money
    money = fm_get_user_money(index) + addmoney
    
    set_pdata_int(index, OFFSET_CSMONEY, money)
    
    if(update)
    {
        message_begin(MSG_ONE, g_msg_money, _, index)
        write_long(clamp(money, 0, 16000))
        write_byte(1)
        message_end()
    }
    return 1
}

public fm_cs_set_user_model(taskid)
{
    new id = taskid - TASKID_MODEL
    set_user_info(id, "model", g_playermodel[id])
}

stock fm_cs_get_user_model(player, model[], len)
{
    get_user_info(player, "model", model, len)
}

public fm_user_model_update(taskid)
{
    static Float:current_time
    current_time = get_gametime()
    
    if(current_time - g_models_targettime >= g_modelchange_delay)
    {
        fm_cs_set_user_model(taskid)
        g_models_targettime = current_time
    }
    else
    {
        set_task((g_models_targettime + g_modelchange_delay) - current_time, "fm_cs_set_user_model", taskid)
        g_models_targettime = g_models_targettime + g_modelchange_delay
    }
}

stock fm_set_rendering(entity, fx = kRenderFxNone, r = 255, g = 255, b = 255, render = kRenderNormal, amount = 16)
{
    new Float:rendercolor[3]
    rendercolor[0] = float(r)
    rendercolor[1] = float(g)
    rendercolor[2] = float(b)
    
    set_pev(entity, pev_renderfx, fx)
    set_pev(entity, pev_rendercolor, rendercolor)
    set_pev(entity, pev_rendermode, render)
    set_pev(entity, pev_renderamt, float(amount))
    
    return 1
}

stock fm_set_user_godmode(id, godmode = 0)
{
    set_pev(id, pev_takedamage, godmode == 1 ? DAMAGE_NO : DAMAGE_AIM)
    return 1
}

stock str_count(str[], searchchar)
{
    static maxlen
    maxlen = strlen(str)
    
    static i, count
    count = 0
    
    for(i = 0; i <= maxlen; i++) if(str[i] == searchchar)
        count++

    return count
}

stock set_zombie_attibutes(index)
{
    if(!is_user_alive(index)) 
        return

    g_zombie[index] = true

    if(!task_exists(TASKID_STRIPNGIVE + index))
        set_task(0.1, "task_stripngive", TASKID_STRIPNGIVE + index)

    static Float:health
    health = g_class_data[g_player_class[index]][DATA_HEALTH]
    
    if(g_preinfect[index])
    {
        health *= get_pcvar_float(cvar_zombie_hpmulti)

        #if defined FIRST_ZOMBIE_GLOW
        fm_set_rendering(index, kRenderFxGlowShell, 172, 130, 45, kRenderNormal, 0)
    
        if(task_exists(index + TASKID_GLOWSHELL))
            remove_task(index + TASKID_GLOWSHELL)
    
        set_task(5.0, "task_removeglowshell", index + TASKID_GLOWSHELL)
        #endif
    }
    
    set_pev(index, pev_health, health)
    set_pev(index, pev_gravity, g_class_data[g_player_class[index]][DATA_GRAVITY])
    set_pev(index, pev_body, 0)
    set_pev(index, pev_armorvalue, 0.0)
    
    fm_set_user_armortype(index, CS_ARMOR_NONE)
    fm_set_user_nvg(index)
    
    if(get_pcvar_num(cvar_autonvg)) 
        engclient_cmd(index, "nightvision")

    static currentmodel[32]
    fm_cs_get_user_model(index, currentmodel, charsmax(currentmodel))
    
    static already_has_model
    already_has_model = false
    
    if(equal(currentmodel, g_class_pmodel[g_player_class[index]]))
        already_has_model = true
        
    if(!already_has_model)
    {
        copy(g_playermodel[index], charsmax(g_playermodel[]), g_class_pmodel[g_player_class[index]])
        
        if(g_roundstarted)
            set_task(5.0 * g_modelchange_delay, "fm_user_model_update", index + TASKID_MODEL)
        else
            fm_user_model_update(index + TASKID_MODEL)
    }
        
    static effects
    effects = pev(index, pev_effects)
    
    if(effects & EF_DIMLIGHT)
    {
        message_begin(MSG_ONE, g_msg_flashlight, _, index)
        write_byte(0)
        write_byte(100)
        message_end()
        
        set_pev(index, pev_effects, effects & ~EF_DIMLIGHT)
    }
}

public respawn_player(id)
{
    if(g_respawn[id])
    {
        ExecuteHamB(Ham_CS_RoundRespawn, id)
    }
    return PLUGIN_CONTINUE
}

frost_explode(ent)
{
    static Float:originF[3]
    pev(ent, pev_origin, originF)
    
    create_blast3(originF)
    
    emit_sound(ent, CHAN_WEAPON, grenade_frost, 1.0, ATTN_NORM, 0, PITCH_NORM)
    
    static victim
    victim = -1
    
    while((victim = engfunc(EngFunc_FindEntityInSphere, victim, originF, 240.0)) != 0)
    {
        if(!(1 <= victim <= 32) || !g_zombie[victim] || g_frozen[victim])
            continue;
            
        message_begin(MSG_ONE, g_msg_statusicon, _, victim)
        write_byte(1) // status (0=hide, 1=show, 2=flash)
        write_string("dmg_cold")
        write_byte(63) // red
        write_byte(148) // green
        write_byte(233) // blue
        message_end()
        
        fm_set_rendering(victim, kRenderFxGlowShell, 63, 148, 233, kRenderNormal, 25)
        
        emit_sound(victim, CHAN_BODY, grenade_frost_player, 1.0, ATTN_NORM, 0, PITCH_NORM)
        
        message_begin(MSG_ONE, g_msg_screenfade, _, victim)
        write_short(0) // duration
        write_short(0) // hold time
        write_short(FFADE_STAYOUT) // fade type
        write_byte(63) // red
        write_byte(148) // green
        write_byte(233) // blue
        write_byte(100)
        message_end()
        
        if(pev(victim, pev_flags) & FL_ONGROUND)
            set_pev(victim, pev_gravity, 999999.9)
        else
            set_pev(victim, pev_gravity, 0.000001)
        
        g_frozen[victim] = true
        set_task(get_pcvar_float(cvar_freezeduration), "remove_freeze", victim)
    }
    
    engfunc(EngFunc_RemoveEntity, ent)
}

public remove_freeze(id)
{
    if(!is_user_alive(id) || !g_frozen[id])
        return;
    
    g_frozen[id] = false;
    
    set_pev(id, pev_gravity, g_class_data[g_player_class[id]][DATA_GRAVITY])
    engclient_cmd(id, "weapon_knife")
    fm_set_rendering(id)
    
    message_begin(MSG_ONE, g_msg_statusicon, _, id)
    write_byte(0) // status (0=hide, 1=show, 2=flash)
    write_string("dmg_cold")
    write_byte(63) // red
    write_byte(148) // green
    write_byte(233) // blue
    message_end()
    
    message_begin(MSG_ONE, g_msg_screenfade, _, id)
    write_short(UNIT_SECOND) // duration
    write_short(0) // hold time
    write_short(FFADE_IN) // fade type
    write_byte(63) // red
    write_byte(148) // green
    write_byte(233) // blue
    write_byte(100) // alpha
    message_end()
    
    emit_sound(id, CHAN_BODY, grenade_frost_break, 1.0, ATTN_NORM, 0, PITCH_NORM)
    
    static origin2[3]
    get_user_origin(id, origin2)
    
    message_begin(MSG_PVS, SVC_TEMPENTITY, origin2)
    write_byte(TE_BREAKMODEL)
    write_coord(origin2[0])
    write_coord(origin2[1])
    write_coord(origin2[2]+ 24)
    write_coord(16) // size x
    write_coord(16) // size y
    write_coord(16) // size z
    write_coord(random_num(-50, 50)) // velocity x
    write_coord(random_num(-50, 50)) // velocity y
    write_coord(25)    // velocity z
    write_byte(10)    // random velocity
    write_short(g_glassSpr)    // model
    write_byte(10)    // count
    write_byte(25)    // life
    write_byte(BREAK_GLASS)
    message_end()
}

create_blast3(const Float:originF[3])
{
    engfunc(EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, originF, 0)
    write_byte(TE_BEAMCYLINDER) // TE id
    engfunc(EngFunc_WriteCoord, originF[0]) // x
    engfunc(EngFunc_WriteCoord, originF[1]) // y
    engfunc(EngFunc_WriteCoord, originF[2]) // z
    engfunc(EngFunc_WriteCoord, originF[0]) // x axis
    engfunc(EngFunc_WriteCoord, originF[1]) // y axis
    engfunc(EngFunc_WriteCoord, originF[2]+470.0) // z axis
    write_short(g_exploSpr) // sprite
    write_byte(0) // startframe
    write_byte(0) // framerate
    write_byte(4) // life
    write_byte(60) // width
    write_byte(0) // noise
    write_byte(63) // red
    write_byte(148) // green
    write_byte(233) // blue
    write_byte(200) // brightness
    write_byte(0) // speed
    message_end()
    
    engfunc(EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, originF, 0)
    write_byte(TE_BEAMCYLINDER) // TE id
    engfunc(EngFunc_WriteCoord, originF[0]) // x
    engfunc(EngFunc_WriteCoord, originF[1]) // y
    engfunc(EngFunc_WriteCoord, originF[2]) // z
    engfunc(EngFunc_WriteCoord, originF[0]) // x axis
    engfunc(EngFunc_WriteCoord, originF[1]) // y axis
    engfunc(EngFunc_WriteCoord, originF[2]+555.0) // z axis
    write_short(g_exploSpr) // sprite
    write_byte(0) // startframe
    write_byte(0) // framerate
    write_byte(4) // life
    write_byte(60) // width
    write_byte(0) // noise
    write_byte(63) // red
    write_byte(148) // green
    write_byte(233) // blue
    write_byte(200) // brightness
    write_byte(0) // speed
    message_end()
    
    engfunc(EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, originF, 0)
    write_byte(TE_DLIGHT) // TE id
    engfunc(EngFunc_WriteCoord, originF[0]) // x
    engfunc(EngFunc_WriteCoord, originF[1]) // y
    engfunc(EngFunc_WriteCoord, originF[2]) // z
    write_byte(floatround(240.0/5.0))
    write_byte(63) // red
    write_byte(148) // green
    write_byte(233) // blue
    write_byte(30) // vida en 0.1, 30 = 3 segundos
    write_byte(30) // velocidad de decaimiento
    message_end()
    
    engfunc(EngFunc_MessageBegin, MSG_BROADCAST,SVC_TEMPENTITY, originF, 0)
    write_byte(TE_EXPLOSION)
    engfunc(EngFunc_WriteCoord, originF[0]) // x axis
    engfunc(EngFunc_WriteCoord, originF[1]) // y axis
    engfunc(EngFunc_WriteCoord, originF[2]+10) // z axis
    write_short(g_explosfr)
    write_byte(17)
    write_byte(15)
    write_byte(TE_EXPLFLAG_NOSOUND)
    message_end()
    
    engfunc(EngFunc_MessageBegin, MSG_BROADCAST,SVC_TEMPENTITY, originF, 0)
    write_byte(TE_SPRITETRAIL) // TE ID
    engfunc(EngFunc_WriteCoord, originF[0]) // x axis
    engfunc(EngFunc_WriteCoord, originF[1]) // y axis
    engfunc(EngFunc_WriteCoord, originF[2] + 40) // z axis
    engfunc(EngFunc_WriteCoord, originF[0]) // x axis
    engfunc(EngFunc_WriteCoord, originF[1]) // y axis
    engfunc(EngFunc_WriteCoord, originF[2]) // z axis
    write_short(frostgib) // Sprite Index
    write_byte(30) // Count
    write_byte(10) // Life
    write_byte(4) // Scale
    write_byte(50) // Velocity Along Vector
    write_byte(10) // Rendomness of Velocity
    message_end()
}

stock bool:allow_infection()
{
    static count[2]
    count[0] = 0
    count[1] = 0
    
    static index, maxzombies
    for(index = 1; index <= g_maxplayers; index++)
    {
        if(is_user_connected(index) && g_zombie[index]) 
            count[0]++
        else if(is_user_alive(index)) 
            count[1]++
    }
    
    maxzombies = clamp(get_pcvar_num(cvar_maxzombies), 1, 31)
    return (count[0] < maxzombies && count[1] > 1) ? true : false
}

stock randomly_pick_zombie()
{
    static data[4]
    data[0] = 0 
    data[1] = 0 
    data[2] = 0 
    data[3] = 0
    
    static index, players[2][32]
    for(index = 1; index <= g_maxplayers; index++)
    {
        if(!is_user_alive(index)) 
            continue
        
        if(g_zombie[index])
        {
            data[0]++
            players[0][data[2]++] = index
        }
        else 
        {
            data[1]++
            players[1][data[3]++] = index
        }
    }

    if(data[0] > 0 &&  data[1] < 1) 
        return players[0][_random(data[2])]
    
    return (data[0] < 1 && data[1] > 0) ?  players[1][_random(data[3])] : 0
}

stock equipweapon(id, weapon)
{
    if(!is_user_alive(id)) 
        return

    static weaponid[2], weaponent, weapname[32]
    
    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])
            {
                get_weaponname(weaponid[0], weapname, 31)
                bacon_strip_weapon(id, weapname)
            }
        }
        else
            weaponid[0] = -1
        
        if(weaponid[0] != weaponid[1])
            bacon_give_weapon(id, g_primaryweapons[g_player_weapons[id][0]][1])
        
        fm_set_user_bpammo(id, weaponid[1], g_weapon_ammo[weaponid[1]][MAX_AMMO])
    }

    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])
            {
                get_weaponname(weaponid[0], weapname, 31)
                bacon_strip_weapon(id, weapname)
            }
        }
        else
            weaponid[0] = -1
        
        if(weaponid[0] != weaponid[1])
            bacon_give_weapon(id, g_secondaryweapons[g_player_weapons[id][1]][1])
        
        fm_set_user_bpammo(id, weaponid[1], g_weapon_ammo[weaponid[1]][MAX_AMMO])
    }
    
    if(weapon & EQUIP_GREN)
    {
        static i
        for(i = 0; i < sizeof g_grenades; i++) if(!user_has_weapon(id, get_weaponid(g_grenades[i])))
            bacon_give_weapon(id, g_grenades[i])
    }
}

stock add_delay(index, const task[])
{
    switch(index)
    {
        case 1..8:   set_task(0.1, task, index)
        case 9..16:  set_task(0.2, task, index)
        case 17..24: set_task(0.3, task, index)
        case 25..32: set_task(0.4, task, index)
    }
}

stock ColorChat(id, String[], any:...) 
{
    static szMesage[192]
    vformat(szMesage, charsmax(szMesage), String, 3)
    
    replace_all(szMesage, charsmax(szMesage), "!1", "^1")
    replace_all(szMesage, charsmax(szMesage), "!3", "^3")
    replace_all(szMesage, charsmax(szMesage), "!4", "^4")
    
    static g_msg_SayText = 0
    if(!g_msg_SayText)
        g_msg_SayText = get_user_msgid("SayText")
    
    new Players[32], iNum = 1, i

     if(id) Players[0] = id
    else get_players(Players, iNum, "ch")
    
    for(--iNum; iNum >= 0; iNum--) 
    {
        i = Players[iNum]
        
        message_begin(MSG_ONE_UNRELIABLE, g_msg_SayText, _, i)
        write_byte(i)
        write_string(szMesage)
        message_end()
    }
}
/* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
*{\\ rtf1\\ ansi\\ deff0{\\ fonttbl{\\ f0\\ fnil Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ lang1033\\ f0\\ fs16 \n\\ par }
*/

Cfg:

| Afiseaza codul

/* Biohazard configs
*
*  by Cheap_Suit
* 
*  This file is provided as is (no warranties).
*/

#if defined _biohazardcfg_included
    #endinput
#endif
#define _biohazardcfg_included


// aici pui "//" sau stergi din fata liniilor de mai jos
#define COLORED_FLASHBANGS
#define EFFECT_SPAWN
//#define FIRST_ZOMBIE_GLOW
#define FOG_ENABLE
#define HUMAN_KNIFE_SPEED



// human setting
//#define DEFAULT_HUMAN_MDL    "gign"
KNIFE_SPEED    290.0

// fog settings
#define FOG_DENSITY        "0.0012"
#define FOG_COLOR           "128 128 128"


// default zombie setting
#define DEFAULT_PMODEL        "slum"
#define DEFAULT_WMODEL        "models/v_knife_zombie.mdl"

#define DEFAULT_HEALTH         170.0 //Health value
#define DEFAULT_SPEED        280.0 //Speed value
#define DEFAULT_GRAVITY        1.0   //Gravity multiplier
#define DEFAULT_ATTACK        2.0   //Zombie damage multiplier
#define DEFAULT_DEFENCE        0.087 //Bullet damage multiplier
#define DEFAULT_HEDEFENCE   1.0   //HE damage multiplier
#define DEFAULT_HITSPEED    0.89  //Pain speed multiplier
#define DEFAULT_HITDELAY    0.28  //Pain speed delay value
#define DEFAULT_REGENDLY    0.18  //Regeneration delay value
#define DEFAULT_HITREGENDLY 2.0   //Pain regeneration delay value
#define DEFAULT_KNOCKBACK   1.0   //Knockback multiplier

new g_zombie_weapname[] = "melee"
new g_infection_name[]  = "infection"

// frostnades
new const grenade_frost[] = "warcraft3/frostnova.wav"
new const grenade_frost_player[] = "warcraft3/impalehit.wav"
new const grenade_frost_break[] = "warcraft3/impalelaunch1.wav"
new const sprite_grenade_trail[] = "sprites/biohazard/frost_trail.spr"
new const sprite_grenade_ring[] = "sprites/biohazard/ef_shockwave.spr"
new const sprite_grenade_glass[] = "models/glassgibs.mdl"

// primary weapons (menu|game)
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[][][] = 
{ 
    { "Deagle",   "weapon_deagle"  },
    { "USP",      "weapon_usp"     },
    { "Elite",    "weapon_elite"   } 
}

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

new Float:g_knockbackpower[] =
{
    3.0,  // KBPOWER_357SIG
    4.0,  // KBPOWER_762NATO
    9.5,  // KBPOWER_BUCKSHOT
    3.0,  // KBPOWER_45ACP
    4.5,  // KBPOWER_556NATO
    3.0,  // KBPOWER_9MM
    3.5,  // KBPOWER_57MM
    12.0, // KBPOWER_338MAGNUM
    4.0,  // KBPOWER_556NATOBOX
    3.8   // KBPOWER_50AE
}

new g_survivor_win_sounds[][] =
{
    "biohazard/survivor_win1.wav",
    "biohazard/survivor_win2.wav",
    "biohazard/survivor_win3.wav"
}

new g_zombie_win_sounds[][] = 
{ 
    "biohazard/zombie_win1.wav", 
    "biohazard/zombie_win2.wav",
    "biohazard/zombie_win3.wav"     
}

new g_scream_sounds[][] = 
{ 
    "biohazard/scream1.wav", 
    "biohazard/scream2.wav", 
    "biohazard/scream3.wav"
}

new g_zombie_miss_sounds[][] = 
{ 
    "zombie/claw_miss1.wav", 
    "zombie/claw_miss2.wav"                     
}

new g_zombie_hit_sounds[][] = 
{ 
    "zombie/claw_strike1.wav",
    "zombie/claw_strike2.wav",
    "zombie/claw_strike3.wav"
}

new g_zombie_die_sounds[][] = 
{
    "biohazard/death1.wav",
    "biohazard/death2.wav",
    "biohazard/death3.wav" 
}

PS: Sursa are si o comanda pentru zombie de /respawn, as vrea daca se poate sa scoateti si aia, mersi anticipat.

[levin]

scoate fiecare plugin pe rând

[MarcoReusNr1]

Am facut asa, dar nu imi dau seama de la care ca primesc rar asa, totusi din ce am observat cred ca de la pluginul care l am postat aici e, poti verifica te rog daca asa e, si daca poti remedia, mersi anticipat

[SkillartzHD]

inlocuieste DHUDMESSAGE cu HUDMESSAGE
sau , vezi in ce plugin este folosit dhudmessage abuziv (in loop) si eliminal