Zombie Gigant

// Ignored xs__ variables
#pragma semicolon 1
#pragma ctrlchar '\'

new __dhud_color;
new __dhud_x;
new __dhud_y;
new __dhud_effect;
new __dhud_fxtime;
new __dhud_holdtime;
new __dhud_fadeintime;
new __dhud_fadeouttime;
new __dhud_reliable;
new PRIMARY_WEAPONS_BIT_SUM = 8899675000000000.00/*1509749160*/;
new SECONDARY_WEAPONS_BIT_SUM = 67308546;
new pev_think = 100;
new pev_team2 = 101;
new pev_death = 102;
new pev_vectipe = 103;
new g_mana[33];
new g_countevolution[33];
new bool:g_evolution[33];
new g_zg[33];
new bool:Register;
new create_ent;
new zg_reload[33];
new RELOAD_TIME_ZG;
new modelindex[3];
new modelindex2[10];
new blood[2];
new g_Hud;
new fw_infect_user;
new fw_zombi_killed;
new Float:hud_delay[33];
new Float:bot_delay[33];
new Float:mana_delay[33];
new Model_Zg[3][] =
{
    "models/zombiegiant/zombi/zg_dione.mdl",
    "models/zombiegiant/zombi/zg_revenant.mdl",
    "models/zombiegiant/zombi/zg_titan.mdl"
};
new Model_Attack[3][] =
{
    "models/zombiegiant/ef_zg_dione.mdl",
    "models/zombiegiant/ef_zg_revenant.mdl",
    "models/zombiegiant/ef_zg_titan.mdl"
};
new sound_footstep[4][] =
{
    "zombi/zg/footstep1.wav",
    "zombi/zg/footstep2.wav",
    "zombi/zg/footstep3.wav",
    "zombi/zg/footstep4.wav"
};
new sound_dione[13][] =
{
    "zombi/zg/dione/death1.wav",
    "zombi/zg/dione/appear2.wav",
    "zombi/zg/dione/dash.wav",
    "zombi/zg/dione/evolution.wav",
    "zombi/zg/dione/idle.wav",
    "zombi/zg/dione/skill_final.wav",
    "zombi/zg/dione/skill_poison.wav",
    "zombi/zg/dione/skill_rolling.wav",
    "zombi/zg/dione/skill_rolling_end.wav",
    "zombi/zg/dione/skill_tantacle.wav",
    "zombi/zg/dione/attack1_1.wav",
    "zombi/zg/dione/attack1_2.wav",
    "zombi/zg/dione/attack2.wav"
};
new sound_revenant[13][] =
{
    "zombi/zg/revenant/death1.wav",
    "zombi/zg/revenant/appear2.wav",
    "zombi/zg/titan/dash.wav",
    "zombi/zg/revenant/evolution.wav",
    "zombi/zg/revenant/idle.wav",
    "zombi/zg/revenant/skill_final.wav",
    "zombi/zg/revenant/skill_fireball2.wav",
    "zombi/zg/revenant/skill_fireball3.wav",
    "zombi/zg/revenant/skill_inferno.wav",
    "zombi/zg/revenant/fireball_explode.wav",
    "zombi/zg/revenant/attack1_1.wav",
    "zombi/zg/revenant/attack1_2.wav",
    "zombi/zg/revenant/attack2.wav"
};
new sound_titan[14][] =
{
    "zombi/zg/titan/death1.wav",
    "zombi/zg/titan/appear2.wav",
    "zombi/zg/titan/dash.wav",
    "zombi/zg/titan/evolution.wav",
    "zombi/zg/titan/idle.wav",
    "zombi/zg/titan/skill_final.wav",
    "zombi/zg/titan/zbs_attack1_1.wav",
    "zombi/zg/titan/zbs_attack1_2.wav",
    "zombi/zg/titan/zbs_attack1_3.wav",
    "zombi/zg/titan/zbs_cannon_start.wav",
    "zombi/zg/titan/zbs_cannon1.wav",
    "zombi/zg/titan/zbs_landmine1.wav",
    "zombi/zg/titan/attack1_2.wav",
    "zombi/zg/titan/attack1_4.wav"
};
new Float:VEC_HULL_MIN[3] =
{
    -1029701632, -1029701632, -1022099456
}
new Float:VEC_HULL_MAX[3] =
{
    1117782016, 1117782016, 1124728832
}

Float:operator-(Float:)(Float:oper)
{
    return oper ^ 0.00/*-2147483648*/;
}

Float:operator*(Float:,_:)(Float:oper1, oper2)
{
    return oper1 * float(oper2);
}

Float:operator/(Float:,_:)(Float:oper1, oper2)
{
    return oper1 / float(oper2);
}

Float:operator/(_:,Float:)(oper1, Float:oper2)
{
    return float(oper1) / oper2;
}

bool:operator!=(Float:,_:)(Float:oper1, oper2)
{
    return floatcmp(oper1, float(oper2)) != 0;
}

bool:operator>(Float:,Float:)(Float:oper1, Float:oper2)
{
    return 0 < floatcmp(oper1, oper2);
}

bool:operator>=(Float:,Float:)(Float:oper1, Float:oper2)
{
    return 0 <= floatcmp(oper1, oper2);
}

bool:operator>=(Float:,_:)(Float:oper1, oper2)
{
    return 0 <= floatcmp(oper1, float(oper2));
}

bool:operator<(Float:,Float:)(Float:oper1, Float:oper2)
{
    return 0 > floatcmp(oper1, oper2);
}

bool:operator<(_:,Float:)(oper1, Float:oper2)
{
    return 0 > floatcmp(float(oper1), oper2);
}

bool:operator<=(Float:,Float:)(Float:oper1, Float:oper2)
{
    return 0 >= floatcmp(oper1, oper2);
}

bool:operator<=(Float:,_:)(Float:oper1, oper2)
{
    return 0 >= floatcmp(oper1, float(oper2));
}

Float:floatmin(Float:ValueA, Float:ValueB)
{
    if (ValueA <= ValueB)
    {
        return ValueA;
    }
    return ValueB;
}

Float:floatmax(Float:ValueA, Float:ValueB)
{
    if (ValueA >= ValueB)
    {
        return ValueA;
    }
    return ValueB;
}

public __fatal_ham_error(Ham:id, HamError:err, String:reason[])
{
    !!! Removed Phi
    if (func != -1 && callfunc_begin_i(func, -1) == 1)
    {
        callfunc_push_int(id);
        callfunc_push_int(err);
        callfunc_push_str(reason, false);
        if (callfunc_end() == 1)
        {
            fail = 0;
        }
    }
    if (fail)
    {
        set_fail_state(reason);
    }
    return 0;
}

set_dhudmessage(red, green, blue, Float:x, Float:y, effects, Float:fxtime, Float:holdtime, Float:fadeintime, Float:fadeouttime, bool:reliable)
{
    __dhud_color = clamp(red, 0, 255) << 16 + clamp(green, 0, 255) << 8 + clamp(blue, 0, 255);
    __dhud_x = x;
    __dhud_y = y;
    __dhud_effect = effects;
    __dhud_fxtime = fxtime;
    __dhud_holdtime = holdtime;
    __dhud_fadeintime = fadeintime;
    __dhud_fadeouttime = fadeouttime;
    __dhud_reliable = reliable;
    return 1;
}

show_dhudmessage(index, String:message[])
{
    !!! Removed Phi
    new buffer[128];
    new numArguments = numargs();
    if (numArguments == 2)
    {
        send_dhudMessage(index, message);
    }
    else
    {
        if (index || numArguments == 3)
        {
            vformat(buffer, 127, message, 3);
            send_dhudMessage(index, buffer);
        }
        new playersList[32];
        new numPlayers = 0;
        get_players(playersList, numPlayers, "ch", "");
        if (!numPlayers)
        {
            return 0;
        }
        new Array:handleArrayML = ArrayCreate(1, 32);
        new i = 2;
        new j = 0;
        while (i < numArguments)
        {
            if (getarg(i, 0) == -1)
            {
                do {
                    j++;
                    new var2 = getarg(i + 1, j);
                    buffer[j] = var2;
                } while (var2);
                j = 0;
                if (GetLangTransKey(buffer) != -1)
                {
                    i++;
                    ArrayPushCell(handleArrayML, i);
                    i++;
                }
                i++;
            }
            i++;
        }
        new size = ArraySize(handleArrayML);
        if (!size)
        {
            vformat(buffer, 127, message, 3);
            send_dhudMessage(index, buffer);
        }
        else
        {
            new i = 0;
            new j = 0;
            while (i < numPlayers)
            {
                index = playersList[i];
                j = 0;
                while (j < size)
                {
                    setarg(ArrayGetCell(handleArrayML, j), 0, index);
                    j++;
                }
                vformat(buffer, 127, message, 3);
                send_dhudMessage(index, buffer);
                i++;
            }
        }
        ArrayDestroy(handleArrayML);
    }
    return 1;
}

