Летучие мыши

Суть такова,что способность Летучих мышей ( DRAKULA_BATS_ ) применяеться не на врагу , а на себе.
Тоисть направляешь прицел на врага ,нажимаешь Е, а Летучие мыши летают вокруг тебя.
Просьба помочь

Код:

#include <amxmodx>
#include <fakemeta>
#include <engine>
#include <hamsandwich>
#include <dhudmessage>
#include <ColorChat>
#include <xs>

#define PLUGIN "Elemental Knife"
#define VERSION "1.0"
#define AUTHOR "EpisCape"

#define MAX_KNIVES 6
#define MSG_LENGTH 255
#define TIME_THINK 1.0
#define TASK_TOSSGLOWREMOVE 0x653
#define TASK_FIRE 0x379

#define CLASSNAME_DEFAULT "info_null"
#define CLASSNAME_STANBLOCK "info_stanblock"
#define CLASSNAME_STANBLOCKCRASH "info_stanblockcrash"
#define CLASSNAME_ICECUBE "info_icebuce"
#define CLASSNAME_ICECUBECRASH "info_icecubecrash"

/* ==========================================
 ---------------- Настройки ----------------
 ========================================== */
#define PREFIX_INFO "[ Нож Смерти ]" // Префикс
#define RELOAD_ABILITY 10.0 // Перезарядка способности (сек)

// 1 нож
#define RELOAD_TIME_STANBLOCK 3.0 // Длительность окаменения (сек)
#define DAMAGE_HEALTH_STANBLOCK 35.0 // Наносимый урон от окаменения

// 2 нож
#define TOSS_POWER_SHIFT 4.0 // Сила смещения подброса
#define TOSS_POWER_FLIP 400.0 // Сила подкидывания подброса
#define TOSS_ZONE_DIST 300.0 // Зона поражения для рядом стоящих игроков (в юнитах)

// 3 нож
#define FIRE_TIME 3.0 // Длительность горения (сек)
#define FIRE_DAMAGE 20.0 // Наносимый урон от горения (в секунду)

// 4 нож
#define WATER_CUBE_LIFE_TIME 4.0 // Длительность наводнения (сек)
#define WATER_CUBE_DMG_HEALTH 10.0 // Наносимый урон от наводнения

// 5 нож
#define DREIK_BOMB_VELOCITY 2500 // начальная скорость броска бомбы
#define DREIK_BOMB_RADIUS 150.0 // начальный радиус зоны действия бомбы
#define DREIK_BOMB_DAMAGE 40.0 // начальный урон при попадании бомбой
#define DREIK_BOMB_STAN_TIME 1.1 // начальный стан при попадании бомбой

// 6 нож
#define DRAKULA_BATS_LIFE 3.9 // начальное время сущестоввания летучих мышей
#define DRAKULA_BATS_RADIUS 100.0 // начальный радиус действия летучих мышей
#define DRAKULA_BATS_DAMAGE 8.3 // начальный урон от действия летучих мышей (в сек)
#define DRAKULA_BATS_VAMPIR 0.2 // начальный умножаемый коэффициент пополняемого здоровья (от урона летучих мышей)

enum (+= 100)
{
    TASK_BOT_USE_SKILL,
}

#define ID_BOT_USE_SKILL (taskid - TASK_BOT_USE_SKILL)

enum KNIVES_TYPE
{
    KNIFE_ONE = 0,
    KNIFE_TWO,
    KNIFE_THREE,
    KNIFE_FOUR,
    KNIFE_FIVE,
    KNIFE_SIX
};

new const KNIVES_LIST[MAX_KNIVES][] =
{
    "Клинки",
    "Кинджал",
    "Телекинез",
    "Смертельная Коса",
    "Длинный Тесак",
    "Биохазард"
};

new const KNIVES_INFO_ABILITY[MAX_KNIVES][] =
{
    "Окаменение",
    "Подброс",
    "Поджигание",
    "Наводнение",
    "Оглушение",
    "Летучие мыши"
};

new const ELEMS_MODELS_VIEW[MAX_KNIVES][] =
{
    "models/knife_dm/v_knife_ghost.mdl",
    "models/knife_dm/v_knife_nexon.mdl",
    "models/knife_dm/v_knife_telekinesis.mdl",
    "models/knife_dm/v_knife_thanatos.mdl",
    "models/knife_dm/v_knife_nexon.mdl",
    "models/knife_dm/v_knife_biohazard.mdl"
};

