Отображение ХУД

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

// Zombie Attributes
new const zclass_name[] = "Простокласс" // name
new const zclass_info[] = "Простокласс" // description
new const zclass_model[] = "venom" // model
new const zclass_clawmodel[] = "v_venom.mdl" // claw model
const zclass_health = 5000 // health
const zclass_speed = 255 // speed
const Float:zclass_gravity = 0.75 // gravity
const Float:zclass_knockback = 1.5 // knockback

// --- config ------------------------ //
#define TRAIL_LIFE        2
#define TRAIL_WIDTH       10
#define TRAIL_RED         90
#define TRAIL_GREEN       200
#define TRAIL_BLUE        90
#define TRAIL_BRIGTHNESS  220

new Float:g_fastspeed = 375.0 // sprint speed
new Float:g_normspeed = 255.0 // norm speed. must be as zclass_speed
new Float:g_abilonecooldown = 15.0 // cooldown time
new Float:g_abilonelenght = 10.0 // time of sprint
new const sound_china_sprint[] = "zombie_plague/china_spd.wav" //sprint sound
// ----------------------------------- //

new i_cooldown_time[33]
new g_speeded[33] = 0
new g_abil_one_used[33] = 0
new gTrail
new g_maxplayers

new idclass

// ==== Heal
new Float:heal_time_wait = 10.0 ,
heal_amount = 600
new const heal_sound[] = "zombie_plague/td_heal.wav"
new const heal_sprite[] = "sprites/zb_restore_health.spr"
new heal_sprite_id
new g_can_heal[33]
new const zombie_sound_heal[] = "zombie_plague/zombi_heal.wav"
new const g_vgrenade[] = "models/bomb_cso/v_venom_bomb.mdl"
new const g_pgrenade[] = "models/bomb_cso/p_venom_bomb.mdl"
#define TASK_WAIT_HEAL 53498


// ==== Harden
new Float:harden_time = 10.0
new Float:harden_time_wait = 10.0
new Float:harden_damage_def = 0.2 ,
Float:harden_painshock_def = 1.25
new const harden_sound[] = "zombie_plague/boomer_skill.wav"
new g_can_harden[33], g_hardening[33]

const m_flTimeWeaponIdle = 48
const m_flNextAttack = 83

#define TASK_H_TIME_REMOVE 8345843
#define TASK_H_TIME_WAIT 53495734

// ==== Dead Explode Effect
new const death_exp_effect_model[] = "models/zombie_plague/ef_boomer.mdl"
new const death_exp_effect_sprite[] = "sprites/zombiebomb_exp.spr"
new const death_exp_effect_sound[] = "zombie_plague/boomer_death.wav"
new Float:death_exp_radius = 350.0
new Float:death_exp_knockspeed = 250.0

#define GIB_CLASSNAME "venomguard_gib"
new g_hide_corpse[33]
new g_register, g_explode_effect_idspr

new g_current_time[33], g_hud_skill, g_hud_skill2, g_current_time2[33]

public plugin_init()
{
    register_plugin("[Zombie: Z-VIRUS] Zombie Class: Venom Guard Zombie", "1.0", "Dias")
    
    register_message(get_user_msgid("ClCorpse"), "msg_clcorpse")    
    register_think(GIB_CLASSNAME, "fw_Think_Gib")
    
    RegisterHam(Ham_Killed, "player", "fw_Killed_Post", 1)
    register_event("CurWeapon","handle_gun","be","1=1")  
    RegisterHam(Ham_Spawn, "player", "fw_Spawn_Post", 1)
    RegisterHam(Ham_TakeDamage, "player", "fw_TakeDamage")
    
    g_hud_skill = CreateHudSyncObj(11)
    g_hud_skill2 = CreateHudSyncObj(12)
    set_task(1.0, "change_time", _, _, _, "b")
    
    register_clcmd("drop", "cmd_drop")
    register_clcmd("lastinv", "cmd_lastinv")
    
    register_clcmd("ability1", "use_ability_one")
    register_concmd("ability1", "use_ability_one")
    
    register_forward( FM_PlayerPreThink, "client_prethink" )
    register_logevent("roundStart", 2, "1=Round_Start")
    register_event("CurWeapon","handle_gun","be","1=1")
    
    g_maxplayers = get_maxplayers()

    gTrail = engfunc(EngFunc_PrecacheModel,"sprites/smoke.spr")
}