send_dhudMessage(index, String:message[])
{
    new var2;
    if (__dhud_reliable)
    {
        new var1;
        if (index)
        {
            var1 = 1;
        }
        else
        {
            var1 = 2;
        }

/ * ERROR! Не удалось привести тип объекта "Lysis.DSentinel" к типу "Lysis.DReturn". * /
 function "send_dhudMessage"
send_dhudMessage(index, String:message[])

Float:xs_sqrt(Float:x)
{
    return floatsqroot(x);
}

xs_vec_add(Float:in1[], Float:in2[], Float:out[])
{
    out[0] = in1[0] + in2[0];
    out[1] = in1[1] + in2[1];
    out[2] = in1[2] + in2[2];
    return 0;
}

xs_vec_sub(Float:in1[], Float:in2[], Float:out[])
{
    out[0] = in1[0] - in2[0];
    out[1] = in1[1] - in2[1];
    out[2] = in1[2] - in2[2];
    return 0;
}

xs_vec_mul_scalar(Float:vec[], Float:scalar, Float:out[])
{
    out[0] = vec[0] * scalar;
    out[1] = vec[1] * scalar;
    out[2] = vec[2] * scalar;
    return 0;
}

Float:xs_vec_len(Float:vec[])
{
    return xs_sqrt(vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2]);
}

public plugin_init()
{
    register_event("DeathMsg", "Event_Death", "a", "");
    register_event("CurWeapon", "Event_CurWeapon", "be", "1=1");
    register_message(get_user_msgid("DeathMsg"), "Message_DeathMsg");
    register_forward(FM_CmdStart, "fw_CmdStart", 0);
    register_forward(FM_AddToFullPack, "fw_AddToFullPack", 1);
    register_think("cso_zombie_giant", "fw_Think");
    register_think("zg_attack_effect", "fw_Think_Effect");
    register_think("zg_tentacle", "fw_Think_Tentacle");
    register_think("zg_tentacle2", "fw_Think_Tentacle2");
    register_think("zg_poison2", "fw_Think_Poison");
    register_think("zg_fireball", "fw_Think_FireBall");
    register_think("zg_fireball2", "fw_Think_FireBall2");
    register_think("zg_granade", "fw_Think_Rocket");
    register_touch("zg_poison", "*", "fw_Touch_Poison");
    register_touch("zg_fireball", "*", "fw_Touch_FireBall");
    register_touch("zg_fireball2", "*", "fw_Touch_FireBall2");
    register_touch("zg_granade", "*", "fw_Touch_Rocket");
    register_concmd("bugboss", "areglar", -1, "", -1);
    register_clcmd("say bugboss", "areglar", -1, "", -1);
    register_clcmd("radio1", "skill_1", -1, "", -1);
    register_clcmd("radio2", "skill_2", -1, "", -1);
    register_clcmd("radio3", "skill_3", -1, "", -1);
    g_Hud = CreateHudSyncObj(0);
    fw_infect_user = CreateMultiForward("zg_infect_user", 0, 0);
    fw_zombi_killed = CreateMultiForward("zg_zombi_killed", 0, 0, 0, 0);
    return 0;
}

public plugin_precache()
{
    LoadFiles();
    blood[0] = engfunc(EngFunc_PrecacheModel, "sprites/blood.spr");
    blood[1] = engfunc(EngFunc_PrecacheModel, "sprites/bloodspray.spr");
    new var1 = Model_Zg;
    modelindex[0] = engfunc(EngFunc_PrecacheModel, var1[0][0][var1]);
    modelindex[1] = engfunc(EngFunc_PrecacheModel, Model_Zg[1][0]);
    modelindex[2] = engfunc(EngFunc_PrecacheModel, Model_Zg[2][0]);
    modelindex2[0] = engfunc(EngFunc_PrecacheModel, "sprites/zg/ef_bat.spr");
    modelindex2[1] = engfunc(EngFunc_PrecacheModel, "models/zombiegiant/gibs_cave.mdl");
    modelindex2[2] = engfunc(EngFunc_PrecacheModel, "sprites/zg/gunsmoke.spr");
    modelindex2[3] = engfunc(EngFunc_PrecacheModel, "sprites/zg/gunsmoke2.spr");
    modelindex2[4] = engfunc(EngFunc_PrecacheModel, "sprites/zg/fexplo.spr");
    modelindex2[5] = engfunc(EngFunc_PrecacheModel, "models/cindergibs.mdl");
    modelindex2[6] = engfunc(EngFunc_PrecacheModel, "sprites/zg/ef_smoke_poison.spr");
    modelindex2[7] = engfunc(EngFunc_PrecacheModel, "sprites/zg/spr_boomer.spr");
    new i = 0;
    i = 0;
    while (i < 3)
    {
        engfunc(EngFunc_PrecacheModel, Model_Attack[i][0][0]);
        i++;
    }
    i = 0;
    while (i < 3)
    {
        engfunc(EngFunc_PrecacheModel, Model_Zg[i][0][0]);
        i++;
    }
    engfunc(EngFunc_PrecacheModel, "models/zombiegiant/ef_skill4_a.mdl");
    engfunc(EngFunc_PrecacheModel, "models/zombiegiant/ef_swing.mdl");
    engfunc(EngFunc_PrecacheModel, "models/zombiegiant/ef_dione_tentacle.mdl");
    engfunc(EngFunc_PrecacheModel, "models/zombiegiant/dione_tentacle.mdl");
    engfunc(EngFunc_PrecacheModel, "models/zombiegiant/dione_poison.mdl");
    engfunc(EngFunc_PrecacheModel, "models/zombiegiant/ef_poisonground.mdl");
    engfunc(EngFunc_PrecacheModel, "models/zombiegiant/revenant_fireball.mdl");
    engfunc(EngFunc_PrecacheModel, "models/zombiegiant/titan_grenade.mdl");
    engfunc(EngFunc_PrecacheModel, "models/zombiegiant/titan_m14.mdl");
    i = 0;
    while (i < 13)
    {
        engfunc(EngFunc_PrecacheSound, sound_dione[i][0][0]);
        i++;
    }
    i = 0;
    while (i < 13)
    {
        engfunc(EngFunc_PrecacheSound, sound_revenant[i][0][0]);
        i++;
    }
    i = 0;
    while (i < 14)
    {
        engfunc(EngFunc_PrecacheSound, sound_titan[i][0][0]);
        i++;
    }
    i = 0;
    while (i < 4)
    {
        engfunc(EngFunc_PrecacheSound, sound_footstep[i][0][0]);
        i++;
    }
    engfunc(EngFunc_PrecacheModel, "models/rpgrocket.mdl");
    return 0;
}

public plugin_natives()
{
    register_native("zg_remove_zombie_all", "native_zg_remove_zombie_all", 1);
    register_native("zg_make_zombie", "native_zg_make_zombie", 1);
    register_native("is_user_zombie", "native_is_user_zombie", 1);
    return 0;
}

public native_zg_remove_zombie_all()
{
    Event_Remove_Entity();
    return 0;
}

public native_zg_make_zombie(id, Class)
{
    Make_Zombie(id, Class);
    return 0;
}

public native_is_user_zombie(id)
{
    if (is_user_zombie(id))
    {
        return 1;
    }
    return 0;
}

public client_disconnect(id)
{
    if (is_user_zombie(id))
    {
        remove_task_ent(get_iEnt(id));
        remove_entity(get_iEnt(id));
        set_iEnt(id, 0);
        set_view(id, 0);
    }
    return 0;
}

public Event_Remove_Entity()
{
    new Zombie = 0;
    new Owner = 0;
    new var1 = find_ent_by_class(Zombie, "cso_zombie_giant");
    Zombie = var1;
    while (var1)
    {
        Owner = get_owner(Zombie);
        set_view(Owner, 0);
        set_iEnt(Owner, 0);
        remove_task_ent(Zombie);
        engfunc(EngFunc_RemoveEntity, Zombie);
    }
    return 0;
}

public Event_CurWeapon(id)
{
    if (!is_user_alive(id))
    {
        return 0;
    }
    if (!get_iEnt(id))
    {
        return 0;
    }
    set_pev(id, pev_viewmodel2, 0);
    set_pev(id, pev_weaponmodel2, 0);
    return 0;
}

public Event_Death()
{
    new iAttacker = read_data(1);
    new iVictim = read_data(2);
    if (!is_user_connected(iAttacker))
    {
        return 1;
    }
    if (!is_user_connected(iVictim))
    {
        return 1;
    }
    g_countevolution[iVictim] = 0;
    g_evolution[iVictim] = 0;
    if (!get_iEnt(iAttacker))
    {
        return 1;
    }
    new var1 = g_mana[iAttacker];
    var1 = var1[0][0] + 5;
    if (41 <= g_mana[iAttacker][0][0])
    {
        g_mana[iAttacker] = 40;
    }

/ * ERROR! Не удалось привести тип объекта "Lysis.DSentinel" к типу "Lysis.DReturn". * /
 function "Event_Death"
public Event_Death()

public Message_DeathMsg(msg_id, msg_dest, id)
{
    !!! Removed Phi
    if (!is_user_connected(iAttacker) || iVictim != iAttacker)
    {
        return 0;
    }
    if (is_user_zombie(iAttacker))
    {
        if (get_class(get_iEnt(iAttacker)))
        {
            if (get_class(get_iEnt(iAttacker)) == 1)
            {
                set_msg_arg_string(4, "revenant");
            }
            if (get_class(get_iEnt(iAttacker)) == 2)
            {
                set_msg_arg_string(4, "fallentitan");
            }
        }
        set_msg_arg_string(4, "dione");
    }
    return 0;
}

public client_PostThink(id)
{
    if (!is_user_alive(id))
    {
        return 0;
    }
    if (!get_iEnt(id))
    {
        return 0;
    }
    static iEnt;
    static len4[128];
    static len3[128];
    static len2[128];
    static len[128];
    static Float:CurTime;
    CurTime = get_gametime();
    iEnt = get_iEnt(id);
    static Float:gethealth;
    pev(iEnt, pev_health, gethealth);
    if (CurTime - 0.15 > hud_delay[id][0][0])
    {
        if (get_hp_bar(floatround(10000.00, floatround_round), gethealth))
        {
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 1)
            {
                formatex(len, 127, "-                                       ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 2)
            {
                formatex(len, 127, "--                                      ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 3)
            {
                formatex(len, 127, "---                                     ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 4)
            {
                formatex(len, 127, "----                                    ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 5)
            {
                formatex(len, 127, "-----                                   ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 6)
            {
                formatex(len, 127, "------                                  ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 7)
            {
                formatex(len, 127, "-------                                 ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 8)
            {
                formatex(len, 127, "--------                                ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 9)
            {
                formatex(len, 127, "---------                               ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 10)
            {
                formatex(len, 127, "----------                              ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 11)
            {
                formatex(len, 127, "-----------                             ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 12)
            {
                formatex(len, 127, "------------                            ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 13)
            {
                formatex(len, 127, "-------------                           ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 14)
            {
                formatex(len, 127, "--------------                          ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 15)
            {
                formatex(len, 127, "---------------                         ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 16)
            {
                formatex(len, 127, "----------------                        ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 17)
            {
                formatex(len, 127, "-----------------                       ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 18)
            {
                formatex(len, 127, "------------------                      ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 19)
            {
                formatex(len, 127, "-------------------                     ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 20)
            {
                formatex(len, 127, "--------------------                    ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 21)
            {
                formatex(len, 127, "---------------------                   ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 22)
            {
                formatex(len, 127, "----------------------                  ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 23)
            {
                formatex(len, 127, "-----------------------                 ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 24)
            {
                formatex(len, 127, "------------------------                ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 25)
            {
                formatex(len, 127, "-------------------------               ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 26)
            {
                formatex(len, 127, "--------------------------              ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 27)
            {
                formatex(len, 127, "---------------------------             ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 28)
            {
                formatex(len, 127, "----------------------------            ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 29)
            {
                formatex(len, 127, "-----------------------------           ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 30)
            {
                formatex(len, 127, "------------------------------          ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 31)
            {
                formatex(len, 127, "-------------------------------         ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 32)
            {
                formatex(len, 127, "--------------------------------        ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 33)
            {
                formatex(len, 127, "---------------------------------       ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 34)
            {
                formatex(len, 127, "----------------------------------      ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 35)
            {
                formatex(len, 127, "-----------------------------------     ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 36)
            {
                formatex(len, 127, "------------------------------------    ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 37)
            {
                formatex(len, 127, "-------------------------------------   ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 38)
            {
                formatex(len, 127, "--------------------------------------  ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 39)
            {
                formatex(len, 127, "--------------------------------------- ");
            }
            if (get_hp_bar(floatround(10000.00, floatround_round), gethealth) == 40)
            {
                formatex(len, 127, "----------------------------------------");
            }
            formatex(len, 127, "----------------------------------------");
        }
        else
        {
            formatex(len, 127, "                                        ");
        }
        new var2 = g_mana;
        new var1;
        if (var2[id][0][0])
        {
            new var3 = g_mana;
            if (var3[id][0][0] == 1)
            {
                formatex(len2, 127, "-                                       ");
                var1 = var3;
            }
            new var4 = g_mana;
            if (var4[id][0][0] == 2)
            {
                formatex(len2, 127, "--                                      ");
                var1 = var4;
            }
            new var5 = g_mana;
            if (var5[id][0][0] == 3)
            {
                formatex(len2, 127, "---                                     ");
                var1 = var5;
            }
            new var6 = g_mana;
            if (var6[id][0][0] == 4)
            {
                formatex(len2, 127, "----                                    ");
                var1 = var6;
            }
            new var7 = g_mana;
            if (var7[id][0][0] == 5)
            {
                formatex(len2, 127, "-----                                   ");
                var1 = var7;
            }
            new var8 = g_mana;
            if (var8[id][0][0] == 6)
            {
                formatex(len2, 127, "------                                  ");
                var1 = var8;
            }
            new var9 = g_mana;
            if (var9[id][0][0] == 7)
            {
                formatex(len2, 127, "-------                                 ");
                var1 = var9;
            }
            new var10 = g_mana;
            if (var10[id][0][0] == 8)
            {
                formatex(len2, 127, "--------                                ");
                var1 = var10;
            }
            new var11 = g_mana;
            if (var11[id][0][0] == 9)
            {
                formatex(len2, 127, "---------                               ");
                var1 = var11;
            }
            new var12 = g_mana;
            if (var12[id][0][0] == 10)
            {
                formatex(len2, 127, "----------                              ");
                var1 = var12;
            }
            new var13 = g_mana;
            if (var13[id][0][0] == 11)
            {
                formatex(len2, 127, "-----------                             ");
                var1 = var13;
            }
            new var14 = g_mana;
            if (var14[id][0][0] == 12)
            {
                formatex(len2, 127, "------------                            ");
                var1 = var14;
            }
            new var15 = g_mana;
            if (var15[id][0][0] == 13)
            {
                formatex(len2, 127, "-------------                           ");
                var1 = var15;
            }
            new var16 = g_mana;
            if (var16[id][0][0] == 14)
            {
                formatex(len2, 127, "--------------                          ");
                var1 = var16;
            }
            new var17 = g_mana;
            if (var17[id][0][0] == 15)
            {
                formatex(len2, 127, "---------------                         ");
                var1 = var17;
            }
            new var18 = g_mana;
            if (var18[id][0][0] == 16)
            {
                formatex(len2, 127, "----------------                        ");
                var1 = var18;
            }
            new var19 = g_mana;
            if (var19[id][0][0] == 17)
            {
                formatex(len2, 127, "-----------------                       ");
                var1 = var19;
            }
            new var20 = g_mana;
            if (var20[id][0][0] == 18)
            {
                formatex(len2, 127, "------------------                      ");
                var1 = var20;
            }
            new var21 = g_mana;
            if (var21[id][0][0] == 19)
            {
                formatex(len2, 127, "-------------------                     ");
                var1 = var21;
            }
            new var22 = g_mana;
            if (var22[id][0][0] == 20)
            {
                formatex(len2, 127, "--------------------                    ");
                var1 = var22;
            }
            new var23 = g_mana;
            if (var23[id][0][0] == 21)
            {
                formatex(len2, 127, "---------------------                   ");
                var1 = var23;
            }
            new var24 = g_mana;
            if (var24[id][0][0] == 22)
            {
                formatex(len2, 127, "----------------------                  ");
                var1 = var24;
            }
            new var25 = g_mana;
            if (var25[id][0][0] == 23)
            {
                formatex(len2, 127, "-----------------------                 ");
                var1 = var25;
            }
            new var26 = g_mana;
            if (var26[id][0][0] == 24)
            {
                formatex(len2, 127, "------------------------                ");
                var1 = var26;
            }
            new var27 = g_mana;
            if (var27[id][0][0] == 25)
            {
                formatex(len2, 127, "-------------------------               ");
                var1 = var27;
            }
            new var28 = g_mana;
            if (var28[id][0][0] == 26)
            {
                formatex(len2, 127, "--------------------------              ");
                var1 = var28;
            }
            new var29 = g_mana;
            if (var29[id][0][0] == 27)
            {
                formatex(len2, 127, "---------------------------             ");
                var1 = var29;
            }
            new var30 = g_mana;
            if (var30[id][0][0] == 28)
            {
                formatex(len2, 127, "----------------------------            ");
                var1 = var30;
            }
            new var31 = g_mana;
            if (var31[id][0][0] == 29)
            {
                formatex(len2, 127, "-----------------------------           ");
                var1 = var31;
            }
            new var32 = g_mana;
            if (var32[id][0][0] == 30)
            {
                formatex(len2, 127, "------------------------------          ");
                var1 = var32;
            }
            new var33 = g_mana;
            if (var33[id][0][0] == 31)
            {
                formatex(len2, 127, "-------------------------------         ");
                var1 = var33;
            }
            new var34 = g_mana;
            if (var34[id][0][0] == 32)
            {
                formatex(len2, 127, "--------------------------------        ");
                var1 = var34;
            }
            new var35 = g_mana;
            if (var35[id][0][0] == 33)
            {
                formatex(len2, 127, "---------------------------------       ");
                var1 = var35;
            }
            new var36 = g_mana;
            if (var36[id][0][0] == 34)
            {
                formatex(len2, 127, "----------------------------------      ");
                var1 = var36;
            }
            new var37 = g_mana;
            if (var37[id][0][0] == 35)
            {
                formatex(len2, 127, "-----------------------------------     ");
                var1 = var37;
            }
            new var38 = g_mana;
            if (var38[id][0][0] == 36)
            {
                formatex(len2, 127, "------------------------------------    ");
                var1 = var38;
            }
            new var39 = g_mana;
            if (var39[id][0][0] == 37)
            {
                formatex(len2, 127, "-------------------------------------   ");
                var1 = var39;
            }
            new var40 = g_mana;
            if (var40[id][0][0] == 38)
            {
                formatex(len2, 127, "--------------------------------------  ");
                var1 = var40;
            }
            new var41 = g_mana;
            if (var41[id][0][0] == 39)
            {
                formatex(len2, 127, "--------------------------------------- ");
                var1 = var41;
            }
            new var42 = g_mana;
            if (var42[id][0][0] == 40)
            {
                formatex(len2, 127, "----------------------------------------");
                var1 = var42;
            }
            formatex(len2, 127, "----------------------------------------");
            var1 = var42;
        }
        else
        {
            formatex(len2, 127, "                                        ");
            var1 = var2;
        }
        set_dhudmessage(255, 20, 0, -1.00, 0.00, 0, 0.23, 0.23, 0.00, 0.00, false);
        show_dhudmessage(id, "\n\n]|[%s]|[\n]|[%s]|[", len, len2);
        if (!g_evolution[id][0][0])
        {
            formatex(len3, 127, " ");
        }
        else
        {
            if (!get_evolution(iEnt))
            {
                formatex(len3, 127, "EVOLUTION ]|[E]|[");
            }
            formatex(len3, 127, " ");
        }
        if (get_class(get_iEnt(id)))
        {
            if (get_class(get_iEnt(id)) == 1)
            {
                formatex(len4, 127, "DASH [Z]\nFIREBALL [X]\nINFERNO [C]");
            }
            if (get_class(get_iEnt(id)) == 2)
            {
                formatex(len4, 127, "DASH [Z]\nCANNON [X]\nLAND MINE [C]");
            }
        }
        else
        {
            formatex(len4, 127, "ROLLING [Z]\nTENTACLE [X]\nPOISON [C]");
        }
        set_hudmessage(255, 56, 24, -1.00, 0.74, 0, 6.00, 0.10, 0.10, 0.20, 4);
        if (g_countevolution[id][0][0])
        {
            if (g_countevolution[id][0][0] == 1)
            {
                ShowSyncHudMsg(id, g_Hud, "%s\n%s\nFINAL [G]\n\nEvolution: 120%%%\n[||----------------]", len3, len4);
            }
            if (g_countevolution[id][0][0] == 2)
            {
                ShowSyncHudMsg(id, g_Hud, "%s\n%s\nFINAL [G]\n\nEvolution: 130%%%\n[||||--------------]", len3, len4);
            }
            if (g_countevolution[id][0][0] == 3)
            {
                ShowSyncHudMsg(id, g_Hud, "%s\n%s\nFINAL [G]\n\nEvolution: 140%%%\n[||||||------------]", len3, len4);
            }
            if (g_countevolution[id][0][0] == 4)
            {
                ShowSyncHudMsg(id, g_Hud, "%s\n%s\nFINAL [G]\n\nEvolution: 150%%%\n[||||||||----------]", len3, len4);
            }
            if (g_countevolution[id][0][0] == 5)
            {
                ShowSyncHudMsg(id, g_Hud, "%s\n%s\nFINAL [G]\n\nEvolution: 160%%%\n[||||||||||--------]", len3, len4);
            }
            if (g_countevolution[id][0][0] == 6)
            {
                ShowSyncHudMsg(id, g_Hud, "%s\n%s\nFINAL [G]\n\nEvolution: 170%%%\n[||||||||||||------]", len3, len4);
            }
            if (g_countevolution[id][0][0] == 7)
            {
                ShowSyncHudMsg(id, g_Hud, "%s\n%s\nFINAL [G]\n\nEvolution: 180%%%\n[||||||||||||||----]", len3, len4);
            }
            if (g_countevolution[id][0][0] == 8)
            {
                ShowSyncHudMsg(id, g_Hud, "%s\n%s\nFINAL [G]\n\nEvolution: 190%%%\n[||||||||||||||||--]", len3, len4);
            }
            ShowSyncHudMsg(id, g_Hud, "%s\n%s\nFINAL [G]\n\nEvolution: 200%%%\n[||||||||||||||||||]", len3, len4);
        }
        else
        {
            ShowSyncHudMsg(id, g_Hud, "%s\n%s\nFINAL [G]\n\nEvolution: 110%%%\n[------------------]", len3, len4);
        }
        872[id] = CurTime;
    }
    if (CurTime - 5.15 > bot_delay[id][0][0])
    {
        if (is_user_bot(id))
        {
            if (g_evolution[id][0][0])
            {
                npc_evolution(get_iEnt(id));
            }
            switch (random_num(0, 4))
            {
                case 0:
                {
                    skill_1(id);
                }
                case 1:
                {
                    if (random_num(0, 1) == 1)
                    {
                        if (get_class(get_iEnt(id)) == 1)
                        {
                            npc_attack(get_iEnt(id), 16);
                        }
                        else
                        {
                            skill_2(id);
                        }
                    }
                    else
                    {
                        skill_2(id);
                    }
                }
                case 2:
                {
                    skill_3(id);
                }
                case 3:
                {
                    if (random_num(0, 1) == 1)
                    {
                        if (get_class(get_iEnt(id)) == 1)
                        {
                            npc_attack(get_iEnt(id), 16);
                        }
                        else
                        {
                            skill_2(id);
                        }
                    }
                    else
                    {
                        skill_2(id);
                    }
                }
                case 4:
                {
                    skill_3(id);
                }
                default:
                {
                }
            }
        }

/ * ERROR! Ссылка на объект не указывает на экземпляр объекта. * /
 function "client_PostThink"
public client_PostThink(id)

public areglar(id)
{
    if (!get_iEnt(id))
    {
        return 0;
    }
    if (!task_exists(get_iEnt(id) + 1, 0))
    {
        set_task(1.00, "npc_reload_task", get_iEnt(id) + 1, "", 0, "", 0);
    }
    return 0;
}

public Make_Zombie(id, Class)
{
    Create_Zg2(id, Class);
    return 0;
}

public Create_Zg(id)
{
    Create_Zg2(id, random_num(0, 2));
    return 0;
}

public Create_Zg2(id, Class)
{
    !!! Removed Phi
    fm_set_user_godmode(id, 1);
    fm_set_user_noclip(id, 1);
    cs_set_user_team(id, 1, _}:0);
    drop_weapons(id, 1);
    drop_weapons(id, 2);
    if (is_user_zombie(id))
    {
        return 0;
    }
    static Float:Origin[3];
    pev(id, pev_origin, Origin);
    new var1 = Origin[2];
    var1 = var1[0] + 150.00;
    create_ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
    new ent = create_ent;
    entity_set_string(ent, 0, "cso_zombie_giant");
    entity_set_origin(ent, Origin);
    entity_set_float(ent, EV_FL_takedamage, 1.00);
    entity_set_float(ent, EV_FL_friction, 1.00);
    entity_set_float(ent, EV_FL_health, 10000.00);
    entity_set_float(ent, EV_FL_speed, 157.00);
    entity_set_float(ent, EV_FL_gravity, 36.00);
    entity_set_model(ent, Model_Zg[Class][0][0]);
    entity_set_int(ent, EV_INT_flags, 32);
    entity_set_int(ent, EV_INT_fixangle, 1);
    entity_set_int(ent, EV_INT_movetype, 13);
    entity_set_int(ent, EV_INT_solid, 2);
    entity_set_int(ent, EV_INT_gamestate, 1);
    set_pev(ent, pev_modelindex, modelindex[Class]);
    set_pev(ent, pev_owner, id);
    set_pev(ent, pev_enemy, 0);
    new var2 = Heap_4;
    var2[0] = 32052;
    set_team(ent, get_user_team(id, var2, 0));
    engfunc(EngFunc_SetSize, ent, VEC_HULL_MIN, VEC_HULL_MAX);
    pev(id, pev_angles, Origin);
    Origin[2] = 0;
    Origin[0] = 0;
    set_pev(ent, pev_angles, Origin);
    set_ready2(id, false);
    set_evolution(ent, false);
    set_class(ent, Class);
    EmitSound(ent, "zombi/zg/system/zombie_spawn.wav", 1);
    if (Class)
    {
        if (Class == 1)
        {
            EmitSound(ent, sound_revenant[1][0], 1);
        }
        if (Class == 2)
        {
            EmitSound(ent, sound_titan[1][0], 1);
        }
    }
    else
    {
        EmitSound(ent, sound_dione[1][0], 1);
    }
    if (!Register)
    {
        RegisterHamFromEntity(Ham_Killed, ent, "fw_ZombiG_Killed", 0);
        RegisterHamFromEntity(Ham_TakeDamage, ent, "fw_TakeDamage", 0);
        RegisterHamFromEntity(Ham_TraceAttack, ent, "fw_TraceAttack", 0);
        Register = 1;
    }
    set_pev(ent, pev_fuser1, get_gametime() + 5.70);
    entity_set_float(ent, EV_FL_nextthink, halflife_time());
    engfunc(EngFunc_DropToFloor, ent);
    set_entity_anim(ent, get_anim(ent, 23));
    set_iEnt(id, ent);
    set_view(id, 1);
    set_pev(id, pev_solid, 0);
    set_pev(id, pev_viewmodel2, 0);
    set_pev(id, pev_weaponmodel2, 0);
    entity_set_int(id, EV_INT_rendermode, 4);
    entity_set_float(id, EV_FL_renderamt, 0.00);
    fm_set_rendering(id, 0, 15, 15, 15, 4, 10);
    set_mana(id, 40);
    pev(ent, pev_origin, Origin);
    new var3 = Origin[2];
    var3 = var3[0] + 120.00;
    set_pev(id, pev_origin, Origin);
    new var4 = Origin[2];
    var4 = var4[0] - 80.00;
    create_effect(Origin, modelindex2[0][0], 32, 8, 14);
    create_break(Origin, modelindex2[1][0], 20, 16, 20);
    static g_fwDummyResult;
    ExecuteForward(fw_infect_user, g_fwDummyResult, id);
    return 0;
}

public fw_AddToFullPack(es, e, ent, host, hostflags, player, pSet)
{
    !!! Removed Phi
    if (player && get_orig_retval())
    {
        if (!is_user_connected(host))
        {
            return 1;
        }
        if (!is_user_connected(ent))
        {
            return 1;
        }
        if (is_user_zombie(host))
        {
            if (is_user_zombie(ent))
            {
                set_es(es, ES_RenderMode, 4);
                set_es(es, ES_RenderAmt, 0);
            }
            else
            {
                static Color[3];
                new var2 = Color;
                var2[0] = 32388;
                set_es(es, ES_RenderFx, 19);
                set_es(es, ES_RenderMode, 0);
                set_es(es, ES_RenderColor, 32376);
                set_es(es, ES_RenderAmt, 16);
            }
        }
        if (is_user_zombie(ent))
        {
            set_es(es, ES_RenderMode, 4);
            set_es(es, ES_RenderAmt, 0);
        }
    }
    return 2;
}

public fw_CmdStart(id, uc_handle, seed)
{
    !!! Removed Phi
    if (!is_user_alive(id))
    {
        return 0;
    }
    if (!get_iEnt(id))
    {
        return 0;
    }
    if (!get_ready2(get_iEnt(id)))
    {
        return 0;
    }
    static iEnt;
    static CurButton;
    CurButton = get_uc(uc_handle, UC_Buttons);
    iEnt = get_iEnt(id);
    if (get_think(iEnt))
    {
        return 0;
    }
    if (CurButton & 1)
    {
        npc_attack(iEnt, get_anim(iEnt, random_num(0, 1)));
    }
    else
    {
        if (CurButton & 2048)
        {
            npc_attack(iEnt, get_anim(iEnt, 2));
        }
        if (CurButton & 32)
        {
            if (g_evolution[id][0][0])
            {
                npc_evolution(iEnt);
            }
        }
        if (CurButton & 2)
        {
            npc_jump(iEnt);
        }
        if (CurButton & 8)
        {
            static iButton;
            iButton = pev(id, pev_button);
            zg_reload[id] = 0;
            if (iButton & 512)
            {
                set_ready(iEnt, true);
                set_vectipe(iEnt, 1);
                return 0;
            }
            if (iButton & 1024)
            {
                set_ready(iEnt, true);
                set_vectipe(iEnt, 2);
                return 0;
            }
            set_ready(iEnt, true);
            set_vectipe(iEnt, 0);
        }
        if (CurButton & 16)
        {
            static iButton;
            iButton = pev(id, pev_button);
            zg_reload[id] = 0;
            if (iButton & 512)
            {
                set_ready(iEnt, true);
                set_vectipe(iEnt, 6);
                return 0;
            }
            if (iButton & 1024)
            {
                set_ready(iEnt, true);
                set_vectipe(iEnt, 7);
                return 0;
            }
            set_ready(iEnt, true);
            set_vectipe(iEnt, 5);
        }
        if (CurButton & 512)
        {
            zg_reload[id] = 0;
            set_ready(iEnt, true);
            set_vectipe(iEnt, 3);
        }
        if (CurButton & 1024)
        {
            zg_reload[id] = 0;
            set_ready(iEnt, true);
            set_vectipe(iEnt, 4);
        }
    }
    return 0;
}

public fw_Think(iEnt)
{
    !!! Removed Phi
    if (!is_valid_ent(iEnt))
    {
        return 1;
    }
    if (get_death(iEnt))
    {
        return 1;
    }
    static Float:CurTime;
    static Float:Origin[3];
    static id;
    id = get_owner(iEnt);
    CurTime = get_gametime();
    if (!id)
    {
        return 1;
    }
    set_pev(id, pev_maxspeed, 925353388);
    if (!fm_get_user_godmode(id))
    {
        fm_set_user_godmode(id, 1);
    }
    if (!get_ready2(iEnt))
    {
        pev(iEnt, pev_origin, Origin);
        new var3 = Origin[2];
        var3 = var3[0] + 120.00;
        set_pev(id, pev_origin, Origin);
        entity_set_float(iEnt, EV_FL_nextthink, get_gametime() + 0.01);
        if (CurTime >= pev(iEnt, pev_fuser1))
        {
            set_ready2(iEnt, true);
        }
        return 2;
    }
    if (!get_think(iEnt))
    {
        static Float:delay2;
        static Float:delay;
        if (get_ready(iEnt))
        {
            if (CurTime - 0.79 > delay)
            {
                if (get_class(iEnt))
                {
                    if (get_class(iEnt) == 1)
                    {
                        EmitSound(iEnt, sound_footstep[random_num(0, 1)][0][0], 5);
                    }
                    if (get_class(iEnt) == 2)
                    {
                        EmitSound(iEnt, sound_footstep[random_num(2, 3)][0][0], 5);
                    }
                }
                else
                {
                    EmitSound(iEnt, sound_footstep[random_num(0, 1)][0][0], 5);
                }
                new i = 0;
                while (get_maxplayers() > i)
                {
                    if (!(is_user_zombie(i)))
                    {
                        if (is_user_alive(i) && entity_range(iEnt, i) <= 600)
                        {
                            ScreenShake(i, 8, 6, 18);
                        }
                    }
                    i++;
                }
                delay = CurTime;
            }
            CurTime = get_gametime();
            if (get_vectipe(iEnt))
            {
                if (get_vectipe(iEnt) == 1)
                {
                    if (pev(iEnt, pev_sequence) != 2)
                    {
                        set_entity_anim(iEnt, 2);
                    }
                    get_position(id, 100.00, 0.00, 0.00, Origin, 0);
                    set_entity_angles2(iEnt, Origin, 20.00);
                    get_position(id, 100.00, -70.00, 0.00, Origin, 0);
                    static Float:Angles[3];
                    get_angles(iEnt, Origin, Angles);
                    set_velocity2(iEnt, Angles, entity_get_float(iEnt, EV_FL_speed), 1);
                }
                if (get_vectipe(iEnt) == 2)
                {
                    if (pev(iEnt, pev_sequence) != 4)
                    {
                        set_entity_anim(iEnt, 4);
                    }
                    get_position(id, 100.00, 0.00, 0.00, Origin, 0);
                    set_entity_angles2(iEnt, Origin, 20.00);
                    get_position(id, 100.00, 70.00, 0.00, Origin, 0);
                    static Float:Angles[3];
                    get_angles(iEnt, Origin, Angles);
                    set_velocity2(iEnt, Angles, entity_get_float(iEnt, EV_FL_speed), 1);
                }
                if (get_vectipe(iEnt) == 3)
                {
                    if (pev(iEnt, pev_sequence) != 5)
                    {
                        set_entity_anim(iEnt, 5);
                    }
                    get_position(id, 100.00, 0.00, 0.00, Origin, 0);
                    set_entity_angles2(iEnt, Origin, 20.00);
                    get_position(id, 0.00, -100.00, 0.00, Origin, 0);
                    static Float:Angles[3];
                    get_angles(iEnt, Origin, Angles);
                    set_velocity2(iEnt, Angles, entity_get_float(iEnt, EV_FL_speed), 1);
                }
                if (get_vectipe(iEnt) == 4)
                {
                    if (pev(iEnt, pev_sequence) != 6)
                    {
                        set_entity_anim(iEnt, 6);
                    }
                    get_position(id, 100.00, 0.00, 0.00, Origin, 0);
                    set_entity_angles2(iEnt, Origin, 20.00);
                    get_position(id, 0.00, 100.00, 0.00, Origin, 0);
                    static Float:Angles[3];
                    get_angles(iEnt, Origin, Angles);
                    set_velocity2(iEnt, Angles, entity_get_float(iEnt, EV_FL_speed), 1);
                }
                if (get_vectipe(iEnt) == 5)
                {
                    if (pev(iEnt, pev_sequence) != 8)
                    {
                        set_entity_anim(iEnt, 8);
                    }
                    get_position(id, 100.00, 0.00, 0.00, Origin, 0);
                    set_entity_angles2(iEnt, Origin, 20.00);
                    get_position(id, -100.00, 0.00, 0.00, Origin, 0);
                    static Float:Angles[3];
                    get_angles(iEnt, Origin, Angles);
                    set_velocity2(iEnt, Angles, entity_get_float(iEnt, EV_FL_speed), 1);
                }
                if (get_vectipe(iEnt) == 6)
                {
                    if (pev(iEnt, pev_sequence) != 7)
                    {
                        set_entity_anim(iEnt, 7);
                    }
                    get_position(id, 100.00, 0.00, 0.00, Origin, 0);
                    set_entity_angles2(iEnt, Origin, 20.00);
                    get_position(id, -100.00, -80.00, 0.00, Origin, 0);
                    static Float:Angles[3];
                    get_angles(iEnt, Origin, Angles);
                    set_velocity2(iEnt, Angles, entity_get_float(iEnt, EV_FL_speed), 1);
                }
                if (get_vectipe(iEnt) == 7)
                {
                    if (pev(iEnt, pev_sequence) != 9)
                    {
                        set_entity_anim(iEnt, 9);
                    }
                    get_position(id, 100.00, 0.00, 0.00, Origin, 0);
                    set_entity_angles2(iEnt, Origin, 20.00);
                    get_position(id, -100.00, 80.00, 0.00, Origin, 0);
                    static Float:Angles[3];
                    get_angles(iEnt, Origin, Angles);
                    set_velocity2(iEnt, Angles, entity_get_float(iEnt, EV_FL_speed), 1);
                }
            }
            else
            {
                if (pev(iEnt, pev_sequence) != 3)
                {
                    set_entity_anim(iEnt, 3);
                }
                get_position(id, 100.00, 0.00, 0.00, Origin, 0);
                set_entity_angles(iEnt, Origin, 20.00);
            }
            new var4 = zg_reload[id];
            var4 = var4[0][0] + 1;
            if (is_user_bot(id))
            {
                if (RELOAD_TIME_ZG + 5 <= zg_reload[id][0][0])
                {
                    zg_reload[id] = 0;
                    set_ready(iEnt, false);
                }
            }
            else
            {
                if (RELOAD_TIME_ZG <= zg_reload[id][0][0])
                {
                    zg_reload[id] = 0;
                    set_ready(iEnt, false);
                }
            }
        }
        else
        {
            if (pev(iEnt, pev_sequence) != 1)
            {
                set_entity_anim(iEnt, 1);
            }
            if (get_class(iEnt))
            {
                if (CurTime - 0.80 > delay2)
                {
                    if (get_class(iEnt))
                    {
                        if (get_class(iEnt) == 1)
                        {
                            EmitSound(iEnt, sound_revenant[4][0], 3);
                        }
                        if (get_class(iEnt) == 2)
                        {
                            EmitSound(iEnt, sound_titan[4][0], 3);
                        }
                    }
                    else
                    {
                        EmitSound(iEnt, sound_dione[4][0], 3);
                    }
                    delay2 = CurTime;
                }
            }
            else
            {
                if (CurTime - 5.00 > delay2)
                {
                    if (get_class(iEnt))
                    {
                        if (get_class(iEnt) == 1)
                        {
                            EmitSound(iEnt, sound_revenant[4][0], 3);
                        }
                        if (get_class(iEnt) == 2)
                        {
                            EmitSound(iEnt, sound_titan[4][0], 3);
                        }
                    }
                    else
                    {
                        EmitSound(iEnt, sound_dione[4][0], 3);
                    }
                    delay2 = CurTime;
                }
            }
            get_position(id, 100.00, 0.00, 0.00, Origin, 1);
            set_entity_angles2(iEnt, Origin, 20.00);
        }
        pev(iEnt, pev_origin, Origin);
        new var5 = Origin[2];
        var5 = var5[0] + 120.00;
        set_pev(id, pev_origin, Origin);
        if (get_user_weapon(id, 0, 0) != 29)
        {
            engclient_cmd(id, "weapon_knife", "", "");
        }
    }
    else
    {
        pev(iEnt, pev_origin, Origin);
        new var6 = Origin[2];
        var6 = var6[0] + 120.00;
        set_pev(id, pev_origin, Origin);
    }
    if (is_user_bot(id))
    {
        new i = 0;
        while (get_maxplayers() > i)
        {
            if (!(is_user_zombie(i)))
            {
                if (is_user_alive(i) && entity_range(iEnt, i) <= 220)
                {
                    npc_attack(iEnt, get_anim(iEnt, random_num(0, 1)));
                }
            }
            i++;
        }
    }
    entity_set_float(iEnt, EV_FL_nextthink, get_gametime());
    return 2;
}

public fw_TraceAttack(victim, attacker, Float:damage, Float:direction[3], tracehandle, damage_type)
{
    if (attacker == victim)
    {
        return 1;
    }
    if (!pev_valid(victim))
    {
        return 1;
    }
    if (!is_user_connected(attacker))
    {
        return 1;
    }
    if (!is_npc(victim))
    {
        return 1;
    }
    new Float:flEnd[3];
    new target = 0;
    new body = 0;
    get_tr2(tracehandle, TR_vecEndPos, flEnd);
    get_user_aiming(attacker, target, body, 9999);
    if (damage_type & 2)
    {
        switch (body)
        {
            case 1:
            {
                show_blood(flEnd, random_num(14, 15));
            }
            case 3:
            {
                show_blood(flEnd, 12);
            }
            case 4:
            {
                show_blood(flEnd, 10);
            }
            case 5:
            {
                show_blood(flEnd, 10);
            }
            case 6:
            {
                show_blood(flEnd, 10);
            }
            case 7:
            {
                show_blood(flEnd, 10);
            }
            default:
            {
                show_blood(flEnd, 10);
            }
        }
    }
    return 1;
}

public fw_TakeDamage(victim, inflictor, attacker, Float:damage, damage_type)
{
    !!! Removed Phi
    if (!is_user_alive(attacker) || !is_user_connected(attacker))
    {
        return 4;
    }
    if (attacker == victim)
    {
        return 1;
    }
    if (!pev_valid(victim) || !pev_valid(attacker))
    {
        return 1;
    }
    if (!is_npc(victim))
    {
        return 1;
    }
    new var3 = Heap_4;
    var3[0] = 32052;
    if (get_user_team(attacker, var3, 0) != get_team(victim))
    {
        cs_set_user_money_ul(attacker, floatround(damage, floatround_round) + cs_get_user_money_ul(attacker) + 50, "");
        SetHamParamFloat(4, damage);
        return 2;
    }
    return 4;
}

public fw_ZombiG_Killed(victim, attacker)
{
    if (!is_npc(victim))
    {
        return 1;
    }
    static owner;
    static Float:Angles[3];
    static Float:Origin[3];
    owner = get_owner(victim);
    create_ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
    new ent = create_ent;
    pev(victim, pev_origin, Origin);
    pev(victim, pev_angles, Angles);
    entity_set_origin(ent, Origin);
    entity_set_vector(ent, 6, Angles);
    entity_set_string(ent, 0, "zg_temp");
    entity_set_model(ent, Model_Zg[get_class(victim)][0][0]);
    entity_set_int(ent, EV_INT_solid, 0);
    entity_set_int(ent, EV_INT_movetype, 8);
    set_entity_anim(ent, get_anim(victim, 4));
    if (get_class(victim))
    {
        if (get_class(victim) == 1)
        {
            new var2 = sound_revenant;
            EmitSound(ent, var2[0][0][var2], 3);
        }
        if (get_class(victim) == 2)
        {
            new var3 = sound_titan;
            EmitSound(ent, var3[0][0][var3], 3);
        }
    }
    else
    {
        new var1 = sound_dione;
        EmitSound(ent, var1[0][0][var1], 3);
    }

/ * ERROR! Не удалось привести тип объекта "Lysis.DSentinel" к типу "Lysis.DReturn". * /
 function "fw_ZombiG_Killed"
public fw_ZombiG_Killed(victim, attacker)

public remove_task_ent(iEnt)
{
    if (task_exists(iEnt + 2, 0))
    {
        remove_task(iEnt + 2, 0);
    }
    if (task_exists(iEnt + 3, 0))
    {
        remove_task(iEnt + 3, 0);
    }
    if (task_exists(iEnt + 4, 0))
    {
        remove_task(iEnt + 4, 0);
    }
    if (task_exists(iEnt + 5, 0))
    {
        remove_task(iEnt + 5, 0);
    }
    if (task_exists(iEnt + 7, 0))
    {
        remove_task(iEnt + 7, 0);
    }
    return 0;
}

public Remove_NPC(ent)
{
    remove_entity(ent);
    return 0;
}

public no_speed(iEnt)
{
    !!! Removed Phi
    if (!is_valid_ent(iEnt) || get_think(iEnt))
    {
        return 0;
    }
    if (get_death(iEnt))
    {
        return 0;
    }
    static Float:Angles[3];
    pev(iEnt, pev_angles, Angles);
    set_velocity(iEnt, Angles, 0.00, 1);
    entity_set_vector(get_owner(iEnt), 2, 32756);
    return 0;
}

public npc_reload(iEnt, Float:Time)
{
    set_task(Time, "npc_reload_task", iEnt + 1, "", 0, "", 0);
    return 0;
}

public npc_reload_task(iEnt)
{
    new id = iEnt + -1;
    if (!pev_valid(id))
    {
        return 0;
    }
    set_think(id, false);
    return 0;
}

public npc_attack(iEnt, anim)
{
    !!! Removed Phi
    if (!get_ready2(iEnt))
    {
        return 0;
    }
    if (!is_valid_ent(iEnt) || get_think(iEnt))
    {
        return 0;
    }
    if (get_death(iEnt))
    {
        return 0;
    }
    no_speed(iEnt);
    set_think(iEnt, true);
    set_entity_anim(iEnt, anim);
    if (anim == 16)
    {
        if (get_class(iEnt))
        {
            if (get_class(iEnt) == 1)
            {
                npc__fireball2(iEnt);
            }
            effect_attack(iEnt, anim);
        }
        else
        {
            effect_attack2(iEnt);
        }
    }
    else
    {
        effect_attack(iEnt, anim);
    }
    if (get_class(iEnt) == 1)
    {
        if (anim == 16)
        {
            npc_reload(iEnt, 1.80);
        }
        else
        {
            set_task(0.20, "npc_attack_task", iEnt + 4, "", 0, "", 0);
        }
    }
    else
    {
        set_task(0.20, "npc_attack_task", iEnt + 4, "", 0, "", 0);
    }
    return 0;
}

public npc_attack_task(iEnt)
{
    iEnt += -4;
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    static Float:Origin[3];
    get_position(iEnt, 100.00, 0.00, 60.00, Origin, 0);
    CreateKnockBack(get_owner(iEnt), Origin, 220.00, 250.00, 100.00);
    static iButton;
    iButton = pev(get_owner(iEnt), pev_button);
    if (iButton & 1)
    {
        npc_reload(iEnt, 0.80);
        return 0;
    }
    if (iButton & 2048)
    {
        npc_reload(iEnt, 1.00);
        return 0;
    }
    npc_reload(iEnt, 1.50);
    return 0;
}

public effect_attack(iEnt, anim)
{
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    create_ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
    new ent = create_ent;
    static Float:Origin[3];
    static Float:Angles[3];
    pev(iEnt, pev_angles, Angles);
    entity_set_vector(ent, 6, Angles);
    get_position(iEnt, -100.00, 0.00, 0.00, Origin, 0);
    entity_set_origin(ent, Origin);
    entity_set_model(ent, Model_Attack[get_class(iEnt)][0][0]);
    entity_set_string(ent, 0, "zg_attack_effect");
    entity_set_int(ent, EV_INT_solid, 1);
    entity_set_int(ent, EV_INT_movetype, 0);
    if (anim == 14)
    {
        set_entity_anim(ent, 0);
        EmitSound(iEnt, sound_titan[10][0], 1);
    }
    else
    {
        if (anim == 15)
        {
            set_entity_anim(ent, 1);
            EmitSound(iEnt, sound_titan[11][0], 1);
        }
        if (anim == 16)
        {
            set_entity_anim(ent, 2);
            EmitSound(iEnt, sound_titan[12][0], 1);
        }
    }
    set_pev(ent, pev_light_level, 180);
    set_pev(ent, pev_rendermode, 5);
    set_pev(ent, pev_renderamt, 255.00/*1132396544*/);
    set_pev(ent, pev_fuser1, get_gametime() + 0.90);
    set_pev(ent, pev_nextthink, halflife_time());
    return 0;
}

public effect_attack2(iEnt)
{
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    create_ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
    new ent = create_ent;
    static Float:Origin[3];
    static Float:Angles[3];
    pev(iEnt, pev_angles, Angles);
    entity_set_vector(ent, 6, Angles);
    get_position(iEnt, 0.00, 0.00, -140.00, Origin, 0);
    entity_set_origin(ent, Origin);
    entity_set_model(ent, "models/zombiegiant/ef_swing.mdl");
    entity_set_string(ent, 0, "zg_attack_effect");
    entity_set_int(ent, EV_INT_solid, 1);
    entity_set_int(ent, EV_INT_movetype, 0);
    set_entity_anim(ent, 0);
    EmitSound(iEnt, sound_titan[10][0], 1);
    set_pev(ent, pev_light_level, 180);
    set_pev(ent, pev_rendermode, 5);
    set_pev(ent, pev_renderamt, 255.00/*1132396544*/);
    set_pev(ent, pev_fuser1, get_gametime() + 0.80);
    set_pev(ent, pev_nextthink, halflife_time());
    return 0;
}

public fw_Think_Effect(iEnt)
{
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    set_pev(iEnt, pev_nextthink, get_gametime() + 0.03);
    static Float:fTimeRemove;
    pev(iEnt, pev_fuser1, fTimeRemove);
    if (get_gametime() >= fTimeRemove - 0.60)
    {
        static Float:fade_out;
        pev(iEnt, pev_renderamt, fade_out);
        fade_out = fade_out - 15.00;
        fade_out = floatmax(fade_out, 0.00);
        set_pev(iEnt, pev_renderamt, fade_out);
    }
    if (get_gametime() >= fTimeRemove)
    {
        engfunc(EngFunc_RemoveEntity, iEnt);
    }
    return 0;
}

public npc_jump(iEnt)
{
    !!! Removed Phi
    if (!get_ready2(iEnt))
    {
        return 0;
    }
    if (!is_valid_ent(iEnt) || get_think(iEnt))
    {
        return 0;
    }
    if (get_death(iEnt))
    {
        return 0;
    }
    if (0 >= get_mana(iEnt) - 10)
    {
        return 0;
    }
    no_speed(iEnt);
    set_think(iEnt, true);
    static Float:Origin[3];
    static iButton;
    iButton = pev(get_owner(iEnt), pev_button);
    if (iButton & 512)
    {
        get_position(get_owner(iEnt), 100.00, 0.00, 0.00, Origin, 0);
        set_entity_angles2(iEnt, Origin, 10.00);
        get_position(get_owner(iEnt), 0.00, -100.00, 0.00, Origin, 0);
        static Float:Angles[3];
        get_angles(iEnt, Origin, Angles);
        set_velocity2(iEnt, Angles, 1300.00, 1);
        set_entity_anim(iEnt, 11);
    }
    else
    {
        if (iButton & 1024)
        {
            get_position(get_owner(iEnt), 100.00, 0.00, 0.00, Origin, 0);
            set_entity_angles2(iEnt, Origin, 10.00);
            get_position(get_owner(iEnt), 0.00, 100.00, 0.00, Origin, 0);
            static Float:Angles[3];
            get_angles(iEnt, Origin, Angles);
            set_velocity2(iEnt, Angles, 1300.00, 1);
            set_entity_anim(iEnt, 12);
        }
        if (iButton & 16)
        {
            get_position(get_owner(iEnt), 100.00, 0.00, 0.00, Origin, 0);
            set_entity_angles2(iEnt, Origin, 10.00);
            get_position(get_owner(iEnt), -100.00, 0.00, 0.00, Origin, 0);
            static Float:Angles[3];
            get_angles(iEnt, Origin, Angles);
            set_velocity2(iEnt, Angles, 1300.00, 1);
            set_entity_anim(iEnt, 13);
        }
        static Float:Angles[3];
        pev(iEnt, pev_angles, Angles);
        set_velocity(iEnt, Angles, 1300.00, 1);
        set_entity_anim(iEnt, 10);
    }
    set_mana(iEnt, get_mana(iEnt) - 10);
    EmitSound(iEnt, sound_titan[6][0], 1);
    set_task(0.10, "npc_jump_task", iEnt + 4, "", 0, "", 0);
    return 0;
}

public npc_jump_task(iEnt)
{
    iEnt += -4;
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    static Float:Origin[3];
    get_position(iEnt, 60.00, 0.00, 40.00, Origin, 0);
    CreateKnockBack(get_owner(iEnt), Origin, 130.00, 250.00, 100.00);
    set_task(0.50, "npc_jump_stop_task", iEnt + 4, "", 0, "", 0);
    return 0;
}

public npc_jump_stop_task(iEnt)
{
    iEnt += -4;
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    npc_reload(iEnt, 0.10);
    return 0;
}

public npc_dash(iEnt)
{
    !!! Removed Phi
    if (!get_ready2(iEnt))
    {
        return 0;
    }
    if (!is_valid_ent(iEnt) || get_think(iEnt))
    {
        return 0;
    }
    if (get_death(iEnt))
    {
        return 0;
    }
    if (0 >= get_mana(iEnt) - 8)
    {
        return 0;
    }
    set_mana(iEnt, get_mana(iEnt) - 8);
    no_speed(iEnt);
    set_think(iEnt, true);
    static Float:Angles[3];
    pev(iEnt, pev_angles, Angles);
    if (get_class(iEnt))
    {
        set_velocity(iEnt, Angles, 1600.00, 1);
    }
    else
    {
        set_velocity(iEnt, Angles, 2000.00, 1);
    }
    set_entity_anim(iEnt, get_anim(iEnt, 5));
    set_task(0.20, "npc_dash_loop", iEnt + 4, "", 0, "b", 0);
    if (get_class(iEnt))
    {
        set_task(1.60, "npc_dash_stop", iEnt + 5, "", 0, "", 0);
    }
    else
    {
        set_task(1.20, "npc_dash_stop", iEnt + 5, "", 0, "", 0);
    }
    return 0;
}

public npc_dash_loop(iEnt)
{
    iEnt += -4;
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    new var1;
    if (get_class(iEnt))
    {
        if (get_class(iEnt) == 1)
        {
            new var3 = sound_footstep;
            EmitSound(iEnt, var3[0][0][var3], 1);
            var1 = var3;
        }
        if (get_class(iEnt) == 2)
        {
            new var4 = sound_footstep[2];
            EmitSound(iEnt, var4[0], 1);
        }
        var1 = var4;
    }
    else
    {
        new var2 = sound_dione[7];
        EmitSound(iEnt, var2[0], 1);
        var1 = var2;
    }
    static Float:Origin[3];
    static Float:Angles[3];
    pev(iEnt, pev_angles, Angles);
    if (get_class(iEnt))
    {
        set_velocity(iEnt, Angles, 1500.00, 1);
    }
    else
    {
        set_velocity(iEnt, Angles, 2000.00, 1);
    }
    pev(iEnt, pev_origin, Origin);
    CreateKnockBack(get_owner(iEnt), Origin, 130.00, 300.00, 80.00);
    new var5 = Origin[2];
    var5 = var5[0] - 80.00;
    create_break(Origin, modelindex2[5][0], 20, 16, 20);
    return 0;
}

public npc_dash_stop(iEnt)
{
    iEnt += -5;
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    remove_task(iEnt + 4, 0);
    no_speed(iEnt);
    set_entity_anim(iEnt, get_anim(iEnt, 6));
    if (!(get_class(iEnt)))
    {
        EmitSound(iEnt, sound_dione[8][0], 1);
    }
    if (get_class(iEnt) == 1)
    {
        npc_reload(iEnt, 0.80);
    }
    else
    {
        npc_reload(iEnt, 1.60);
    }
    return 0;
}

public npc_evolution(iEnt)
{
    !!! Removed Phi
    if (!get_ready2(iEnt))
    {
        return 0;
    }
    if (!is_valid_ent(iEnt) || get_think(iEnt))
    {
        return 0;
    }
    if (get_death(iEnt))
    {
        return 0;
    }
    if (get_evolution(iEnt))
    {
        return 0;
    }
    no_speed(iEnt);
    set_think(iEnt, true);
    set_entity_anim(iEnt, get_anim(iEnt, 3));
    if (get_class(iEnt))
    {
        if (get_class(iEnt) == 1)
        {
            EmitSound(iEnt, sound_revenant[3][0], 3);
        }
        if (get_class(iEnt) == 2)
        {
            EmitSound(iEnt, sound_titan[3][0], 3);
        }
    }
    else
    {
        EmitSound(iEnt, sound_dione[3][0], 3);
    }
    set_task(1.10, "npc_evolution_task", iEnt + 4, "", 0, "", 0);
    return 0;
}

public npc_evolution_task(iEnt)
{
    iEnt += -4;
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    static Float:Origin[3];
    pev(iEnt, pev_origin, Origin);
    new var1 = Origin[2];
    var1 = var1[0] + 40.00;
    create_effect(Origin, modelindex2[0][0], 30, 10, 14);
    create_break(Origin, modelindex2[1][0], 20, 16, 20);
    effect_evolution(iEnt);
    set_evolution(iEnt, true);
    npc_reload(iEnt, 1.00);
    return 0;
}

public effect_evolution(iEnt)
{
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    create_ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
    new ent = create_ent;
    static Float:Origin[3];
    pev(iEnt, pev_origin, Origin);
    new var1 = Origin[2];
    var1 = var1[0] - 100.00;
    entity_set_origin(ent, Origin);
    entity_set_model(ent, "models/zombiegiant/ef_skill4_a.mdl");
    entity_set_string(ent, 0, "zg_attack_effect");
    entity_set_int(ent, EV_INT_solid, 1);
    entity_set_int(ent, EV_INT_movetype, 0);
    set_entity_anim(ent, 0);
    set_pev(ent, pev_light_level, 180);
    set_pev(ent, pev_rendermode, 5);
    set_pev(ent, pev_renderamt, 255.00/*1132396544*/);
    set_pev(ent, pev_fuser1, get_gametime() + 0.80);
    set_pev(ent, pev_nextthink, halflife_time());
    return 0;
}

public skill_1(id)
{
    if (get_iEnt(id))
    {
        if (get_class(get_iEnt(id)))
        {
            if (get_class(get_iEnt(id)) == 1)
            {
                npc_dash(get_iEnt(id));
            }
            if (get_class(get_iEnt(id)) == 2)
            {
                npc_dash(get_iEnt(id));
            }
        }
        else
        {
            npc_dash(get_iEnt(id));
        }
        return 1;
    }
    return 0;
}

public skill_2(id)
{
    if (get_iEnt(id))
    {
        if (get_class(get_iEnt(id)))
        {
            if (get_class(get_iEnt(id)) == 1)
            {
                npc_fireball_b(get_iEnt(id));
            }
            if (get_class(get_iEnt(id)) == 2)
            {
                npc_rocket(get_iEnt(id));
            }
        }
        else
        {
            npc_tentacle(get_iEnt(id));
        }
        return 1;
    }
    return 0;
}

public skill_3(id)
{
    if (get_iEnt(id))
    {
        if (get_class(get_iEnt(id)))
        {
            if (get_class(get_iEnt(id)) == 1)
            {
                npc_inferno(get_iEnt(id));
            }
            if (get_class(get_iEnt(id)) == 2)
            {
                npc_mine(get_iEnt(id));
            }
        }
        else
        {
            npc_poison(get_iEnt(id));
        }
        return 1;
    }
    return 0;
}

public npc_tentacle(iEnt)
{
    !!! Removed Phi
    if (!get_ready2(iEnt))
    {
        return 0;
    }
    if (!is_valid_ent(iEnt) || get_think(iEnt))
    {
        return 0;
    }
    if (get_death(iEnt))
    {
        return 0;
    }
    if (0 >= get_mana(iEnt) - 18)
    {
        return 0;
    }
    set_mana(iEnt, get_mana(iEnt) - 18);
    no_speed(iEnt);
    set_think(iEnt, true);
    set_entity_anim(iEnt, 19);
    EmitSound(iEnt, sound_dione[9][0], 1);
    set_task(1.00, "npc_tentacle_stop", iEnt + 4, "", 0, "", 0);
    return 0;
}

public npc_tentacle_stop(iEnt)
{
    !!! Removed Phi
    iEnt += -4;
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    new i = 0;
    new Float:Origin[3];
    get_position(iEnt, 100.00, 0.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 150.00, 0.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 200.00, 0.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 250.00, 0.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 300.00, 0.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 350.00, 0.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 400.00, 0.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 450.00, 0.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 500.00, 0.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 550.00, 0.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 100.00, -50.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 150.00, -100.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 200.00, -150.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 250.00, -200.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 300.00, -250.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 350.00, -300.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 400.00, -350.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 450.00, -400.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 500.00, -450.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 100.00, 50.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 150.00, 100.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 200.00, 150.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 250.00, 200.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 300.00, 250.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 350.00, 300.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 400.00, 350.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 450.00, 400.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    get_position(iEnt, 500.00, 450.00, 0.00, Origin, 0);
    npc__tentacle(iEnt, Origin);
    i = 0;
    while (get_maxplayers() > i)
    {
        if (is_user_connected(i))
        {
            if (!is_user_alive(i))
            {
            }
            else
            {
                if (is_user_zombie(i))
                {
                }
                else
                {
                    if (entity_range(iEnt, i) <= 1000)
                    {
                        pev(i, pev_origin, Origin);
                        npc__tentacle(iEnt, Origin);
                    }
                }
            }
        }
        i++;
    }
    npc_reload(iEnt, 1.00);
    return 0;
}

public npc__tentacle(iEnt, Float:Origin[3])
{
    create_ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
    new ent = create_ent;
    set_pev(ent, pev_classname, "zg_tentacle");
    engfunc(EngFunc_SetModel, ent, "models/zombiegiant/ef_dione_tentacle.mdl");
    set_pev(ent, pev_origin, Origin);
    set_pev(ent, pev_solid, 1);
    set_pev(ent, pev_movetype, 0);
    set_pev(ent, pev_owner, get_owner(iEnt));
    set_pev(ent, pev_iuser1, 200);
    entity_set_size(ent, 34500, 34512);
    fm_set_rendering(ent, 0, 0, 0, 0, 5, 200);
    set_entity_anim(ent, 0);
    set_task(random_float(0.50, 1.00), "npc__tentacle2", ent + 4, "", 0, "", 0);
    set_pev(ent, pev_nextthink, halflife_time() + 4.00);
    engfunc(EngFunc_DropToFloor, ent);
    return 0;
}

public npc__tentacle2(iEnt)
{
    iEnt += -4;
    static Float:Origin[3];
    create_ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
    new ent = create_ent;
    set_pev(ent, pev_classname, "zg_tentacle2");
    engfunc(EngFunc_SetModel, ent, "models/zombiegiant/dione_tentacle.mdl");
    pev(iEnt, pev_origin, Origin);
    set_pev(ent, pev_origin, Origin);
    set_pev(ent, pev_solid, 1);
    set_pev(ent, pev_movetype, 0);
    entity_set_size(ent, 34848, 34860);
    set_entity_anim(ent, 0);
    set_pev(ent, pev_nextthink, halflife_time() + 3.00);
    new var1 = Origin[2];
    var1 = var1[0] - 40.00;
    CreateKnockBack(get_owner(iEnt), Origin, 60.00, 300.00, 40.00);
    return 0;
}

public fw_Think_Tentacle(ent)
{
    if (!pev_valid(ent))
    {
        return 0;
    }
    static Render;
    Render = pev(ent, pev_iuser1);
    Render = Render + -4;
    fm_set_rendering(ent, 0, 0, 0, 0, 5, Render);
    set_pev(ent, pev_iuser1, Render);
    set_pev(ent, pev_nextthink, get_gametime() + 0.03);
    if (!Render)
    {
        engfunc(EngFunc_RemoveEntity, ent);
    }
    return 0;
}

public fw_Think_Tentacle2(ent)
{
    if (!pev_valid(ent))
    {
        return 0;
    }
    engfunc(EngFunc_RemoveEntity, ent);
    return 0;
}

public npc_poison(iEnt)
{
    !!! Removed Phi
    if (!get_ready2(iEnt))
    {
        return 0;
    }
    if (!is_valid_ent(iEnt) || get_think(iEnt))
    {
        return 0;
    }
    if (get_death(iEnt))
    {
        return 0;
    }
    if (0 >= get_mana(iEnt) - 18)
    {
        return 0;
    }
    set_mana(iEnt, get_mana(iEnt) - 18);
    no_speed(iEnt);
    set_think(iEnt, true);
    set_entity_anim(iEnt, 20);
    EmitSound(iEnt, sound_titan[13][0], 1);
    set_task(0.90, "npc_poison_stop", iEnt + 4, "", 0, "", 0);
    return 0;
}

public npc_poison_stop(iEnt)
{
    iEnt += -4;
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    static Float:StartOrigin[3];
    get_position(iEnt, 300.00, 0.00, 60.00, StartOrigin, 0);
    create_effect(StartOrigin, modelindex2[6][0], 15, 46, 14);
    npc__poison(iEnt, StartOrigin);
    npc__poison(iEnt, StartOrigin);
    npc__poison(iEnt, StartOrigin);
    npc__poison(iEnt, StartOrigin);
    npc__poison(iEnt, StartOrigin);
    npc_reload(iEnt, 1.10);
    return 0;
}

public npc__poison(iEnt, Float:StartOrigin[3])
{
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    create_ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
    new ent = create_ent;
    entity_set_string(ent, 0, "zg_poison");
    engfunc(EngFunc_SetModel, ent, "models/zombiegiant/dione_poison.mdl");
    set_pev(ent, pev_origin, StartOrigin);
    set_pev(ent, pev_solid, 1);
    set_pev(ent, pev_movetype, 6);
    set_pev(ent, pev_owner, get_owner(iEnt));
    set_pev(ent, pev_gravity, 0.40/*1053609165*/);
    set_pev(ent, pev_mins, "");
    set_pev(ent, pev_maxs, "");
    entity_set_float(ent, EV_FL_nextthink, halflife_time());
    static Float:Origin[3];
    static Float:Velocity[3];
    fm_get_aim_origin(get_owner(iEnt), Origin);
    new var1 = Origin;
    var1[0] = var1[0][0] + random_float(-130.00, 130.00);
    new var2 = Origin[1];
    var2 = var2[0] + random_float(-130.00, 130.00);
    new var3 = Origin[2];
    var3 = var3[0] + random_float(-90.00, 110.00);
    get_speed_vector(StartOrigin, Origin, 2000.00, Velocity);
    set_pev(ent, pev_velocity, Velocity);
    static Float:Angles[3];
    static Float:Ent_Origin[3];
    pev(ent, pev_origin, Ent_Origin);
    Ent_Origin[0] = Origin[0][0] - Ent_Origin[0][0];
    Ent_Origin[1] = Origin[1][0] - Ent_Origin[1][0];
    Ent_Origin[2] = Origin[2][0] - Ent_Origin[2][0];
    engfunc(EngFunc_VecToAngles, Ent_Origin, Angles);
    set_pev(ent, pev_angles, Angles);
    return 0;
}

public npc__poison2(iEnt, Float:StartOrigin[3])
{
    StartOrigin[2] += 5.00;
    create_ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
    new ent = create_ent;
    entity_set_string(ent, 0, "zg_poison2");
    engfunc(EngFunc_SetModel, ent, "models/zombiegiant/ef_poisonground.mdl");
    set_pev(ent, pev_origin, StartOrigin);
    set_pev(ent, pev_solid, 1);
    set_pev(ent, pev_movetype, 6);
    set_pev(ent, pev_rendermode, 4);
    set_pev(ent, pev_renderamt, 255.00/*1132396544*/);
    set_pev(ent, pev_owner, get_owner(iEnt));
    set_pev(ent, pev_gravity, 0.80/*1061997773*/);
    static Float:Angles[3];
    pev(iEnt, pev_angles, Angles);
    Angles[2] = 0;
    Angles[0] = 0;
    set_pev(ent, pev_angles, Angles);
    set_entity_anim(ent, 0);
    set_pev(ent, pev_mins, "");
    set_pev(ent, pev_maxs, "");
    set_pev(ent, pev_fuser1, get_gametime() + 4.00);
    entity_set_float(ent, EV_FL_nextthink, halflife_time());
    return 0;
}

public fw_Think_Poison(ent)
{
    if (!pev_valid(ent))
    {
        return 0;
    }
    static Float:Origin[3];
    pev(ent, pev_origin, Origin);
    CreateKnockBack(get_owner(ent), Origin, 60.00, 0.10, 60.00);
    new var1 = Origin[2];
    var1 = var1[0] + 10.00;
    set_origin_random(Origin, 80.00, 80.00, 80.00, 80.00, 0.10, 2.00);
    create_effect(Origin, modelindex2[6][0], random_num(8, 12), 24, 14);
    set_pev(ent, pev_nextthink, get_gametime() + 1.00);
    static Float:fTimeRemove;
    pev(ent, pev_fuser1, fTimeRemove);
    if (get_gametime() >= fTimeRemove)
    {
        engfunc(EngFunc_RemoveEntity, ent);
    }
    return 0;
}

public fw_Touch_Poison(ent, id)
{
    if (!pev_valid(ent))
    {
        return 0;
    }
    static classname[32];
    pev(id, pev_classname, classname, 31);
    if (equali("", "zg_poison", 0))
    {
        return 0;
    }
    new Float:Origin[3];
    pev(ent, pev_origin, Origin);
    CreateKnockBack(get_owner(ent), Origin, 90.00, 0.00, 60.00);
    npc__poison2(ent, Origin);
    Origin[2] += 10.00;
    create_effect(Origin, modelindex2[6][0], random_num(15, 20), 20, 14);
    Origin[2] += 25.00;
    create_effect(Origin, modelindex2[7][0], random_num(18, 24), 20, 14);
    remove_entity(ent);
    return 0;
}

public npc__fireball2(iEnt)
{
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    EmitSound(iEnt, sound_revenant[12][0], 1);
    static Float:StartOrigin[3];
    get_position(iEnt, 80.00, 50.00, 200.00, StartOrigin, 0);
    create_ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
    new ent = create_ent;
    entity_set_string(ent, 0, "zg_fireball2");
    engfunc(EngFunc_SetModel, ent, "models/zombiegiant/revenant_fireball.mdl");
    set_pev(ent, pev_origin, StartOrigin);
    set_pev(ent, pev_solid, 1);
    set_pev(ent, pev_movetype, 6);
    set_pev(ent, pev_light_level, 180);
    set_pev(ent, pev_rendermode, 5);
    set_pev(ent, pev_renderamt, 0.20/*1045220557*/);
    set_pev(ent, pev_owner, get_owner(iEnt));
    set_pev(ent, pev_iuser1, iEnt);
    set_pev(ent, pev_iuser4, 0);
    set_entity_anim(ent, 0);
    set_pev(ent, pev_mins, "");
    set_pev(ent, pev_maxs, "");
    entity_set_float(ent, EV_FL_nextthink, halflife_time());
    static Float:Origin[3];
    static Float:Velocity[3];
    fm_get_aim_origin(get_owner(iEnt), Origin);
    new var1 = Origin;
    var1[0] = var1[0][0] + random_float(-40.00, 40.00);
    new var2 = Origin[1];
    var2 = var2[0] + random_float(-40.00, 40.00);
    new var3 = Origin[2];
    var3 = var3[0] + random_float(-40.00, 40.00);
    get_speed_vector(StartOrigin, Origin, 2200.00, Velocity);
    set_pev(ent, pev_velocity, Velocity);
    static Float:Angles[3];
    static Float:Ent_Origin[3];
    pev(ent, pev_origin, Ent_Origin);
    Ent_Origin[0] = Origin[0][0] - Ent_Origin[0][0];
    Ent_Origin[1] = Origin[1][0] - Ent_Origin[1][0];
    Ent_Origin[2] = Origin[2][0] - Ent_Origin[2][0];
    engfunc(EngFunc_VecToAngles, Ent_Origin, Angles);
    set_pev(ent, pev_angles, Angles);
    return 0;
}

public fw_Think_FireBall2(ent)
{
    if (!pev_valid(ent))
    {
        return 0;
    }
    if (!pev_valid(get_owner2(ent)))
    {
        new Float:Origin[3];
        pev(ent, pev_origin, Origin);
        CreateKnockBack(get_owner(ent), Origin, 90.00, 0.00, 60.00);
        Origin[2] += 35.00;
        create_effect(Origin, modelindex2[4][0], 24, 30, 2);
        remove_entity(ent);
        return 0;
    }
    set_pev(ent, pev_nextthink, get_gametime());
    static Float:Render;
    pev(ent, pev_renderamt, Render);
    Render = Render + 10.00;
    if (Render <= 0.00)
    {
        set_pev(ent, pev_renderamt, Render);
    }
    return 0;
}

public fw_Touch_FireBall2(ent, id)
{
    if (!pev_valid(ent))
    {
        return 0;
    }
    if (get_block(ent))
    {
        return 0;
    }
    if (get_owner(ent) == id)
    {
        return 0;
    }
    if (get_owner2(ent) == id)
    {
        return 0;
    }
    new Float:Origin[3];
    pev(ent, pev_origin, Origin);
    CreateKnockBack(get_owner(ent), Origin, 90.00, 0.00, 50.00);
    Origin[2] += 35.00;
    create_effect(Origin, modelindex2[4][0], 24, 30, 2);
    remove_entity(ent);
    return 0;
}

public npc_fireball_b(iEnt)
{
    !!! Removed Phi
    if (!get_ready2(iEnt))
    {
        return 0;
    }
    if (!is_valid_ent(iEnt) || get_think(iEnt))
    {
        return 0;
    }
    if (get_death(iEnt))
    {
        return 0;
    }
    if (0 >= get_mana(iEnt) - 18)
    {
        return 0;
    }
    set_mana(iEnt, get_mana(iEnt) - 18);
    no_speed(iEnt);
    set_think(iEnt, true);
    set_entity_anim(iEnt, 19);
    npc__fireball(iEnt, 0);
    npc__fireball(iEnt, 1);
    EmitSound(iEnt, sound_revenant[7][0], 1);
    npc_reload(iEnt, 2.00);
    return 0;
}

public npc__fireball(iEnt, hand)
{
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    static Float:StartOrigin[3];
    create_ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
    new ent = create_ent;
    entity_set_string(ent, 0, "zg_fireball");
    engfunc(EngFunc_SetModel, ent, "models/zombiegiant/revenant_fireball.mdl");
    if (hand)
    {
        get_position(iEnt, 80.00, -90.00, 50.00, StartOrigin, 0);
    }
    else
    {
        get_position(iEnt, 80.00, 90.00, 50.00, StartOrigin, 0);
    }
    set_pev(ent, pev_origin, StartOrigin);
    set_pev(ent, pev_solid, 1);
    set_pev(ent, pev_movetype, 5);
    set_pev(ent, pev_light_level, 180);
    set_pev(ent, pev_rendermode, 5);
    set_pev(ent, pev_renderamt, 0);
    set_pev(ent, pev_owner, get_owner(iEnt));
    set_pev(ent, pev_iuser1, iEnt);
    set_pev(ent, pev_iuser2, hand);
    set_pev(ent, pev_iuser3, 0);
    set_pev(ent, pev_iuser4, 1);
    set_pev(ent, pev_gravity, 0.01/*1008981770*/);
    set_entity_anim(ent, 0);
    set_pev(ent, pev_mins, "");
    set_pev(ent, pev_maxs, "");
    entity_set_float(ent, EV_FL_nextthink, halflife_time());
    return 0;
}

public fw_Think_FireBall(ent)
{
    !!! Removed Phi
    if (!pev_valid(ent))
    {
        return 0;
    }
    if (!pev_valid(get_owner2(ent)))
    {
        new Float:Origin[3];
        pev(ent, pev_origin, Origin);
        CreateKnockBack(get_owner(ent), Origin, 90.00, 0.00, 60.00);
        Origin[2] += 35.00;
        create_effect(Origin, modelindex2[4][0], 24, 30, 2);
        remove_entity(ent);
        return 0;
    }
    static Stop;
    static Num;
    static Float:StartOrigin[3];
    Num = pev(ent, pev_iuser3);
    Num = Num + 6;
    if (get_hand(ent))
    {
        if (Num <= 70)
        {
            get_position(get_owner2(ent), float(Num) / 6.00 + 80.00, -90.00, float(Num) / 6.00 + 50.00, StartOrigin, 0);
        }
        else
        {
            get_position(get_owner2(ent), float(Num) + float(Num) / 6.00 + 80.00, -90.00, float(Num) / 2.00 + 50.00, StartOrigin, 0);
        }
    }
    else
    {
        if (Num <= 70)
        {
            get_position(get_owner2(ent), float(Num) / 6.00 + 80.00, 90.00, float(Num) / 6.00 + 50.00, StartOrigin, 0);
        }
        get_position(get_owner2(ent), float(Num) + float(Num) / 6.00 + 80.00, 90.00, float(Num) / 2.00 + 50.00, StartOrigin, 0);
    }
    set_pev(ent, pev_iuser3, Num);
    set_pev(ent, pev_origin, StartOrigin);
    if (!get_hand(ent))
    {
        Stop = 190;
    }
    else
    {
        Stop = 140;
    }
    if (Num >= Stop)
    {
        static Float:Origin[3];
        static Float:Velocity[3];
        fm_get_aim_origin(get_owner(ent), Origin);
        new var1 = Origin;
        var1[0] = var1[0][0] + random_float(-60.00, 60.00);
        new var2 = Origin[1];
        var2 = var2[0] + random_float(-60.00, 60.00);
        new var3 = Origin[2];
        var3 = var3[0] + random_float(-70.00, 60.00);
        get_speed_vector(StartOrigin, Origin, 2200.00, Velocity);
        set_pev(ent, pev_velocity, Velocity);
        static Float:Angles[3];
        static Float:Ent_Origin[3];
        pev(ent, pev_origin, Ent_Origin);
        Ent_Origin[0] = Origin[0][0] - Ent_Origin[0][0];
        Ent_Origin[1] = Origin[1][0] - Ent_Origin[1][0];
        Ent_Origin[2] = Origin[2][0] - Ent_Origin[2][0];
        engfunc(EngFunc_VecToAngles, Ent_Origin, Angles);
        set_pev(ent, pev_angles, Angles);
        set_pev(ent, pev_iuser4, 0);
        return 0;
    }
    set_pev(ent, pev_nextthink, get_gametime());
    static Float:Render;
    pev(ent, pev_renderamt, Render);
    Render = Render + 6.00;
    if (Render <= 0.00)
    {
        set_pev(ent, pev_renderamt, Render);
    }
    return 0;
}

public fw_Touch_FireBall(ent, id)
{
    if (!pev_valid(ent))
    {
        return 0;
    }
    if (get_block(ent))
    {
        return 0;
    }
    if (get_owner(ent) == id)
    {
        return 0;
    }
    if (get_owner2(ent) == id)
    {
        return 0;
    }
    new Float:Origin[3];
    pev(ent, pev_origin, Origin);
    CreateKnockBack(get_owner(ent), Origin, 90.00, 0.00, 60.00);
    Origin[2] += 35.00;
    create_effect(Origin, modelindex2[4][0], 24, 30, 2);
    remove_entity(ent);
    return 0;
}

public npc_inferno(iEnt)
{
    !!! Removed Phi
    if (!get_ready2(iEnt))
    {
        return 0;
    }
    if (!is_valid_ent(iEnt) || get_think(iEnt))
    {
        return 0;
    }
    if (get_death(iEnt))
    {
        return 0;
    }
    if (0 >= get_mana(iEnt) - 24)
    {
        return 0;
    }
    set_mana(iEnt, get_mana(iEnt) - 24);
    no_speed(iEnt);
    set_think(iEnt, true);
    set_entity_anim(iEnt, 20);
    EmitSound(iEnt, sound_revenant[8][0], 1);
    set_task(0.50, "npc_inferno_loop", iEnt + 4, "", 0, "", 0);
    npc_reload(iEnt, 1.60);
    return 0;
}

public npc_inferno_loop(iEnt)
{
    iEnt += -4;
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    static Float:Origin[3];
    get_position(iEnt, 100.00, 0.00, 20.00, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, -100.00, 0.00, 20.00, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, 0.00, 100.00, 20.00, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, 0.00, -100.00, 20.00, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 10);
    get_position(iEnt, 80.00, -50.00, 20.00, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, -80.00, 50.00, 20.00, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, 80.00, 50.00, 20.00, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, -80.00, -50.00, 20.00, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 10);
    CreateKnockBack(get_owner(iEnt), Origin, 200.00, 300.00, 50.00);
    set_task(0.20, "npc_inferno_loop2", iEnt + 4, "", 0, "", 0);
    return 0;
}

public npc_inferno_loop2(iEnt)
{
    iEnt += -4;
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    static Float:Up;
    static Float:Radio;
    static Float:Origin[3];
    Radio = 70.00/*1116471296*/;
    Up = 30.00/*1106247680*/;
    get_position(iEnt, Radio + 100.00, 0.00, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, -100.00 - Radio, 0.00, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, 0.00, Radio + 100.00, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, 0.00, -100.00 - Radio, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 10);
    get_position(iEnt, Radio + 80.00, -50.00 - Radio, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, -80.00 - Radio, Radio + 50.00, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, Radio + 80.00, Radio + 50.00, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, -80.00 - Radio, -50.00 - Radio, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 10);
    CreateKnockBack(get_owner(iEnt), Origin, 300.00, 300.00, 50.00);
    set_task(0.20, "npc_inferno_loop3", iEnt + 4, "", 0, "", 0);
    return 0;
}

public npc_inferno_loop3(iEnt)
{
    iEnt += -4;
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    static Float:Up;
    static Float:Radio;
    static Float:Origin[3];
    Radio = 140.00/*1124859904*/;
    Up = 30.00/*1106247680*/;
    get_position(iEnt, Radio + 100.00, 0.00, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, -100.00 - Radio, 0.00, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, 0.00, Radio + 100.00, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, 0.00, -100.00 - Radio, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 10);
    get_position(iEnt, Radio + 80.00, -50.00 - Radio, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, -80.00 - Radio, Radio + 50.00, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, Radio + 80.00, Radio + 50.00, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, -80.00 - Radio, -50.00 - Radio, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 10);
    CreateKnockBack(get_owner(iEnt), Origin, 400.00, 300.00, 50.00);
    set_task(0.20, "npc_inferno_loop4", iEnt + 4, "", 0, "", 0);
    return 0;
}

public npc_inferno_loop4(iEnt)
{
    iEnt += -4;
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    static Float:Up;
    static Float:Radio;
    static Float:Origin[3];
    Radio = 160.00/*1126170624*/;
    Up = 60.00/*1114636288*/;
    get_position(iEnt, Radio + 100.00, 0.00, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, -100.00 - Radio, 0.00, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, 0.00, Radio + 100.00, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, 0.00, -100.00 - Radio, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 10);
    get_position(iEnt, Radio + 80.00, -50.00 - Radio, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, -80.00 - Radio, Radio + 50.00, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, Radio + 80.00, Radio + 50.00, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 14);
    get_position(iEnt, -80.00 - Radio, -50.00 - Radio, Up, Origin, 0);
    create_effect(Origin, modelindex2[4][0], 20, 30, 10);
    CreateKnockBack(get_owner(iEnt), Origin, 500.00, 300.00, 50.00);
    return 0;
}

public npc_rocket(iEnt)
{
    !!! Removed Phi
    if (!get_ready2(iEnt))
    {
        return 0;
    }
    if (!is_valid_ent(iEnt) || get_think(iEnt))
    {
        return 0;
    }
    if (get_death(iEnt))
    {
        return 0;
    }
    if (0 >= get_mana(iEnt) - 18)
    {
        return 0;
    }
    set_mana(iEnt, get_mana(iEnt) - 18);
    no_speed(iEnt);
    set_think(iEnt, true);
    set_entity_anim(iEnt, 19);
    EmitSound(iEnt, sound_titan[9][0], 1);
    set_task(0.30, "npc_loop_rocket", iEnt + 6, "", 0, "b", 0);
    set_task(4.00, "npc_rocket_stop", iEnt + 7, "", 0, "", 0);
    return 0;
}

public npc_rocket_stop(iEnt)
{
    iEnt += -7;
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    remove_task(iEnt + 6, 0);
    set_entity_anim(iEnt, 21);
    npc_reload(iEnt, 1.00);
    return 0;
}

public npc_loop_rocket(iEnt)
{
    iEnt += -6;
    if (!is_valid_ent(iEnt))
    {
        return 0;
    }
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    if (get_death(iEnt))
    {
        return 0;
    }
    set_entity_anim(iEnt, 20);
    EmitSound(iEnt, sound_titan[10][0], 1);
    static Float:StartOrigin[3];
    get_position(iEnt, 100.00, -40.00, 80.00, StartOrigin, 0);
    create_effect(StartOrigin, modelindex2[3][0], 20, 46, 14);
    get_position(iEnt, 140.00, -40.00, 80.00, StartOrigin, 0);
    create_ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
    new ent = create_ent;
    entity_set_string(ent, 0, "zg_granade");
    engfunc(EngFunc_SetModel, ent, "models/zombiegiant/titan_grenade.mdl");
    set_pev(ent, pev_origin, StartOrigin);
    set_pev(ent, pev_solid, 2);
    set_pev(ent, pev_movetype, 6);
    set_pev(ent, pev_owner, get_owner(iEnt));
    set_pev(ent, pev_gravity, 0.01/*1008981770*/);
    set_pev(ent, pev_mins, "");
    set_pev(ent, pev_maxs, "");
    entity_set_float(ent, EV_FL_nextthink, halflife_time());
    static Float:Origin[3];
    static Float:Velocity[3];
    fm_get_aim_origin(get_owner(iEnt), Origin);
    new var1 = Origin;
    var1[0] = var1[0][0] + random_float(-60.00, 60.00);
    new var2 = Origin[1];
    var2 = var2[0] + random_float(-60.00, 60.00);
    new var3 = Origin[2];
    var3 = var3[0] + random_float(-70.00, 60.00);
    get_speed_vector(StartOrigin, Origin, 2200.00, Velocity);
    set_pev(ent, pev_velocity, Velocity);
    static Float:Angles[3];
    static Float:Ent_Origin[3];
    pev(ent, pev_origin, Ent_Origin);
    Ent_Origin[0] = Origin[0][0] - Ent_Origin[0][0];
    Ent_Origin[1] = Origin[1][0] - Ent_Origin[1][0];
    Ent_Origin[2] = Origin[2][0] - Ent_Origin[2][0];
    engfunc(EngFunc_VecToAngles, Ent_Origin, Angles);
    set_pev(ent, pev_angles, Angles);
    return 0;
}

public fw_Think_Rocket(ent)
{
    if (!pev_valid(ent))
    {
        return 0;
    }
    static Float:Origin[3];
    pev(ent, pev_origin, Origin);
    new var1 = Origin[2];
    var1 = var1[0] - 10.00;
    set_origin_random(Origin, 6.00, 6.00, 6.00, 6.00, 2.00, 2.00);
    create_effect(Origin, modelindex2[2][0], 10, 46, 14);
    set_pev(ent, pev_nextthink, get_gametime() + 0.20);
    return 0;
}

public fw_Touch_Rocket(ent, id)
{
    if (!pev_valid(ent))
    {
        return 0;
    }
    new Float:Origin[3];
    pev(ent, pev_origin, Origin);
    CreateKnockBack(get_owner(ent), Origin, 80.00, 0.00, 60.00);
    Origin[2] += 35.00;
    create_effect(Origin, modelindex2[4][0], 24, 30, 2);
    remove_entity(ent);
    return 0;
}

public npc_mine(iEnt)
{
    !!! Removed Phi
    if (!get_ready2(iEnt))
    {
        return 0;
    }
    if (!is_valid_ent(iEnt) || get_think(iEnt))
    {
        return 0;
    }
    if (get_death(iEnt))
    {
        return 0;
    }
    if (0 >= get_mana(iEnt) - 24)
    {
        return 0;
    }
    set_mana(iEnt, get_mana(iEnt) - 24);
    no_speed(iEnt);
    set_think(iEnt, true);
    set_entity_anim(iEnt, 22);
    EmitSound(iEnt, sound_titan[11][0], 1);
    set_task(1.00, "npc_mine_task", iEnt + 4, "", 0, "", 0);
    return 0;
}

public npc_mine_task(iEnt)
{
    iEnt += -4;
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    static Float:Origin[3];
    get_position(iEnt, 0.00, 0.00, 180.00, Origin, 0);
    create_mine(iEnt, Origin, 4.00);
    new var1 = Origin[2];
    var1 = var1[0] + 10.00;
    create_mine(iEnt, Origin, 5.00);
    new var2 = Origin[2];
    var2 = var2[0] + 10.00;
    create_mine(iEnt, Origin, 8.00);
    npc_reload(iEnt, 2.50);
    return 0;
}

public create_mine(iEnt, Float:Origin[3], Float:Gravity)
{
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    static Float:EndOrigin[3];
    static Float:StartOrigin[3];
    static Float:num2;
    static Float:num;
    num = 60.00/*1114636288*/;
    num2 = num - 20.00;
    StartOrigin[0] = Origin[0] - num;
    StartOrigin[1] = Origin[1];
    StartOrigin[2] = Origin[2];
    EndOrigin[0] = Origin[0] - num - num;
    EndOrigin[1] = Origin[1];
    EndOrigin[2] = Origin[2];
    npc__mine(iEnt, StartOrigin, EndOrigin, Gravity);
    StartOrigin[0] = Origin[0] + num;
    StartOrigin[1] = Origin[1];
    StartOrigin[2] = Origin[2];
    EndOrigin[0] = Origin[0] + num + num;
    EndOrigin[1] = Origin[1];
    EndOrigin[2] = Origin[2];
    npc__mine(iEnt, StartOrigin, EndOrigin, Gravity);
    StartOrigin[0] = Origin[0];
    StartOrigin[1] = Origin[1] - num;
    StartOrigin[2] = Origin[2];
    EndOrigin[0] = Origin[0];
    EndOrigin[1] = Origin[1] - num - num;
    EndOrigin[2] = Origin[2];
    npc__mine(iEnt, StartOrigin, EndOrigin, Gravity);
    StartOrigin[0] = Origin[0];
    StartOrigin[1] = Origin[1] + num;
    StartOrigin[2] = Origin[2];
    EndOrigin[0] = Origin[0];
    EndOrigin[1] = Origin[1] + num + num;
    EndOrigin[2] = Origin[2];
    npc__mine(iEnt, StartOrigin, EndOrigin, Gravity);
    StartOrigin[0] = Origin[0] - num2;
    StartOrigin[1] = Origin[1] + num2;
    StartOrigin[2] = Origin[2];
    EndOrigin[0] = Origin[0] - num2 - num2;
    EndOrigin[1] = Origin[1] + num2 + num2;
    EndOrigin[2] = Origin[2];
    npc__mine(iEnt, StartOrigin, EndOrigin, Gravity);
    StartOrigin[0] = Origin[0] + num2;
    StartOrigin[1] = Origin[1] - num2;
    StartOrigin[2] = Origin[2];
    EndOrigin[0] = Origin[0] + num2 + num2;
    EndOrigin[1] = Origin[1] - num2 - num2;
    EndOrigin[2] = Origin[2];
    npc__mine(iEnt, StartOrigin, EndOrigin, Gravity);
    StartOrigin[0] = Origin[0] + num2;
    StartOrigin[1] = Origin[1] + num2;
    StartOrigin[2] = Origin[2];
    EndOrigin[0] = Origin[0] + num2 + num2;
    EndOrigin[1] = Origin[1] + num2 + num2;
    EndOrigin[2] = Origin[2];
    npc__mine(iEnt, StartOrigin, EndOrigin, Gravity);
    StartOrigin[0] = Origin[0] - num2;
    StartOrigin[1] = Origin[1] - num2;
    StartOrigin[2] = Origin[2];
    EndOrigin[0] = Origin[0] - num2 - num2;
    EndOrigin[1] = Origin[1] - num2 - num2;
    EndOrigin[2] = Origin[2];
    npc__mine(iEnt, StartOrigin, EndOrigin, Gravity);
    return 0;
}

public npc__mine(iEnt, Float:StartOrigin[3], Float:EndOrigin[3], Float:Gravity)
{
    if (!pev_valid(iEnt))
    {
        return 0;
    }
    create_ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
    new ent = create_ent;
    entity_set_string(ent, 0, "zg_granade");
    engfunc(EngFunc_SetModel, ent, "models/zombiegiant/titan_m14.mdl");
    set_pev(ent, pev_origin, StartOrigin);
    set_pev(ent, pev_solid, 1);
    set_pev(ent, pev_movetype, 6);
    set_pev(ent, pev_owner, get_owner(iEnt));
    set_pev(ent, pev_gravity, 0.70/*1060320051*/);
    set_pev(ent, pev_mins, "");
    set_pev(ent, pev_maxs, "");
    entity_set_float(ent, EV_FL_nextthink, halflife_time());
    static Float:Velocity[3];
    new var1 = EndOrigin;
    var1[0] = var1[0] + random_float(-50.00, 50.00);
    EndOrigin[1] += random_float(-50.00, 50.00);
    EndOrigin[2] += random_float(-10.00, 50.00);
    get_speed_vector(StartOrigin, EndOrigin, random_float(160.00, 400.00), Velocity);
    set_pev(ent, pev_velocity, Velocity);
    static Float:Angles[3];
    static Float:Ent_Origin[3];
    pev(ent, pev_origin, Ent_Origin);
    Ent_Origin[0] = EndOrigin[0] - Ent_Origin[0][0];
    Ent_Origin[1] = EndOrigin[1] - Ent_Origin[1][0];
    Ent_Origin[2] = EndOrigin[2] - Ent_Origin[2][0];
    engfunc(EngFunc_VecToAngles, Ent_Origin, Angles);
    set_pev(ent, pev_angles, Angles);
    return 0;
}

is_npc(ent)
{
    static classname[32];
    pev(ent, pev_classname, classname, 31);
    if (!equali("", "cso_zombie_giant", 0))
    {
        return 0;
    }
    return 1;
}

set_entity_angles(iEnt, Float:Origin[3], Float:Framerate)
{
    static Float:Angles2[3];
    static Float:Angles[3];
    static Float:EntOrigin[3];
    pev(iEnt, pev_origin, EntOrigin);
    EntOrigin[0] = Origin[0] - EntOrigin[0][0];
    EntOrigin[1] = Origin[1] - EntOrigin[1][0];
    EntOrigin[2] = Origin[2] - EntOrigin[2][0];
    engfunc(EngFunc_VecToAngles, EntOrigin, Angles);
    Angles[2] = 0;
    Angles[0] = 0;
    pev(iEnt, pev_angles, Angles2);
    Angles2[2] = 0;
    Angles2[0] = 0;
    new var5 = 350.00;
    new var1;
    new var2;
    if (Angles[1][0] >= var5)
    {
        new var6 = 10.00;
        if (Angles2[1][0] <= var6)
        {
            var2 = var6;
            if (ERROR: Phi)
            {
                Angles2[1] = Angles[1][0];
            }
            new var7 = 350.00;
            new var3;
            new var4;
            if (Angles2[1][0] >= var7)
            {
                new var8 = 10.00;
                if (Angles[1][0] <= var8)
                {
                    var4 = var8;
                    if (ERROR: Phi)
                    {
                        Angles2[1] = Angles[1][0];
                    }
                    if (Origin[0] < EntOrigin[0][0])
                    {
                        new var9 = Angles2[1];
                        var9 = var9[0] - Framerate;
                        Angles2[1] = floatmax(Angles2[1][0], Angles[1][0]);
                    }
                    else
                    {
                        new var10 = Angles2[1];
                        var10 = var10[0] + Framerate;
                        Angles2[1] = floatmin(Angles2[1][0], Angles[1][0]);
                    }
                    set_pev(iEnt, pev_angles, Angles2);
                    set_pev(iEnt, pev_v_angle, Angles2);
                    set_velocity(iEnt, Angles2, entity_get_float(iEnt, EV_FL_speed), 1);
                    return 0;
                }
                var3 = var8;
            }
            else
            {
                var3 = var7;
            }
            var4 = var3;
            if (ERROR: Phi)
            {
                Angles2[1] = Angles[1][0];
            }
            if (Origin[0] < EntOrigin[0][0])
            {
                new var9 = Angles2[1];
                var9 = var9[0] - Framerate;
                Angles2[1] = floatmax(Angles2[1][0], Angles[1][0]);
            }
            else
            {
                new var10 = Angles2[1];
                var10 = var10[0] + Framerate;
                Angles2[1] = floatmin(Angles2[1][0], Angles[1][0]);
            }
            set_pev(iEnt, pev_angles, Angles2);
            set_pev(iEnt, pev_v_angle, Angles2);
            set_velocity(iEnt, Angles2, entity_get_float(iEnt, EV_FL_speed), 1);
            return 0;
        }
        var1 = var6;
    }
    else
    {
        var1 = var5;
    }
    var2 = var1;
    if (ERROR: Phi)
    {
        Angles2[1] = Angles[1][0];
    }
    new var7 = 350.00;
    new var3;
    new var4;
    if (Angles2[1][0] >= var7)
    {
        new var8 = 10.00;
        if (Angles[1][0] <= var8)
        {
            var4 = var8;
            if (ERROR: Phi)
            {
                Angles2[1] = Angles[1][0];
            }
            if (Origin[0] < EntOrigin[0][0])
            {
                new var9 = Angles2[1];
                var9 = var9[0] - Framerate;
                Angles2[1] = floatmax(Angles2[1][0], Angles[1][0]);
            }
            else
            {
                new var10 = Angles2[1];
                var10 = var10[0] + Framerate;
                Angles2[1] = floatmin(Angles2[1][0], Angles[1][0]);
            }
            set_pev(iEnt, pev_angles, Angles2);
            set_pev(iEnt, pev_v_angle, Angles2);
            set_velocity(iEnt, Angles2, entity_get_float(iEnt, EV_FL_speed), 1);
            return 0;
        }
        var3 = var8;
    }
    else
    {
        var3 = var7;
    }
    var4 = var3;
    if (ERROR: Phi)
    {
        Angles2[1] = Angles[1][0];
    }
    if (Origin[0] < EntOrigin[0][0])
    {
        new var9 = Angles2[1];
        var9 = var9[0] - Framerate;
        Angles2[1] = floatmax(Angles2[1][0], Angles[1][0]);
    }
    else
    {
        new var10 = Angles2[1];
        var10 = var10[0] + Framerate;
        Angles2[1] = floatmin(Angles2[1][0], Angles[1][0]);
    }
    set_pev(iEnt, pev_angles, Angles2);
    set_pev(iEnt, pev_v_angle, Angles2);
    set_velocity(iEnt, Angles2, entity_get_float(iEnt, EV_FL_speed), 1);
    return 0;
}

set_entity_angles2(iEnt, Float:Origin[3], Float:Framerate)
{
    static Float:Angles2[3];
    static Float:Angles[3];
    static Float:EntOrigin[3];
    pev(iEnt, pev_origin, EntOrigin);
    EntOrigin[0] = Origin[0] - EntOrigin[0][0];
    EntOrigin[1] = Origin[1] - EntOrigin[1][0];
    EntOrigin[2] = Origin[2] - EntOrigin[2][0];
    engfunc(EngFunc_VecToAngles, EntOrigin, Angles);
    Angles[2] = 0;
    Angles[0] = 0;
    pev(iEnt, pev_angles, Angles2);
    Angles2[2] = 0;
    Angles2[0] = 0;
    new var5 = 350.00;
    new var1;
    new var2;
    if (Angles[1][0] >= var5)
    {
        new var6 = 10.00;
        if (Angles2[1][0] <= var6)
        {
            var2 = var6;
            if (ERROR: Phi)
            {
                Angles2[1] = Angles[1][0];
            }
            new var7 = 350.00;
            new var3;
            new var4;
            if (Angles2[1][0] >= var7)
            {
                new var8 = 10.00;
                if (Angles[1][0] <= var8)
                {
                    var4 = var8;
                    if (ERROR: Phi)
                    {
                        Angles2[1] = Angles[1][0];
                    }
                    if (Origin[0] < EntOrigin[0][0])
                    {
                        new var9 = Angles2[1];
                        var9 = var9[0] - Framerate;
                        Angles2[1] = floatmax(Angles2[1][0], Angles[1][0]);
                    }
                    else
                    {
                        new var10 = Angles2[1];
                        var10 = var10[0] + Framerate;
                        Angles2[1] = floatmin(Angles2[1][0], Angles[1][0]);
                    }
                    set_pev(iEnt, pev_angles, Angles2);
                    set_pev(iEnt, pev_v_angle, Angles2);
                    return 0;
                }
                var3 = var8;
            }
            else
            {
                var3 = var7;
            }
            var4 = var3;
            if (ERROR: Phi)
            {
                Angles2[1] = Angles[1][0];
            }
            if (Origin[0] < EntOrigin[0][0])
            {
                new var9 = Angles2[1];
                var9 = var9[0] - Framerate;
                Angles2[1] = floatmax(Angles2[1][0], Angles[1][0]);
            }
            else
            {
                new var10 = Angles2[1];
                var10 = var10[0] + Framerate;
                Angles2[1] = floatmin(Angles2[1][0], Angles[1][0]);
            }
            set_pev(iEnt, pev_angles, Angles2);
            set_pev(iEnt, pev_v_angle, Angles2);
            return 0;
        }
        var1 = var6;
    }
    else
    {
        var1 = var5;
    }
    var2 = var1;
    if (ERROR: Phi)
    {
        Angles2[1] = Angles[1][0];
    }
    new var7 = 350.00;
    new var3;
    new var4;
    if (Angles2[1][0] >= var7)
    {
        new var8 = 10.00;
        if (Angles[1][0] <= var8)
        {
            var4 = var8;
            if (ERROR: Phi)
            {
                Angles2[1] = Angles[1][0];
            }
            if (Origin[0] < EntOrigin[0][0])
            {
                new var9 = Angles2[1];
                var9 = var9[0] - Framerate;
                Angles2[1] = floatmax(Angles2[1][0], Angles[1][0]);
            }
            else
            {
                new var10 = Angles2[1];
                var10 = var10[0] + Framerate;
                Angles2[1] = floatmin(Angles2[1][0], Angles[1][0]);
            }
            set_pev(iEnt, pev_angles, Angles2);
            set_pev(iEnt, pev_v_angle, Angles2);
            return 0;
        }
        var3 = var8;
    }
    else
    {
        var3 = var7;
    }
    var4 = var3;
    if (ERROR: Phi)
    {
        Angles2[1] = Angles[1][0];
    }
    if (Origin[0] < EntOrigin[0][0])
    {
        new var9 = Angles2[1];
        var9 = var9[0] - Framerate;
        Angles2[1] = floatmax(Angles2[1][0], Angles[1][0]);
    }
    else
    {
        new var10 = Angles2[1];
        var10 = var10[0] + Framerate;
        Angles2[1] = floatmin(Angles2[1][0], Angles[1][0]);
    }
    set_pev(iEnt, pev_angles, Angles2);
    set_pev(iEnt, pev_v_angle, Angles2);
    return 0;
}

set_velocity(ent, Float:angles[3], Float:fSpeed, Move)
{
    static Float:Direction[3];
    angle_vector(angles, Move, Direction);
    new Float:f_vAngles[3];
    pev(ent, pev_angles, f_vAngles);
    engfunc(EngFunc_WalkMove, ent, f_vAngles[1], 1.00/*1065353216*/, 0);
    xs_vec_mul_scalar(Direction, fSpeed, Direction);
    entity_set_vector(ent, 2, Direction);
    return 0;
}

set_velocity2(ent, Float:angles[3], Float:fSpeed, Move)
{
    new Float:f_vAngles[3];
    f_vAngles[0] = angles[0];
    f_vAngles[1] = angles[1];
    f_vAngles[2] = angles[2];
    static Float:Direction[3];
    angle_vector(angles, Move, Direction);
    engfunc(EngFunc_WalkMove, ent, f_vAngles[1], 1.00/*1065353216*/, 0);
    xs_vec_mul_scalar(Direction, fSpeed, Direction);
    entity_set_vector(ent, 2, Direction);
    return 0;
}

get_angles(iEnt, Float:Origin[3], Float:Angles[3])
{
    static Float:EntOrigin[3];
    pev(iEnt, pev_origin, EntOrigin);
    EntOrigin[0] = Origin[0] - EntOrigin[0][0];
    EntOrigin[1] = Origin[1] - EntOrigin[1][0];
    EntOrigin[2] = Origin[2] - EntOrigin[2][0];
    engfunc(EngFunc_VecToAngles, EntOrigin, Angles);
    Angles[2] = 0;
    Angles[0] = 0;
    return 0;
}

ScreenShake(id, amplitude, duration, frequency)
{
    message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("ScreenShake"), 92, id);
    write_short(amplitude * 4096);
    write_short(duration * 4096);
    write_short(frequency * 4096);
    message_end();
    return 0;
}

show_blood(Float:flEnd[3], scale)
{
    message_begin(MSG_BROADCAST, SVC_TEMPENTITY, 92, 0);
    write_byte(115);
    engfunc(EngFunc_WriteCoord, flEnd);
    engfunc(EngFunc_WriteCoord, flEnd[1]);
    engfunc(EngFunc_WriteCoord, flEnd[2]);
    write_short(blood[1][0]);
    write_short(blood[0][0]);
    write_byte(247);
    write_byte(scale + 5);
    message_end();
    return 0;
}

create_effect(Float:Origin[3], index, scale, framerate, flag)
{
    message_begin(MSG_BROADCAST, SVC_TEMPENTITY, 92, 0);
    write_byte(3);
    engfunc(EngFunc_WriteCoord, Origin);
    engfunc(EngFunc_WriteCoord, Origin[1]);
    engfunc(EngFunc_WriteCoord, Origin[2]);
    write_short(index);
    write_byte(scale);
    write_byte(framerate);
    write_byte(flag);
    message_end();
    return 0;
}

create_break(Float:Origin[3], index, life, count, velicity)
{
    message_begin(MSG_BROADCAST, SVC_TEMPENTITY, 92, 0);
    write_byte(108);
    engfunc(EngFunc_WriteCoord, Origin);
    engfunc(EngFunc_WriteCoord, Origin[1]);
    engfunc(EngFunc_WriteCoord, Origin[2]);
    engfunc(EngFunc_WriteCoord, 150);
    engfunc(EngFunc_WriteCoord, 150);
    engfunc(EngFunc_WriteCoord, 150);
    engfunc(EngFunc_WriteCoord, random_num(-50, 50));
    engfunc(EngFunc_WriteCoord, random_num(-50, 50));
    engfunc(EngFunc_WriteCoord, random_num(-50, 50));
    write_byte(velicity);
    write_short(index);
    write_byte(count);
    write_byte(life);
    write_byte(64);
    message_end();
    return 0;
}

public CreateKnockBack(iEnt, Float:Origin[3], Float:Radio, Float:Power, Float:Damage)
{
    !!! Removed Phi
    static iVictim = -1;
    new var2 = find_ent_in_sphere(iVictim, Origin, Radio);
    iVictim = var2;
    while (var2)
    {
        if (iEnt != iVictim && 0 != pev(iVictim, pev_takedamage))
        {
            ExecuteHamB(Ham_TakeDamage, iVictim, 0, iEnt, Damage, 2);
            if (is_user_alive(iVictim))
            {
                KnockBack(iEnt, iVictim, Power);
            }
        }
    }
    return 0;
}

public KnockBack(id, iVic, Float:iKb)
{
    !!! Removed Phi
    if (iVic > 32)
    {
        return 0;
    }
    if (!can_damage(id, iVic))
    {
        return 0;
    }
    new Float:vAttacker[3];
    new Float:vVictim[3];
    new Float:vVelocity[3];
    new flags = 0;
    pev(id, pev_origin, vAttacker);
    pev(iVic, pev_origin, vVictim);
    vVictim[2] = 0;
    vAttacker[2] = 0;
    flags = pev(id, pev_flags);
    xs_vec_sub(vVictim, vAttacker, vVictim);
    new Float:fDistance = xs_vec_len(vVictim);
    xs_vec_mul_scalar(vVictim, 1 / fDistance, vVictim);
    pev(iVic, pev_velocity, vVelocity);
    xs_vec_mul_scalar(vVictim, iKb, vVictim);
    vVictim[2] = xs_vec_len(vVictim) * 3.00;
    if (flags & -513)
    {
        xs_vec_mul_scalar(vVictim, 1.50, vVictim);
        vVictim[2] *= 0.40;
    }
    if (xs_vec_len(vVictim) > xs_vec_len(vVelocity))
    {
        set_pev(iVic, pev_velocity, vVictim);
    }
    return 0;
}

drop_weapons(id, dropwhat)
{
    static weaponid;
    static i;
    static num;
    static weapons[32];
    num = 0;
    get_user_weapons(id, "", num);
    i = 0;
    while (i < num)
    {
        new var5 = weapons;
        weaponid = var5[i][0][0];
        new var1;
        new var2;
        if (dropwhat == 1)
        {
            new var6 = 1 << weaponid;
            if (PRIMARY_WEAPONS_BIT_SUM & var6)
            {
                var2 = 1;

/ * ERROR! Не удалось привести тип объекта "Lysis.DSentinel" к типу "Lysis.DReturn". * /
 function "drop_weapons"
drop_weapons(id, dropwhat)

get_hp_bar(MaxHP, Float:GetHP)
{
    static NumHp;
    new var2 = GetHP;
    new var1;
    if (MaxHP < var2)
    {
        NumHp = 40;
        var1 = var2;
    }
    else
    {
        new var3 = 0.00;
        NumHp = floatround(GetHP * 40 / MaxHP + var3, floatround_round);
        var1 = var3;
    }
    return NumHp;
}

fm_get_aim_origin(index, Float:origin[3])
{
    new Float:start[3];
    new Float:view_ofs[3];
    pev(index, pev_origin, start);
    pev(index, pev_view_ofs, view_ofs);
    xs_vec_add(start, view_ofs, start);
    new Float:dest[3];
    pev(index, pev_v_angle, dest);
    engfunc(EngFunc_MakeVectors, dest);
    global_get(glb_v_forward, dest);
    xs_vec_mul_scalar(dest, 9999.00, dest);
    xs_vec_add(start, dest, dest);
    engfunc(EngFunc_TraceLine, start, dest, 0, index, 0);
    get_tr2(0, TR_vecEndPos, origin);
    return 1;
}

fm_set_user_godmode(index, godmode)
{
    new var1;
    if (godmode == 1)
    {
        var1 = 0;
    }
    else
    {
        var1 = 2.00/*1073741824*/;
    }

/ * ERROR! Не удалось привести тип объекта "Lysis.DSentinel" к типу "Lysis.DReturn". * /
 function "fm_set_user_godmode"
fm_set_user_godmode(index, godmode)

fm_get_user_godmode(index)
{
    if (pev(index, pev_takedamage))
    {
        return 1;
    }
    return 0;
}

fm_set_user_noclip(index, noclip)
{
    new var1;
    if (noclip == 1)
    {
        var1 = 8;
    }
    else
    {
        var1 = 3;
    }

/ * ERROR! Не удалось привести тип объекта "Lysis.DSentinel" к типу "Lysis.DReturn". * /
 function "fm_set_user_noclip"
fm_set_user_noclip(index, noclip)

fm_set_rendering(entity, fx, r, g, b, render, amount)
{
    new Float:RenderColor[3];
    RenderColor[0] = float®;
    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;
}

get_position(id, Float:forw, Float:right, Float:up, Float:vStart[], IdTipe)
{
    !!! Removed Phi
    static Float:vUp[3];
    static Float:vRight[3];
    static Float:vForward[3];
    static Float:vAngle[3];
    static Float:vOrigin[3];
    pev(id, pev_origin, vOrigin);
    pev(id, pev_view_ofs, vUp);
    xs_vec_add(vOrigin, vUp, vOrigin);
    if (IdTipe == 1)
    {
        pev(id, pev_v_angle, vAngle);
    }
    else
    {
        if (IdTipe)
        {
            if (IdTipe == 3)
            {
                pev(id, pev_v_angle, vAngle);
                vAngle[0] = 0;
            }
        }
        pev(id, pev_angles, vAngle);
        vAngle[0] = 0;
    }
    angle_vector(vAngle, 1, vForward);
    angle_vector(vAngle, 2, vRight);
    angle_vector(vAngle, 3, vUp);
    vStart[0] = vOrigin[0][0] + vForward[0][0] * forw + vRight[0][0] * right + vUp[0][0] * up;
    vStart[1] = vOrigin[1][0] + vForward[1][0] * forw + vRight[1][0] * right + vUp[1][0] * up;
    vStart[2] = vOrigin[2][0] + vForward[2][0] * forw + vRight[2][0] * right + vUp[2][0] * up;
    return 0;
}

get_speed_vector(Float:origin1[3], Float:origin2[3], Float:speed, Float:new_velocity[3])
{
    new_velocity[0] = origin2[0] - origin1[0];
    new_velocity[1] = origin2[1] - origin1[1];
    new_velocity[2] = origin2[2] - origin1[2];
    static Float:num;
    num = floatsqroot(speed * speed / new_velocity[0] * new_velocity[0] + new_velocity[1] * new_velocity[1] + new_velocity[2] * new_velocity[2]);
    new var1 = new_velocity;
    var1[0] = var1[0] * num;
    new_velocity[1] *= num;
    new_velocity[2] *= num;
    return 0;
}

set_origin_random(Float:Origin[3], Float:MinX, Float:MaxX, Float:MinY, Float:MaxY, Float:MinZ, Float:MaxZ)
{
    new var1 = Origin;

/ * ERROR! NYI * /
 function "set_origin_random"
set_origin_random(Float:Origin[3], Float:MinX, Float:MaxX, Float:MinY, Float:MaxY, Float:MinZ, Float:MaxZ)

can_damage(id1, id2)
{
    !!! Removed Phi
    if (id1 <= 0 || id1 >= 33 || id2 <= 0 || id2 >= 33)
    {
        return 1;
    }
    return get_pdata_int(id2, 114, 5) != get_pdata_int(id1, 114, 5);
}

EmitSound(ent, String:SoundFile[], Channel)
{
    if (!pev_valid(ent))
    {
        return 0;
    }
    emit_sound(ent, Channel, SoundFile, 1.00, 0.80, 0, 100);
    return 0;
}

set_entity_anim(index, anim)
{
    entity_set_float(index, EV_FL_animtime, get_gametime());
    entity_set_float(index, EV_FL_framerate, 1.00);
    entity_set_float(index, EV_FL_frame, 0.00);
    entity_set_int(index, EV_INT_sequence, anim);
    return 0;
}

set_think(ent, bool:Enable)
{
    if (!Enable)
    {
        set_pev(ent, pev_think, 0);
    }
    else
    {
        set_pev(ent, pev_think, 1);
    }
    return 0;
}

set_team(ent, team)
{
    set_pev(ent, pev_team2, team);
    return 0;
}

set_death(ent, bool:Enable)
{
    if (!Enable)
    {
        set_pev(ent, pev_death, 0);
    }
    else
    {
        set_pev(ent, pev_death, 1);
    }
    return 0;
}

set_ready(ent, bool:Enable)
{
    if (!Enable)
    {
        set_pev(ent, pev_fuser3, 0);
    }
    else
    {
        set_pev(ent, pev_fuser3, 1.00/*1065353216*/);
    }
    return 0;
}

set_ready2(ent, bool:Enable)
{
    if (!Enable)
    {
        set_pev(ent, pev_fuser2, 0);
    }
    else
    {
        set_pev(ent, pev_fuser2, 1.00/*1065353216*/);
    }
    return 0;
}

set_mana(ent, num)
{
    g_mana[get_owner(ent)] = num;
    return 0;
}

set_evolution(ent, bool:Enable)
{
    if (!Enable)
    {
        set_pev(ent, pev_skin, 0);
    }
    else
    {
        set_pev(ent, pev_skin, 1);
    }
    return 0;
}

set_iEnt(id, ent)
{
    if (!g_zg[id][0][0])
    {
        g_zg[id] = ent;
    }
    else
    {
        g_zg[id] = ent;
    }
    return 0;
}

set_vectipe(ent, tipe)
{
    set_pev(ent, pev_vectipe, tipe);
    return 0;
}

set_class(ent, Class)
{
    set_pev(ent, pev_fuser4, float(Class));
    return 0;
}

get_think(ent)
{
    return pev(ent, pev_think);
}

get_team(ent)
{
    return pev(ent, pev_team2);
}

get_death(ent)
{
    return pev(ent, pev_death);
}

get_vectipe(ent)
{
    return pev(ent, pev_vectipe);
}

get_ready(ent)
{
    new Float:Ready = 0;
    pev(ent, pev_fuser3, Ready);
    return floatround(Ready, floatround_round);
}

get_ready2(ent)
{
    new Float:Ready = 0;
    pev(ent, pev_fuser2, Ready);
    return floatround(Ready, floatround_round);
}

get_owner(ent)
{
    return pev(ent, pev_owner);
}

get_owner2(ent)
{
    return pev(ent, pev_iuser1);
}

get_evolution(ent)
{
    return pev(ent, pev_skin);
}

get_class(ent)
{
    new Float:Class = 0;
    pev(ent, pev_fuser4, Class);
    return floatround(Class, floatround_round);
}

get_anim(ent, anim)
{
    new anim_result = 0;
    if (anim == 23)
    {
        if (get_class(ent))
        {
            if (get_class(ent) == 1)
            {
                anim_result = 21;
            }
            if (get_class(ent) == 2)
            {
                anim_result = 23;
            }
        }
        else
        {
            anim_result = 21;
        }
    }
    else
    {
        if (anim)
        {
            if (anim == 1)
            {
                if (get_class(ent))
                {
                    if (get_class(ent) == 1)
                    {
                        anim_result = 15;
                    }
                    if (get_class(ent) == 2)
                    {
                        anim_result = 15;
                    }
                }
                else
                {
                    anim_result = 15;
                }
            }
            if (anim == 2)
            {
                if (get_class(ent))
                {
                    if (get_class(ent) == 1)
                    {
                        anim_result = 16;
                    }
                    if (get_class(ent) == 2)
                    {
                        anim_result = 16;
                    }
                }
                else
                {
                    anim_result = 16;
                }
            }
            if (anim == 3)
            {
                if (get_class(ent))
                {
                    if (get_class(ent) == 1)
                    {
                        anim_result = 24;
                    }
                    if (get_class(ent) == 2)
                    {
                        anim_result = 26;
                    }
                }
                else
                {
                    anim_result = 24;
                }
            }
            if (anim == 4)
            {
                if (get_class(ent))
                {
                    if (get_class(ent) == 1)
                    {
                        anim_result = 22;
                    }
                    if (get_class(ent) == 2)
                    {
                        anim_result = 24;
                    }
                }
                else
                {
                    anim_result = 22;
                }
            }
            if (anim == 5)
            {
                if (get_class(ent))
                {
                    if (get_class(ent) == 1)
                    {
                        anim_result = 17;
                    }
                    if (get_class(ent) == 2)
                    {
                        anim_result = 17;
                    }
                }
                else
                {
                    anim_result = 17;
                }
            }
            if (anim == 6)
            {
                if (get_class(ent))
                {
                    if (get_class(ent) == 1)
                    {
                        anim_result = 18;
                    }
                    if (get_class(ent) == 2)
                    {
                        anim_result = 18;
                    }
                }
                else
                {
                    anim_result = 18;
                }
            }
            if (anim == 7)
            {
                if (get_class(ent))
                {
                    if (get_class(ent) == 1)
                    {
                        anim_result = 23;
                    }
                    if (get_class(ent) == 2)
                    {
                        anim_result = 25;
                    }
                }
                anim_result = 23;
            }
        }
        if (get_class(ent))
        {
            if (get_class(ent) == 1)
            {
                anim_result = 14;
            }
            if (get_class(ent) == 2)
            {
                anim_result = 14;
            }
        }
        else
        {
            anim_result = 14;
        }
    }

/ * ERROR! Ссылка на объект не указывает на экземпляр объекта. * /
 function "get_anim"
get_anim(ent, anim)

get_mana(ent)
{
    return g_mana[get_owner(ent)][0][0];
}

get_iEnt(id)
{
    if (!g_zg[id][0][0])
    {
        return 0;
    }
    return g_zg[id][0][0];
}

get_hand(ent)
{
    return pev(ent, pev_iuser2);
}

get_block(ent)
{
    return pev(ent, pev_iuser4);
}

is_user_zombie(id)
{
    if (!g_zg[id][0][0])
    {
        return 0;
    }
    return 1;
}

LoadFiles()
{
    !!! Removed Phi
    new path[64];
    new linedata[1024];
    new key[64];
    new value[960];
    new section = 0;
    format(path, 63, "addons/amxmodx/configs/zombiegiant.ini");
    if (!file_exists(path))
    {
        new error[100];
        formatex(error, 99, "Cannot load customization file %s!", path);
        set_fail_state(error);
        return 0;
    }
    new file = fopen(path, "rt");
    while (file && !feof(file))
    {
        if (!linedata[0] || linedata[0] == 59)
        {
        }
    }
    if (file)
    {
        fclose(file);
    }
    return 0;
}