new const ELEMS_MODELS_WEAPON[MAX_KNIVES][] =
{
    "models/knife_dm/p_knife_ghost.mdl",
    "models/knife_dm/p_knife_nexon.mdl",
    "models/knife_dm/p_knife_telekinesis.mdl",
    "models/knife_dm/p_knife_thanatos.mdl",
    "models/knife_dm/p_knife_nexon.mdl",
    "models/knife_dm/p_knife_biohazard.mdl"
};

new const ELEMS_MODELS[][] =
{
    "models/knife_dm/earth_stone.mdl",
    "models/knife_dm/earth_stone_crash.mdl",
    "models/knife_dm/water_cube.mdl",
    "models/knife_dm/water_cube_crash.mdl"
};

new const ELEMS_SOUND_WORLD[][] =
{
    "knife_dm/miss"
};

new const ELEMS_SOUND_AMBIENT[][] =
{
    "knife_dm/earth_block.wav",
    "knife_dm/earth_block_crash.wav",
    "knife_dm/fire_scream.wav"
};

new const ELEMS_SPRITE[][] =
{
    "sprites/knife_dm/fire_flame.spr"
};

new const BOMB_MODEL[] = "models/knife_dm/bomb.mdl"
new const BATS_MODEL[] = "models/knife_dm/bats.mdl"
new const STAN_SOUND[] = "knife_dm/stan.wav"
new const BATS_SOUND[] = "knife_dm/bats.wav"
const TASK_STAN = 0x14101;

new g_iKnife[33], g_iButton[33], g_iCurMaxSpeed[33], g_iFireAttacker[33], g_iWaterAttacker[33], g_iSpriteFire, bool:g_bFirstTime[33];
new g_sMsgHudInfo[33][MSG_LENGTH+1], g_iEntFake, g_iSpriteEffect;
new Float: g_fTimeMsg[33], Float: g_fCurTime, Float: g_fTimeAbility[33];
new Float: g_fTimeStan[33], Float: g_fFireTime[33], Float: g_fTimeFrost[33];
new bool: g_bStan[33], bool: g_bToss[33], bool: g_bFire[33], bool: g_bFrost[33];

public plugin_precache()
{
    g_iSpriteEffect = precache_model("sprites/zbeam3.spr");
    for(new i; i < MAX_KNIVES; i++)
    {
        engfunc(EngFunc_PrecacheModel, ELEMS_MODELS_VIEW[i]);
        engfunc(EngFunc_PrecacheModel, ELEMS_MODELS_WEAPON[i]);
    }

    for(new i; i < sizeof(ELEMS_MODELS); i++)
        engfunc(EngFunc_PrecacheModel, ELEMS_MODELS[i]);

    new sBufferPath[256];

    for(new i; i < sizeof(ELEMS_SOUND_WORLD); i++)
    {
        format(sBufferPath, charsmax(sBufferPath), "%s.wav", ELEMS_SOUND_WORLD[i]);
        engfunc(EngFunc_PrecacheSound, sBufferPath);
    }

    for(new i; i < sizeof(ELEMS_SOUND_AMBIENT); i++)
        engfunc(EngFunc_PrecacheSound, ELEMS_SOUND_AMBIENT[i]);

    g_iSpriteFire = engfunc(EngFunc_PrecacheModel, ELEMS_SPRITE[0]);

    precache_model(BOMB_MODEL);
    precache_model(BATS_MODEL);
    precache_sound(STAN_SOUND);
    precache_sound(BATS_SOUND);
}

public client_connect(id)
{
    g_iKnife[id] = random_num(0, MAX_KNIVES-1);
}

public client_disconnect(id)
{
    if(task_exists(id + TASK_TOSSGLOWREMOVE))
        remove_task(id + TASK_TOSSGLOWREMOVE);

    g_iWaterAttacker[id] = -1;
    remove_task(id + TASK_STAN);
}

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

    register_logevent("logevent_round_start",2, "1=Round_Start")

    register_clcmd("say knife", "Clcmd_KnifeChoose");

    RegisterHam(Ham_Player_PreThink, "player", "fw_HamPlayerThinkPre");
    RegisterHam(Ham_Player_PostThink, "player", "fw_HamPlayerThinkPost", true);
    RegisterHam(Ham_Item_PreFrame, "player", "fwHam_PreFramePlayer_Pre")
    RegisterHam(Ham_Spawn, "player", "fw_HamPlayerSpawnPost", true);
    RegisterHam(Ham_Killed, "player", "fw_HamPlayerKlliedPost", true);
    RegisterHam(Ham_Touch, "player", "fw_HamPlayerTouchPost", true);

    RegisterHam(Ham_Item_Deploy, "weapon_knife", "fw_HamKnifePostDeploy", .Post = true);

    RegisterHam(Ham_Think, CLASSNAME_DEFAULT, "fw_HamEntThinkPost", true);

    register_touch("dreik_bomb", "*", "Touch_DreikBomb");
    register_think("dreik_bomb", "Think_DreikBomb");
    register_think("drakula_bats", "Think_DrakulaBats");
}