public plugin_precache()
{
    engfunc(EngFunc_PrecacheModel, death_exp_effect_model)
    precache_model(g_vgrenade)
    precache_model(g_pgrenade)
    engfunc(EngFunc_PrecacheSound, death_exp_effect_sound)
    g_explode_effect_idspr = engfunc(EngFunc_PrecacheModel, death_exp_effect_sprite)
    
    heal_sprite_id = engfunc(EngFunc_PrecacheModel, heal_sprite)
    engfunc(EngFunc_PrecacheSound, heal_sound)
    engfunc(EngFunc_PrecacheSound, harden_sound)
    
    idclass = zp_register_zombie_class(zclass_name, zclass_info, zclass_model, zclass_clawmodel, zclass_health, zclass_speed, zclass_gravity, zclass_knockback)    
    
    precache_sound(sound_china_sprint)
}

public client_putinserver(id)
{
    if(is_user_bot(id) && !g_register)
    {
        g_register = 1
        set_task(0.1, "do_register_ham_now", id)
    }
    
    if(!is_user_bot(id))
        set_task(1.0, "show_skill_hud", id, _, _, "b")
}

public show_skill_hud(id)
{
    if(is_user_alive(id) && zp_get_user_zombie(id) && zp_get_user_zombie_class(id) == idclass)
    {
        show_hud_heal(id)
        show_hud_harden(id)
    }
}

public show_hud_heal(id)
{
    static Float:percent, percent2
    static Float:time_remove
    
    time_remove = heal_time_wait
    
    percent = (float(g_current_time[id]) / time_remove) * 100.0
    percent2 = clamp(floatround(percent), 1, 100)
    
    if(percent2 > 0 && percent2 < 50)
    {
        set_hudmessage(255, 0, 0, 0.02, 0.55, 0, 1.5, 1.5)
        ShowSyncHudMsg(id, g_hud_skill, "[G] - Лечение (Откат умения %i%%)", percent2)
    } else if(percent2 >= 50 && percent < 100) {
        set_hudmessage(255, 255, 0, 0.02, 0.55, 0, 1.5, 1.5)
        ShowSyncHudMsg(id, g_hud_skill, "[G] - Лечение (Откат умения %i%%)", percent2)
    } else if(percent2 >= 100) {
        set_hudmessage(255, 255, 255, 0.02, 0.55, 0, 1.5, 1.5)
        ShowSyncHudMsg(id, g_hud_skill, "[G] - Лечение (Умение готово)")
    }
}

public show_hud_harden(id)
{
    static Float:percent, percent2
    static Float:time_remove, Float:time_wait
    
    time_wait = harden_time
    time_remove = harden_time_wait
    
    percent = (float(g_current_time2[id]) / (time_remove + time_wait)) * 100.0
    percent2 = clamp(floatround(percent), 1, 100)
    
    if(percent2 > 0 && percent2 < 50)
    {
        set_hudmessage(255, 0, 0, 0.02, 0.58, 0, 1.5, 1.5)
        ShowSyncHudMsg(id, g_hud_skill2, "[Q] - Сильная Защита (Откат умения %i%%)", percent2)
    } else if(percent2 >= 50 && percent < 100) {
        set_hudmessage(255, 255, 0, 0.02, 0.58, 0, 1.5, 1.5)
        ShowSyncHudMsg(id, g_hud_skill2, "[Q] - Сильная Защита (Откат умения %i%%)", percent2)
    } else if(percent2 >= 100) {
        set_hudmessage(255, 255, 255, 0.02, 0.58, 0, 1.5, 1.5)
        ShowSyncHudMsg(id, g_hud_skill2, "[Q] - Сильная Защита (Умение готово)")
    }    
}