public plugin_cfg()
{
    g_iEntFake = create_entity("trigger_hurt");
}

public logevent_round_start()
{
    for (new id=1; id<33; id++)
    {
        if (!is_user_connected(id)) continue;
        if (is_user_bot(id))
        {
            if (task_exists(id+TASK_BOT_USE_SKILL)) remove_task(id+TASK_BOT_USE_SKILL)
            set_task(float(random_num(5,15)), "bot_use_skill", id+TASK_BOT_USE_SKILL)
        }
    }
}

// bot use skill
public bot_use_skill(taskid)
{
    new id = ID_BOT_USE_SKILL
    if (!is_user_bot(id)) return;
    Ability_Active_One(id)
    if (task_exists(taskid)) remove_task(taskid)
    set_task(float(random_num(5,15)), "bot_use_skill", id+TASK_BOT_USE_SKILL)
}

public client_putinserver(id)
{
    g_bFirstTime[id] = true
    g_bStan[id] = false;
}

public fw_HamPlayerThinkPre(id)
{
    if(!is_user_alive(id))
        return;

    g_iButton[id] = pev(id, pev_button);

    if(g_iButton[id] & IN_USE && g_fTimeAbility[id] <= 0)
        Ability_Active_One(id);

    if(g_bStan[id] || g_bFrost[id])
        set_pev(id, pev_velocity, {0.0, 0.0, -100.0});
}

public fw_HamPlayerThinkPost(id)
{
    if(!is_user_alive(id))
        return;

    g_fCurTime = get_gametime();

    if(g_fTimeMsg[id] < g_fCurTime)
    {
        if(g_fTimeAbility[id] > 0)
        {
            set_dhudmessage(255, 0, 0, 0.01, 0.92, 1, 0.1, TIME_THINK, 0.1, 0.1);

            g_fTimeAbility[id] -= TIME_THINK;

            new countSec[16]; get_ending(floatround(g_fTimeAbility[id]), "секунд", "секунда", "секунды", countSec, charsmax(countSec))

            format(g_sMsgHudInfo[id], MSG_LENGTH, "Нож • %s • Ярость • %s • %i %s", KNIVES_LIST[g_iKnife[id]], KNIVES_INFO_ABILITY[g_iKnife[id]], floatround(g_fTimeAbility[id]), countSec)
        }else{
            set_dhudmessage(0, 255, 0, 0.01, 0.92, 0, 0.1, TIME_THINK, 0.1, 0.1);

            format(g_sMsgHudInfo[id], MSG_LENGTH, "Нож • %s • Ярость • %s • [E]", KNIVES_LIST[g_iKnife[id]], KNIVES_INFO_ABILITY[g_iKnife[id]]);
        }


        show_dhudmessage(id, "%s", g_sMsgHudInfo[id]);

        g_fTimeMsg[id] = g_fCurTime + TIME_THINK;
    }
}

public Ability_Active_One(id)
{
    new iTarget, iBody;
    get_user_aiming(id, iTarget, iBody, 1000);

    if(!is_user_alive(iTarget))
    {
        client_cmd(id, "spk %s", ELEMS_SOUND_WORLD[0]);
        g_fTimeAbility[id] = RELOAD_ABILITY / 2;
        return;
    }

    if(get_user_team(id) == get_user_team(iTarget))
    {
        client_cmd(id, "spk %s", ELEMS_SOUND_WORLD[0]);
        g_fTimeAbility[id] = RELOAD_ABILITY / 2;
        return;
    }

    if(g_bStan[iTarget] || g_bToss[iTarget] || g_bFire[iTarget] || g_bFrost[iTarget])
    {
        client_cmd(id, "spk %s", ELEMS_SOUND_WORLD[0]);
        g_fTimeAbility[id] = RELOAD_ABILITY / 2;
        return;
    }

    switch(g_iKnife[id])
    {
        case KNIFE_ONE: Ability_TypeMainOne(id, iTarget);
        case KNIFE_TWO: Ability_TypeMainTwo(id, iTarget);
        case KNIFE_THREE: Ability_TypeMainThree(id, iTarget);
        case KNIFE_FOUR: Ability_TypeMainFour(id, iTarget);
        case KNIFE_FIVE: Ability_TypeMainFive(id, iTarget);
        case KNIFE_SIX: Ability_TypeMainSix(id, iTarget);
    }

    g_fTimeAbility[id] = RELOAD_ABILITY;
}

public Ability_TypeMainOne(id, iTarget)
{
    new Float: fOrigin[3];
    pev(iTarget, pev_origin, fOrigin);

    engfunc(EngFunc_DropToFloor, iTarget);
    g_iCurMaxSpeed[iTarget] = pev(iTarget, pev_maxspeed);
    set_pev(iTarget, pev_maxspeed, -1.0);

    g_fTimeStan[iTarget] = RELOAD_TIME_STANBLOCK;
    g_bStan[iTarget] = true;

    new iEnt = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, CLASSNAME_DEFAULT));

    set_pev(iEnt, pev_classname, CLASSNAME_STANBLOCK);
    set_pev(iEnt, pev_origin, fOrigin);
    set_pev(iEnt, pev_owner, iTarget);

    engfunc(EngFunc_DropToFloor, iEnt);
    engfunc(EngFunc_SetModel, iEnt, ELEMS_MODELS[0]);
    engfunc(EngFunc_EmitSound, iEnt, 0, ELEMS_SOUND_AMBIENT[0], 1.0, 1.0, 0, 100);

    set_ent_animation(iEnt, 0, 1.0, 1.0);

    ExecuteHamB(Ham_TakeDamage, iTarget, iEnt, id, DAMAGE_HEALTH_STANBLOCK, DMG_GENERIC);

    set_pev(iEnt, pev_nextthink, get_gametime() + 0.1);
}

public Ability_TypeMainTwo(id, iTarget)
{
    new iVictim = FM_NULLENT, Float: fOrigin[3], Float: fVelocity[3], Float: fData[3];
    pev(iTarget, pev_origin, fOrigin);

    while((iVictim = engfunc(EngFunc_FindEntityInSphere, iVictim, fOrigin, TOSS_ZONE_DIST)))
    {
        if(!is_user_alive(iVictim))
            continue;

        if(get_user_team(iTarget) != get_user_team(iVictim))
            continue;

        if(g_bToss[iVictim])
            continue;

        g_bToss[iVictim] = true;

        switch(random_num(0, 2))
        {
            case 0: global_get(glb_v_forward, fData)
            case 1: global_get(glb_v_up, fData);
            case 2: global_get(glb_v_right, fData);
        }

        if(vector_length(fVelocity) < 100)
        {
            fData[0] += random_float(100.0, 300.0);
            fData[1] += random_float(100.0, 300.0);
            fData[2] += random_float(100.0, 300.0);
        }

        pev(iVictim, pev_velocity, fVelocity);

        xs_vec_add(fVelocity, fData, fVelocity);
        xs_vec_mul_scalar(fVelocity, TOSS_POWER_SHIFT, fVelocity);

        fVelocity[2] += TOSS_POWER_FLIP;
        set_pev(iVictim, pev_velocity, fVelocity);

        set_task(1.0, "Toss_EffectRemove", iVictim + TASK_TOSSGLOWREMOVE);
    }
}

public Ability_TypeMainThree(id, iTarget)
{

    g_bFire[iTarget] = true;
    g_fFireTime[iTarget] = FIRE_TIME;

    g_iFireAttacker[iTarget] = id;
    set_task(0.1, "Fire_Think", iTarget + TASK_FIRE, .flags = "b");
}

public Ability_TypeMainFour(id, iTarget)
{
    new Float: fOrigin[3];
    pev(iTarget, pev_origin, fOrigin);

    engfunc(EngFunc_DropToFloor, iTarget);
    g_iCurMaxSpeed[iTarget] = pev(iTarget, pev_maxspeed);
    set_pev(iTarget, pev_maxspeed, -1.0);

    g_fTimeFrost[iTarget] = WATER_CUBE_LIFE_TIME;
    g_bFrost[iTarget] = true;

    new iEnt = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, CLASSNAME_DEFAULT));

    set_pev(iEnt, pev_classname, CLASSNAME_ICECUBE);
    set_pev(iEnt, pev_origin, fOrigin);
    set_pev(iEnt, pev_owner, iTarget);

    engfunc(EngFunc_DropToFloor, iEnt);
    engfunc(EngFunc_SetModel, iEnt, ELEMS_MODELS[2]);
    engfunc(EngFunc_EmitSound, iEnt, 0, ELEMS_SOUND_AMBIENT[0], 1.0, 1.0, 0, 100);

    set_ent_animation(iEnt, 0, 1.0, 1.0);

    g_iWaterAttacker[iTarget] = id;

    set_pev(iEnt, pev_nextthink, get_gametime() + 0.1);
}