public change_time()
{
    for(new i = 0; i < get_maxplayers(); i++)
    {
        g_current_time[i]++
        g_current_time2[i]++
    }
}

public do_register_ham_now(id)
{
    RegisterHamFromEntity(Ham_Spawn, id, "fw_Spawn_Post", 1)
    RegisterHamFromEntity(Ham_Killed, id, "fw_Killed_Post", 1)
    RegisterHamFromEntity(Ham_TakeDamage, id, "fw_TakeDamage")
}

public zp_user_infected_post(id, infector)
{
    if ((zp_get_user_zombie_class(id) == idclass) && !zp_get_user_nemesis(id))
    {
        
        new text[100]
        new note_cooldown = floatround(g_abilonecooldown)
        format(text,99,"^x04[ZP]^x01 Ваша способность ^x04Ускорение^x01. Откат:^x04 %d ^x01секунд.",note_cooldown)
        message_begin(MSG_ONE,get_user_msgid("SayText"),{0,0,0},id)
        write_byte(id)
        write_string(text)
        message_end()
        
        i_cooldown_time[id] = floatround(g_abilonecooldown)
        remove_task(id)
        g_speeded[id] = 0
        g_abil_one_used[id] = 0
        client_cmd(id,"bind t ability1")
        
        g_current_time[id] = 100
        g_current_time2[id] = 100    
            
        g_can_heal[id] = 1
        g_can_harden[id] = 1
        g_hardening[id] = 0    
    }
}

public zp_user_humanized_post(id)
{
    fw_Spawn_Post(id)
    
    remove_task(id)
    client_cmd(id,"cl_forwardspeed 400")
    client_cmd(id,"cl_backspeed 400")
}
// ================================== Skill: Heal ===================================
public cmd_drop(id)
{
    if(is_user_alive(id) && zp_get_user_zombie(id) && zp_get_user_zombie_class(id) == idclass)
        skill_heal_handle(id)
}

public skill_heal_handle(id)
{
    if(g_can_heal[id])
    {
        // check health
        new start_health = zp_get_zombie_maxhealth(id)
        if(get_user_health(id) >= start_health)
            return PLUGIN_CONTINUE
        
        // set health
        new Float:health, health_up, health_set, new_health
        
        health = float(get_user_health(id))
        
        health_up = heal_amount
        
        health_set = floatround(health + health_up)
        new_health = min(start_health, health_set)
        
        fm_set_user_health(id, new_health)
        g_current_time[id] = 0
        
        // Make a screen fade
        message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("ScreenFade"), _, id)
        write_short((1<<12) * 1) // duration
        write_short(0) // hold time
        write_short(0x0000) // fade type
        write_byte(0) // red
        write_byte(150) // green
        write_byte(0) // blue
        write_byte(50) // alpha
        message_end()
        
        client_print(id, print_center, "Healed...")        
        
        // effect
        PlaySound(id, zombie_sound_heal)
        
        static Float:Origin[3]
        pev(id, pev_origin, Origin)
        
        message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
        write_byte(TE_EXPLOSION)
        engfunc(EngFunc_WriteCoord, Origin[0])
        engfunc(EngFunc_WriteCoord, Origin[1])
        engfunc(EngFunc_WriteCoord, Origin[2])
        write_short(heal_sprite_id)
        write_byte(15)
        write_byte(12)
        write_byte(14)
        message_end()
        
        // set time wait
        g_can_heal[id] = 0
        if (task_exists(id+TASK_WAIT_HEAL)) remove_task(id+TASK_WAIT_HEAL)
        set_task(heal_time_wait, "reset_skill_heal", id+TASK_WAIT_HEAL)
    }    
    
    return PLUGIN_HANDLED
}

public reset_skill_heal(id)
{
    id -= TASK_WAIT_HEAL
    
    if(is_user_alive(id) && zp_get_user_zombie(id) && zp_get_user_zombie_class(id) == idclass)
    {
        g_can_heal[id] = 1
        g_current_time[id] = 100
    }
}

public handle_gun(id)
{
    new weap = get_user_weapon(id)

    if(weap == CSW_HEGRENADE && zp_get_user_zombie_class(id) == idclass && zp_get_user_zombie(id))
    {
        entity_set_string(id, EV_SZ_viewmodel, g_vgrenade)
    }
    else if(weap == CSW_SMOKEGRENADE && zp_get_user_zombie_class(id) == idclass && zp_get_user_zombie(id))
    {
        entity_set_string(id, EV_SZ_viewmodel, g_vgrenade)
    }
    else if(weap == CSW_HEGRENADE && zp_get_user_zombie(id))
    {
        set_pev(id, pev_weaponmodel2, g_pgrenade);
    }
    else if(weap == CSW_SMOKEGRENADE && zp_get_user_zombie(id))
    {
        set_pev(id, pev_weaponmodel2, g_pgrenade);
    }

    return PLUGIN_HANDLED
}  

// ================================== Skill: Harden ================================
public cmd_lastinv(id)
{
    if(is_user_alive(id) && zp_get_user_zombie(id) && zp_get_user_zombie_class(id) == idclass)
        skill_harden_handle(id)
}

public skill_harden_handle(id)
{
    if(g_can_harden[id] && !g_hardening[id])
    {
        play_weapon_anim(id, 2)
        set_weapons_timeidle(id, 1.75)
        set_player_nextattack(id, 1.75)
        
        emit_sound(id, CHAN_ITEM, harden_sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
        fm_set_user_rendering(id, kRenderFxGlowShell, 255, 0, 0, kRenderNormal, 16)
        
        g_can_harden[id] = 0
        g_hardening[id] = 1
        g_current_time2[id] = 0

        set_task(harden_time, "stop_harden", id+TASK_H_TIME_REMOVE)
    }
}

public stop_harden(id)
{
    id -= TASK_H_TIME_REMOVE
    
    if(is_user_alive(id) && zp_get_user_zombie(id) && zp_get_user_zombie_class(id) == idclass)
    {
        fm_set_user_rendering(id)
        
        g_can_harden[id] = 0
        g_hardening[id] = 0
        
        set_task(harden_time_wait, "reset_harden", id+TASK_H_TIME_WAIT)
    }
}

public reset_harden(id)
{
    id -= TASK_H_TIME_WAIT
    
    if(is_user_alive(id) && zp_get_user_zombie(id) && zp_get_user_zombie_class(id) == idclass)
    {
        fm_set_user_rendering(id)
        
        g_can_harden[id] = 1
        g_hardening[id] = 0
        
        g_current_time2[id] = 100
    }    
}

// ================================== MAIN MESSAGE ====================================
public msg_clcorpse()
{
    static id
    id = get_msg_arg_int(12)
    
    if(!zp_get_user_zombie(id))
        return PLUGIN_CONTINUE
    if(zp_get_user_zombie_class(id) != idclass)
        return PLUGIN_CONTINUE
    
    if(g_hide_corpse[id])
        return PLUGIN_HANDLED
        
    return PLUGIN_CONTINUE
}  

// ================================== FORWARD ===============================
public fw_Spawn_Post(id)
{
    if(!is_user_connected(id))
        return HAM_IGNORED
        
    g_hide_corpse[id] = 0
    fm_set_user_rendering(id)
    
    return HAM_HANDLED
}

public fw_Killed_Post(id)
{
    if(!is_user_connected(id))
        return HAM_IGNORED
    if(!zp_get_user_zombie(id))
        return HAM_IGNORED
    if(zp_get_user_zombie_class(id) != idclass)
        return HAM_IGNORED
    
    g_hide_corpse[id] = 1
    fm_set_user_rendering(id, kRenderFxGlowShell, 0, 0, 0, kRenderTransAlpha, 0)
    death_effect(id)
    
    return HAM_HANDLED
}

public fw_Think_Gib(ent)
{
    if(!pev_valid(ent))
        return
        
    engfunc(EngFunc_RemoveEntity, ent)
}

public fw_TakeDamage(victim, inflictor, attacker, Float:damage, damagebits)
{
    if(!is_user_connected(victim) || !is_user_connected(attacker))
        return HAM_IGNORED
    if(!zp_get_user_zombie(victim) || zp_get_user_zombie(attacker))
        return HAM_IGNORED
    if(zp_get_user_zombie_class(victim) != idclass)
        return HAM_IGNORED
    if(!g_hardening[victim])
        return HAM_IGNORED
        
    SetHamParamFloat(4, damage * harden_damage_def)
    set_pdata_float(victim, 108, harden_painshock_def, 5)
        
    return HAM_HANDLED
}

// ================================= MAIN PUBLIC =========================================
public death_effect(id)
{
    static Float:Origin[3]
    pev(id, pev_origin, Origin)
    
    create_explode_effect(Origin)
    create_explode_gib(id)
    emit_sound(id, CHAN_STATIC, death_exp_effect_sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
    
    check_and_knockback(id, Origin, death_exp_radius)
}

public create_explode_gib(owner)
{
    new ent
    ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))
    
    if(!pev_valid(ent))
        return
        
    static Float:Origin[3]
    static Float:maxs[3], Float:mins[3]
    
    pev(owner, pev_origin, Origin)
    set_pev(ent, pev_origin, Origin)
    
    mins[0] = -16.0; maxs[0] = 16.0
    mins[1] = -16.0; maxs[1] = 16.0
    mins[2] = -36.0; maxs[2] = 36.0
    entity_set_size(ent, mins, maxs)
    engfunc(EngFunc_SetModel, ent, death_exp_effect_model)
    
    set_pev(ent, pev_classname, GIB_CLASSNAME)
    set_entity_anim(ent, 0)
    
    set_pev(ent, pev_nextthink, get_gametime() + 0.25)
}