public Ability_TypeMainFive(id, iTarget)
{
    new iEnt, Float: fOrigin[3], Float: fViewOfs[3], Float: fVelocity[3];

    pev(id, pev_origin, fOrigin);
    pev(id, pev_view_ofs, fViewOfs);

    for(new i; i < 3; i++)
        fOrigin[i] += fViewOfs[i];

    iEnt = create_entity("info_null");

    set_pev(iEnt, pev_classname, "dreik_bomb");
    set_pev(iEnt, pev_origin, fOrigin);
    set_pev(iEnt, pev_solid, SOLID_TRIGGER);
    set_pev(iEnt, pev_movetype, MOVETYPE_TOSS);
    set_pev(iEnt, pev_owner, id);
    engfunc(EngFunc_SetModel, iEnt, BOMB_MODEL);
    
    velocity_by_aim(id, DREIK_BOMB_VELOCITY, fVelocity);
    set_pev(iEnt, pev_velocity, fVelocity);
    set_pev(iEnt, pev_nextthink, get_gametime() + 5.0);
}

public Touch_DreikBomb(iBomb, iEnt)
{
    if(!is_valid_ent(iBomb))
        return;

    static iOwner;

    if((iOwner = entity_get_edict(iBomb, EV_ENT_owner)) == iEnt)
        return;

    Ability_Dreik(iOwner, iBomb);
    entity_set_int(iBomb, EV_INT_flags, entity_get_int(iBomb, EV_INT_flags) | FL_KILLME);
}

public Think_DreikBomb(iEnt)
{
    if(!is_valid_ent(iEnt))
        return;

    Ability_Dreik(entity_get_edict(iEnt, EV_ENT_owner), iEnt);
    entity_set_int(iEnt, EV_INT_flags, entity_get_int(iEnt, EV_INT_flags) | FL_KILLME);
}

public Ability_Dreik(id, iEnt)
{
    new Float: fOrigin[3];
    pev(iEnt, pev_origin, fOrigin);
    CreateBeamCylinder(fOrigin, DREIK_BOMB_RADIUS, 30, 30, 30);
    emit_sound(id, CHAN_AUTO, STAN_SOUND, VOL_NORM, ATTN_NORM, 0, PITCH_NORM);

    new iVictim = FM_NULLENT;
    while((iVictim = find_ent_in_sphere(iVictim, fOrigin, DREIK_BOMB_RADIUS)))
    {
        if(!is_user_alive(iVictim))
            continue;

        if(get_user_team(iVictim) == get_user_team(id) && id != iVictim)
            continue;
            
        if(g_bStan[iVictim])
            continue;

        set_ent_render(iVictim, 30, 30, 30);
        ExecuteHamB(Ham_TakeDamage, iVictim, g_iEntFake, id, DREIK_BOMB_DAMAGE, DMG_CRUSH);
        set_pev(iVictim, pev_maxspeed, -1.0);
        g_bStan[iVictim] = true;
        set_task(DREIK_BOMB_STAN_TIME, "Task_Stan_Off", iVictim + TASK_STAN);
    }
}

public CreateBeamCylinder(Float: fOrigin[3], Float: fDist, r, g, b)
{
    engfunc(EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, fOrigin, 0);
    write_byte(TE_BEAMCYLINDER);
    engfunc(EngFunc_WriteCoord, fOrigin[0]);
    engfunc(EngFunc_WriteCoord, fOrigin[1]);
    engfunc(EngFunc_WriteCoord, fOrigin[2]);
    engfunc(EngFunc_WriteCoord, fOrigin[0]);
    engfunc(EngFunc_WriteCoord, fOrigin[1]);
    engfunc(EngFunc_WriteCoord, fOrigin[2] + fDist);
    write_short(g_iSpriteEffect);
    write_byte(0);
    write_byte(0);
    write_byte(4);
    write_byte(120);
    write_byte(0);
    write_byte(255);
    write_byte(255);
    write_byte(0);
    write_byte(1000);
    write_byte(0);
    message_end();
}

public Task_Stan_Off(id)
{
    id -= TASK_STAN;
    
    g_bStan[id] = false;
    reset_ent_render(id);
    ExecuteHamB(Ham_Item_PreFrame, id);
}