public create_explode_effect(Float:Origin[3])
{
    message_begin(MSG_BROADCAST ,SVC_TEMPENTITY)
    write_byte(TE_EXPLOSION)
    engfunc(EngFunc_WriteCoord, Origin[0])
    engfunc(EngFunc_WriteCoord, Origin[1])
    engfunc(EngFunc_WriteCoord, Origin[2])
    write_short(g_explode_effect_idspr)    // sprite index
    write_byte(30)    // scale in 0.1's
    write_byte(30)    // framerate
    write_byte(4)    // flags
    message_end()    
}

public check_and_knockback(id, Float:Origin[3], Float:radius)
{
    static iVictim
    iVictim = -1
    
    static const hit_sound[3][] =
    {
        "player/bhit_flesh-1.wav",
        "player/bhit_flesh-2.wav",
        "player/bhit_flesh-3.wav"
    }
    
    while((iVictim = find_ent_in_sphere(iVictim, Origin, radius)) != 0)
    {
        if(is_user_alive(iVictim) && can_see_fm(iVictim, id) && cs_get_user_team(id) != cs_get_user_team(iVictim))
        {
            shake_screen(iVictim)
            
            if(is_in_viewcone(iVictim, Origin, 1))
                hook_ent2(iVictim, Origin, death_exp_knockspeed, 2)
            else
                hook_ent2(iVictim, Origin, death_exp_knockspeed, 1)
            
            ExecuteHamB(Ham_TakeDamage, iVictim, 0, iVictim, 0.0, DMG_BULLET)
            emit_sound(iVictim, CHAN_BODY, hit_sound[random(sizeof(hit_sound))], 1.0, ATTN_NORM, 0, PITCH_NORM)
        }
    }    
}

// ================================ MAIN STOCK =====================================
set_weapons_timeidle(id, Float:timeidle)
{
    new entwpn = fm_get_user_weapon_entity(id, get_user_weapon(id))
    if (pev_valid(entwpn)) set_pdata_float(entwpn, m_flTimeWeaponIdle, timeidle + 3.0, 4)
}

set_player_nextattack(id, Float:nexttime)
{
    set_pdata_float(id, m_flNextAttack, nexttime, 4)
}

stock play_weapon_anim(player, anim)
{
    set_pev(player, pev_weaponanim, anim)
    
    message_begin(MSG_ONE, SVC_WEAPONANIM, {0, 0, 0}, player)
    write_byte(anim)
    write_byte(pev(player, pev_body))
    message_end()
}

stock PlaySound(id, const sound[])
{
    client_cmd(id, "spk ^"%s^"", sound)
}

stock set_entity_anim(ent, anim)
{
    if(!pev_valid(ent))
        return
    
    entity_set_float(ent, EV_FL_animtime, get_gametime())
    entity_set_float(ent, EV_FL_framerate, 1.0)
    entity_set_float(ent, EV_FL_frame, 0.0)
    
    entity_set_int(ent, EV_INT_sequence, anim)    
}

stock shake_screen(id)
{
    message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("ScreenShake"),{0,0,0}, id)
    write_short(1<<14)
    write_short(1<<13)
    write_short(1<<13)
    message_end()
}

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

    entity_set_vector(ent, EV_VEC_velocity, fl_Velocity)
}

stock bool:can_see_fm(entindex1, entindex2)
{
    if (!entindex1 || !entindex2)
        return false

    if (pev_valid(entindex1) && pev_valid(entindex1))
    {
        new flags = pev(entindex1, pev_flags)
        if (flags & EF_NODRAW || flags & FL_NOTARGET)
        {
            return false
        }

        new Float:lookerOrig[3]
        new Float:targetBaseOrig[3]
        new Float:targetOrig[3]
        new Float:temp[3]

        pev(entindex1, pev_origin, lookerOrig)
        pev(entindex1, pev_view_ofs, temp)
        lookerOrig[0] += temp[0]
        lookerOrig[1] += temp[1]
        lookerOrig[2] += temp[2]

        pev(entindex2, pev_origin, targetBaseOrig)
        pev(entindex2, pev_view_ofs, temp)
        targetOrig[0] = targetBaseOrig [0] + temp[0]
        targetOrig[1] = targetBaseOrig [1] + temp[1]
        targetOrig[2] = targetBaseOrig [2] + temp[2]

        engfunc(EngFunc_TraceLine, lookerOrig, targetOrig, 0, entindex1, 0) //  checks the had of seen player
        if (get_tr2(0, TraceResult:TR_InOpen) && get_tr2(0, TraceResult:TR_InWater))
        {
            return false
        }
        else
        {
            new Float:flFraction
            get_tr2(0, TraceResult:TR_flFraction, flFraction)
            if (flFraction == 1.0 || (get_tr2(0, TraceResult:TR_pHit) == entindex2))
            {
                return true
            }
            else
            {
                targetOrig[0] = targetBaseOrig [0]
                targetOrig[1] = targetBaseOrig [1]
                targetOrig[2] = targetBaseOrig [2]
                engfunc(EngFunc_TraceLine, lookerOrig, targetOrig, 0, entindex1, 0) //  checks the body of seen player
                get_tr2(0, TraceResult:TR_flFraction, flFraction)
                if (flFraction == 1.0 || (get_tr2(0, TraceResult:TR_pHit) == entindex2))
                {
                    return true
                }
                else
                {
                    targetOrig[0] = targetBaseOrig [0]
                    targetOrig[1] = targetBaseOrig [1]
                    targetOrig[2] = targetBaseOrig [2] - 17.0
                    engfunc(EngFunc_TraceLine, lookerOrig, targetOrig, 0, entindex1, 0) //  checks the legs of seen player
                    get_tr2(0, TraceResult:TR_flFraction, flFraction)
                    if (flFraction == 1.0 || (get_tr2(0, TraceResult:TR_pHit) == entindex2))
                    {
                        return true
                    }
                }
            }
        }
    }
    return false
}