public Ability_TypeMainSix(id, iTarget)
{
    new iEnt, Float: fOrigin[3];
    pev(id, pev_origin, fOrigin);

    iEnt = create_entity("info_null");

    set_pev(iEnt, pev_classname, "drakula_bats");
    set_pev(iEnt, pev_origin, fOrigin);
    set_pev(iEnt, pev_movetype, MOVETYPE_FOLLOW);
    set_pev(iEnt, pev_aiment, id);
    set_pev(iEnt, pev_owner, id);
    engfunc(EngFunc_SetModel, iEnt, BATS_MODEL);
    set_pev(iEnt, pev_fuser1, DRAKULA_BATS_LIFE);
    set_pev(iEnt, pev_nextthink, get_gametime() + 1.0);
    set_ent_animation(iEnt, 0, 1.0, 1.0);
}

public Think_DrakulaBats(iEnt)
{
    if(!is_valid_ent(iEnt))
        return;

    new iOwner = pev(iEnt, pev_owner);
    new Float: fDamage = DRAKULA_BATS_DAMAGE;
    new Float: fHealth = fDamage * DRAKULA_BATS_VAMPIR;
    new Float: fOrigin[3]; pev(iOwner, pev_origin, fOrigin);
    new Float: fTime, bool: bIsBats;

    if((fTime = pev(iEnt, pev_fuser1) - 1.0) > 0)
    {
        new iVictim = FM_NULLENT;
        while((iVictim = find_ent_in_sphere(iVictim, fOrigin, DRAKULA_BATS_RADIUS)))
        {
            if(!is_user_alive(iVictim))
                continue;

            if(get_user_team(iVictim) == get_user_team(iOwner))
                continue;

            if(!bIsBats)
            {
                emit_sound(iVictim, CHAN_AUTO, BATS_SOUND, VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
                bIsBats = true;
            }

            ExecuteHamB(Ham_TakeDamage, iVictim, g_iEntFake, iOwner, fDamage, DMG_PARALYZE);
            set_pev(iOwner, pev_health, pev(iOwner, pev_health) + fHealth);
        }

        set_pev(iEnt, pev_fuser1, fTime);
        set_pev(iEnt, pev_nextthink, get_gametime() + 1.0);
    }
    else
        entity_set_int(iEnt, EV_INT_flags, entity_get_int(iEnt, EV_INT_flags) | FL_KILLME);
}

public fwHam_PreFramePlayer_Pre(id)
{
    if(!is_user_alive(id))
        return HAM_IGNORED

    if(g_bStan[id])
        return HAM_SUPERCEDE

    return HAM_IGNORED
}

public fw_HamPlayerSpawnPost(id)
{
    if(!is_user_connected(id))
        return;

    if(is_user_alive(id) && g_bFirstTime[id])
    {
        g_bFirstTime[id] = false
        Clcmd_KnifeChoose(id)
    }

    g_bStan[id] = false;
    g_bToss[id] = false;
    g_bFire[id] = false;
    g_bFrost[id] = false;
}

public fw_HamPlayerKlliedPost(iVictim, iAttacker, iCorpse)
{
    if(!is_user_connected(iVictim))
        return;
    
    if(g_bStan[iVictim])
    {
        g_bStan[iVictim] = false;
        reset_ent_render(iVictim);
        remove_task(iVictim + TASK_STAN);
    }
}

public fw_HamPlayerTouchPost(id, iTarget)
{
    if(!is_user_alive(id) || !is_user_alive(iTarget))
        return;

    if(get_user_team(id) != get_user_team(iTarget))
        return;

    if(g_bStan[id] && !g_bStan[iTarget])
        Ability_TypeMainOne(id, iTarget);

    if(g_bFire[id] && !g_bFire[iTarget])
        Ability_TypeMainFour(id, iTarget);
}

public fw_HamEntThinkPost(iEnt)
{
    if(!pev_valid(iEnt))
        return;

    static sClassName[32];
    pev(iEnt, pev_classname, sClassName, charsmax(sClassName));

    if(equal(CLASSNAME_STANBLOCK, sClassName))
    {
        static iTarget; iTarget = pev(iEnt, pev_owner);

        if(!is_user_alive(iTarget) && is_user_connected(iTarget))
        {
            g_bStan[iTarget] = false;
            set_pev(iEnt, pev_flags, pev(iEnt, pev_flags) | FL_KILLME);

            engfunc(EngFunc_EmitSound, iEnt, 0, ELEMS_SOUND_AMBIENT[1], 1.0, 1.0, 0, 100);
            return;
        }

        if(g_fTimeStan[iTarget] > 0)
        {
            g_fTimeStan[iTarget] -= 0.1;

            static Float: fOrigin[3];
            pev(iTarget, pev_origin, fOrigin);
            set_pev(iEnt, pev_origin, fOrigin);

            engfunc(EngFunc_DropToFloor, iEnt);

            set_pev(iEnt, pev_nextthink, get_gametime() + 0.1);
        }else{
            g_bStan[iTarget] = false;
            set_pev(iTarget, pev_maxspeed, float(g_iCurMaxSpeed[iTarget]));

            set_ent_animation(iEnt, 0, 4.0, 1.0);

            set_pev(iEnt, pev_classname, CLASSNAME_STANBLOCKCRASH);
            engfunc(EngFunc_SetModel, iEnt, ELEMS_MODELS[1]);

            engfunc(EngFunc_EmitSound, iEnt, 0, ELEMS_SOUND_AMBIENT[1], 1.0, 1.0, 0, 100);

            set_pev(iEnt, pev_nextthink, get_gametime() + 4.0);
        }
    }

    if(equal(CLASSNAME_ICECUBE, sClassName))
    {
        static iTarget; iTarget = pev(iEnt, pev_owner);

        static Float: fOrigin[3], Float: fOrigin2[3], iVictim;
        static Float: fFrostTime[33], iAttacker;
        pev(iEnt, pev_origin, fOrigin);
        iAttacker = is_user_connected(g_iWaterAttacker[iTarget]) ? g_iWaterAttacker[iTarget] : iTarget;

        if(!is_user_alive(iTarget) && is_user_connected(iTarget))
        {
            g_bFrost[iTarget] = false;
            set_pev(iEnt, pev_flags, pev(iEnt, pev_flags) | FL_KILLME);

            engfunc(EngFunc_EmitSound, iEnt, 0, ELEMS_SOUND_AMBIENT[1], 1.0, 1.0, 0, 100);
            return;
        }

        iVictim = FM_NULLENT;
        while((iVictim = engfunc(EngFunc_FindEntityInSphere, iVictim, fOrigin, 50.0)))
        {
            if(!is_user_alive(iVictim))
                continue;

            if(get_user_team(iTarget) == get_user_team(iVictim))
            {
                if(fFrostTime[iVictim] < g_fCurTime)
                {
                    ExecuteHamB(Ham_TakeDamage, iTarget, iAttacker, iAttacker, WATER_CUBE_DMG_HEALTH, DMG_DROWN);
                    fFrostTime[iTarget] = g_fCurTime + 1.0;
                }
            }

            pev(iVictim, pev_origin, fOrigin2);

        }

        if(g_fTimeFrost[iTarget] > 0)
        {
            g_fTimeFrost[iTarget] -= 0.1;

            static Float: fOrigin[3];
            pev(iTarget, pev_origin, fOrigin);
            set_pev(iEnt, pev_origin, fOrigin);

            engfunc(EngFunc_DropToFloor, iEnt);

            set_pev(iEnt, pev_nextthink, get_gametime() + 0.1);
        }else{
            g_bFrost[iTarget] = false;
            set_pev(iTarget, pev_maxspeed, float(g_iCurMaxSpeed[iTarget]));

            set_ent_animation(iEnt, 0, 4.0, 1.0);

            set_pev(iEnt, pev_classname, CLASSNAME_STANBLOCKCRASH);
            engfunc(EngFunc_SetModel, iEnt, ELEMS_MODELS[3]);

            engfunc(EngFunc_EmitSound, iEnt, 0, ELEMS_SOUND_AMBIENT[1], 1.0, 1.0, 0, 100);

            set_pev(iEnt, pev_nextthink, get_gametime() + 4.0);
        }
    }

    if(equal(CLASSNAME_STANBLOCKCRASH, sClassName) || equal(CLASSNAME_ICECUBECRASH, sClassName))
    {
        set_pev(iEnt, pev_flags, pev(iEnt, pev_flags) | FL_KILLME);
    }
}

public Toss_EffectRemove(task_id)
{
    new iTarget = task_id - TASK_TOSSGLOWREMOVE;

    if(!is_user_alive(iTarget))
        return;

    if(g_bToss[iTarget])
    {
        g_bToss[iTarget] = false;
    }
}

public Fire_Think(task_id)
{
    new iTarget = task_id - TASK_FIRE;

    if(!is_user_alive(iTarget))
        g_bFire[iTarget] = false;

    if(g_bFire[iTarget])
    {
        if(g_fFireTime[iTarget] > 0)
        {
            if(pev(iTarget, pev_flags) & FL_INWATER)
            {
                remove_task(task_id);
                g_bFire[iTarget] = false;
                return;
            }

            static iOrigin[3];
            get_user_origin(iTarget, iOrigin);

            message_begin(MSG_ALL, SVC_TEMPENTITY, iOrigin)
            write_byte(TE_SPRITE);
            write_coord(iOrigin[0])
            write_coord(iOrigin[1])
            write_coord(iOrigin[2])
            write_short(g_iSpriteFire)
            write_byte(10);
            write_byte(1000);
            message_end();

            static Float: fFireTime[33];

            if(fFireTime[iTarget] < g_fCurTime)
            {
                new iAttacker = is_user_connected(g_iFireAttacker[iTarget]) ? g_iFireAttacker[iTarget] : iTarget;
                ExecuteHamB(Ham_TakeDamage, iTarget, iAttacker, iAttacker, FIRE_DAMAGE, DMG_BURN);

                g_fFireTime[iTarget] -= 1.0;
                fFireTime[iTarget] = g_fCurTime + 1.0;
            }
        }else{

            g_iFireAttacker[iTarget] = -1;
            g_bFire[iTarget] = false;
        }
    }
    else
        remove_task(task_id);
}

public Clcmd_KnifeChoose(id)
{
    new iMenu, sItem[64], sInfo[3];

    iMenu = menu_create("\rНож Смерти^n\yВыбор Ножа\w", "KnifeChoose_Handler");

    for(new i; i < MAX_KNIVES; i++)
    {
        format(sItem, charsmax(sItem), g_iKnife[id] == i ? "\y%s" : "\w%s", KNIVES_LIST[i], KNIVES_LIST[i]);
        num_to_str(i, sInfo, charsmax(sInfo));
        menu_additem(iMenu, sItem, sInfo);
    }
    menu_setprop(iMenu, MPROP_PERPAGE, 0);
    menu_display(id, iMenu);
}

public KnifeChoose_Handler(id, iMenu, iItem)
{
    if(iItem == MENU_EXIT)
    return;

    if(g_iKnife[id] == iItem)
    {
        ColorChat(0, RED, "^4%s ^3У Вас уже есть этот Нож", PREFIX_INFO);
        return;
    }

    g_iKnife[id] = iItem;

    if(is_user_alive(id))
    {
        ExecuteHamB(Ham_Item_Deploy, get_pdata_cbase(id, 373));

        g_fTimeAbility[id] = RELOAD_ABILITY;
    }

    ColorChat(0, RED, "^4%s ^3Нож ^4%s", PREFIX_INFO, KNIVES_LIST[g_iKnife[id]]);
    ColorChat(0, RED, "^4%s ^3Ярость ^4%s", PREFIX_INFO, KNIVES_INFO_ABILITY[g_iKnife[id]]);
}

public fw_HamKnifePostDeploy(iWeapon)
{
    new id = get_pdata_cbase(iWeapon, 41, 4);

    if(!is_user_alive(id))
        return;

    set_pev(id, pev_viewmodel2, ELEMS_MODELS_VIEW[g_iKnife[id]]);
    set_pev(id, pev_weaponmodel2, ELEMS_MODELS_WEAPON[g_iKnife[id]]);
}

public set_ent_render(id, r, g, b)
{
    new Float: fRenderColor[3];
    fRenderColor[0] = float®;
    fRenderColor[1] = float(g);
    fRenderColor[2] = float(b);
    
    set_pev(id, pev_renderfx, kRenderFxGlowShell);
    set_pev(id, pev_rendercolor, fRenderColor);
    set_pev(id, pev_rendermode, kRenderNormal);
    set_pev(id, pev_renderamt, 16.0);
}

public reset_ent_render(id)
{
    if(g_bStan[id])
        return;
    
    set_pev(id, pev_renderfx, kRenderFxNone);
    set_pev(id, pev_rendercolor, Float: {255.0, 255.0, 255.0});
    set_pev(id, pev_rendermode, kRenderNormal);
    set_pev(id, pev_renderamt, 16.0);
}

stock set_ent_animation(iEnt, iAnim, Float: fAnimTime, Float: fFrame)
{
    set_pev(iEnt, pev_sequence, iAnim);
    set_pev(iEnt, pev_animtime, fAnimTime);
    set_pev(iEnt, pev_framerate, fFrame);
    set_pev(iEnt, pev_frame, 0.0);
}

stock get_ending(num, const a[], const b[], const c[], output[], lenght)
{
    new num100 = num % 100, num10 = num % 10;
    if(num100 >=5 && num100 <= 20 || num10 == 0 || num10 >= 5 && num10 <= 9) formatex(output, lenght, "%s", a);
    else if(num10 == 1) formatex(output, lenght, "%s", b);
    else if(num10 >= 2 && num10 <= 4) formatex(output, lenght, "%s", c);
}

$@NyA, обьемные файлы сбрасываются не текстом, пролистывать код долго в браузере