public client_prethink(id)
{
    if (zp_get_user_zombie_class(id) == idclass)
    {
        if(is_user_alive(id) && zp_get_user_zombie(id) && (zp_get_user_zombie_class(id) == idclass) && !zp_get_user_nemesis(id))
        Action(id);
    }
}

public Action(id)
{
    if (g_speeded[id] == 1)
    {
        set_user_maxspeed(id , g_fastspeed);
    }
    else
    {
        set_user_maxspeed(id , g_normspeed);
    }
        return PLUGIN_HANDLED;
}

public roundStart()
{
    for (new i = 1; i <= g_maxplayers; i++)
    {
        i_cooldown_time[i] = floatround(g_abilonecooldown)
        g_abil_one_used[i] = 0
        g_speeded[i] = 0
        remove_task(i)
        client_cmd(i,"cl_forwardspeed 400")
        client_cmd(i,"cl_backspeed 400")
    }
}

public ShowHUD(id)
{
    if(is_user_alive(id))
    {
        i_cooldown_time[id] = i_cooldown_time[id] - 1;
        set_hudmessage(200, 100, 0, 0.75, 0.92, 0, 1.0, 1.1, 0.0, 0.0, -1)
        show_hudmessage(id, "Откат умения: %d",i_cooldown_time[id])
    }else{
        remove_task(id)
    }
}

public Spawn(id)
{
    set_user_rendering(id)
    
}

public use_ability_one(id)
{
    if (is_user_alive(id) && (zp_get_user_zombie_class(id) == idclass) && zp_get_user_zombie(id) && !zp_get_user_nemesis(id))
    {
        
        if(g_abil_one_used[id] == 0)
        {    
            client_cmd(id,"cl_forwardspeed 1600")
            client_cmd(id,"cl_backspeed 1600")
    
            message_begin (MSG_BROADCAST,SVC_TEMPENTITY)
            write_byte (TE_BEAMFOLLOW)
            write_short (id)
            write_short (gTrail)
            set_user_rendering(id, kRenderFxGlowShell,255,0,0,kRenderNormal,25)
            write_byte (TRAIL_LIFE)
            write_byte (TRAIL_WIDTH)
            write_byte (TRAIL_RED)
            write_byte (TRAIL_GREEN)
            write_byte (TRAIL_BLUE)
            write_byte (TRAIL_BRIGTHNESS)
            message_end()

            g_speeded[id] = 1
            emit_sound(id, CHAN_STREAM, sound_china_sprint, 1.0, ATTN_NORM, 0, PITCH_NORM)
            g_abil_one_used[id] = 1
            set_task(g_abilonelenght,"set_normal_speed",id)
                        
            i_cooldown_time[id] = floatround(g_abilonecooldown)
            set_task(1.0, "ShowHUD", id, _, _, "a",i_cooldown_time[id])
//            client_print(id,print_chat,"[dev] - use ability")
        }        
    }
}

public set_normal_speed(id)
{
    if ((zp_get_user_zombie_class(id) == idclass) && zp_get_user_zombie(id) && !zp_get_user_nemesis(id))
    {
        g_speeded[id] = 0
        set_user_rendering(id)
        client_cmd(id,"cl_forwardspeed 400")
        client_cmd(id,"cl_backspeed 400")
        set_task(g_abilonecooldown,"set_ability_one_cooldown",id)
//        client_print(id,print_chat,"[dev] - executed 'set normal speed' task")
    }
}

public set_ability_one_cooldown(id)
{
    if ((zp_get_user_zombie_class(id) == idclass) && zp_get_user_zombie(id) && !zp_get_user_nemesis(id))
    {
        g_abil_one_used[id] = 0
        new text[100]
        format(text,99,"^x04[ZP]^x01 Способность  ^x04Ускорения^x01 активна.")
        message_begin(MSG_ONE,get_user_msgid("SayText"),{0,0,0},id)
        write_byte(id)
        write_string(text)
        message_end()
    }
}