Skocz do zawartości

Nowy szablon forum

mygo.pl

Stworzyliśmy dla Was nowy wygląd forum. Z pewnością znajdziesz rzeczy, które wg Ciebie mogą zostać zmienione - wspomnij o tym w specjalnym wątku.

Czytaj więcej

Jak założyć własną sieć

serwerów CS

Zastanawiasz się nad prowadzeniem własnej sieci serwerów? Przeczytaj podstawowe informacje, na które należy zwrócić uwagę, przy takim projekcie.

Czytaj więcej

Tworzymy spis sieci

dodaj swoją

Dodaj sieć do której należysz, pozwoli to na promocję i budowę ogólnopolskiej bazy sieci CS.

Czytaj więcej

[REQ]How to turn ZP weapon into Normal .


MYGO.pl
 Udostępnij

Rekomendowane odpowiedzi

  • RSSy
Hello,
I'm trying to conver this plugin to work in normal mod but I didn't know how!
So please any help???


Code:

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

#define V_MODEL "models/v_kronos3.mdl"
#define P_MODEL "models/p_kronos3.mdl"
#define W_MODEL "models/w_kronos3.mdl"
#define SIGHT_MODEL "models/ef_kronos5.mdl"

#define CSW_BASEDON CSW_P90
#define weapon_basedon "weapon_p90"

#define DAMAGE_A 25.0
#define DAMAGE_B 75.0
#define CLIP 50
#define BPAMMO 500
#define SPEED_A 1.0
#define SPEED_B 1.0
#define RECOIL 0.5
#define RELOAD_TIME 3.0
#define        RESULT_HIT_NONE                        0
#define        RESULT_HIT_PLAYER                        1
#define        RESULT_HIT_WORLD                        2
#define MAX_SHOOT 25
#define ACCURATE 80
#define RANGE 1096.0
#define ANGLE 180.0
#define KNOCKBACK 2.5
#define BODY_NUM 0
#define mf_spr "sprites/muzzleflash3.spr"
#define mf_cls "duarrmemek"
#define WEAPON_SECRETCODE 156851222222035
#define WEAPON_EVENT "events/p90.sc"
#define OLD_W_MODEL "models/w_p90.mdl"

enum
{
        ANIM_IDLE = 0,
        ANIM_IDLE2,
        ANIM_IDLE3,
        ANIM_RELOAD,
        ANIM_RELOAD2,
        ANIM_DRAW,
        ANIM_DRAW2,
        ANIM_SHOOT1,
        ANIM_SHOOT2,
        ANIM_SHOOT3,
        ANIM_SCAN_ACTIVATE,
        ANIM_ZOOM,
        ANIM_SCAN_DEACTIVATE
}

new const ExtraSounds[][] =
{
        "weapons/kronos3_boltpull.wav",
        "weapons/kronos3_clipin1.wav",
        "weapons/kronos3_clipin2.wav",
        "weapons/kronos3_clipout.wav",
        "weapons/kronos3_scan_activate.wav",
        "weapons/kronos3_scan_deacivate.wav",
        "weapons/kronos3_takeaim.wav",
        "weapons/kronos3_zoom.wav",
        "weapons/kronos3-1.wav",
        "weapons/kronos3_beep.wav"
}
new g_System, Max_Shoot, Float:TargetLock[33], g_holding_attack[33], g_Shoot_Count[33]
new g_Had_Weapon2, g_Old_Weapon[33], Float:g_Recoil[33][3], g_Clip[33]
new g_weapon_event, g_ShellId, g_SmokePuff_SprId,spr_blood_spray,spr_blood_drop
new g_HamBot, g_Msg_CurWeapon, laser, m_spriteTexture
new g_MaxPlayers, x90
// MACROS
#define Get_BitVar(%1,%2) (%1 & (1 << (%2 & 31)))
#define Set_BitVar(%1,%2) %1 |= (1 << (%2 & 31))
#define UnSet_BitVar(%1,%2) %1 &= ~(1 << (%2 & 31))

#define TASK_USE 10920+10
#define TASK_RESET 10920+11
#define MAX_TARGET 6

public plugin_init()
{
        register_plugin("Hunter Killer X90", "version1", "Mellowzy")
       
        register_event("CurWeapon", "Event_CurWeapon", "be", "1=1")
        register_message(get_user_msgid("DeathMsg"), "Message_DeathMsg")
       
        register_forward(FM_UpdateClientData, "fw_UpdateClientData_Post", 1)       
        register_forward(FM_PlaybackEvent, "fw_PlaybackEvent")
        register_forward(FM_CmdStart, "fw_CmdStart")
        register_forward(FM_SetModel, "fw_SetModel")       
        register_forward(FM_Think, "fw_MF_Think2")
       
        RegisterHam(Ham_TraceAttack, "worldspawn", "fw_TraceAttack_World")
        RegisterHam(Ham_TraceAttack, "player", "fw_TraceAttack_Player")
       
        RegisterHam(Ham_Weapon_PrimaryAttack, weapon_basedon, "fw_Weapon_PrimaryAttack")
        RegisterHam(Ham_Weapon_PrimaryAttack, weapon_basedon, "fw_Weapon_PrimaryAttack_Post", 1)
        RegisterHam(Ham_Item_AddToPlayer, weapon_basedon, "fw_Item_AddToPlayer_Post", 1)
        RegisterHam(Ham_Weapon_Reload, weapon_basedon, "fw_Weapon_Reload")
        RegisterHam(Ham_Weapon_Reload, weapon_basedon, "fw_Weapon_Reload_Post", 1)
        RegisterHam(Ham_Weapon_WeaponIdle, weapon_basedon, "fw_WeaponIdle", 1)
        RegisterHam(Ham_Item_PostFrame, weapon_basedon, "fw_Item_PostFrame")       
       
        RegisterHam(Ham_Spawn, "player", "Remove_Weapon", 1)
        RegisterHam(Ham_Killed, "player", "Remove_Weapon", 1)
       
        g_MaxPlayers =  get_maxplayers()
       
        g_Msg_CurWeapon = get_user_msgid("CurWeapon")
       
        x90 = zp_register_extra_item("Hunter Killer X-90", 0, ZP_TEAM_HUMAN)
        register_clcmd("weapon_kronos3", "weapon_hook")
}

public plugin_precache()
{
        engfunc(EngFunc_PrecacheModel, V_MODEL)
        engfunc(EngFunc_PrecacheModel, P_MODEL)
        engfunc(EngFunc_PrecacheModel, W_MODEL)
        precache_model(mf_spr)
        spr_blood_spray = precache_model("sprites/bloodspray.spr")
        spr_blood_drop = precache_model("sprites/blood.spr")
       
        g_SmokePuff_SprId = engfunc(EngFunc_PrecacheModel, "sprites/wall_puff1.spr")
        g_ShellId = engfunc(EngFunc_PrecacheModel, "models/rshell.mdl")
        laser = precache_model("sprites/zbeam3.spr")
        m_spriteTexture = precache_model( "sprites/laserbeam.spr" )
       
        register_forward(FM_PrecacheEvent, "fw_PrecacheEvent_Post", 1)
       
        for(new i = 0; i < sizeof(ExtraSounds); i++)
                precache_sound(ExtraSounds)
}

public fw_PrecacheEvent_Post(type, const name[])
{
        if(equal(WEAPON_EVENT, name))
                g_weapon_event = get_orig_retval()               
}

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

public Do_RegisterHam(id)
{
        RegisterHamFromEntity(Ham_TraceAttack, id, "fw_TraceAttack_Player")       
}
public zp_extra_item_selected(id, itemid)
{
        if(itemid == x90) Get_Weapon(id)
}

public zp_user_infected_post(id)Remove_Weapon(id)
public Get_Weapon(id)
{
        if(!is_user_alive(id) || zp_get_user_zombie(id))
                return
               
        Stock_DropSlot(id, 1)
        UnSet_BitVar(g_System, id)
        UnSet_BitVar(Max_Shoot, id)
        g_holding_attack[id] = 0
        g_Shoot_Count[id] = 0
               
        Set_BitVar(g_Had_Weapon2, id)
        fm_give_item(id, weapon_basedon)       
       
        // Set Ammo
        static Ent; Ent = fm_get_user_weapon_entity(id, CSW_BASEDON)
        if(pev_valid(Ent)) cs_set_weapon_ammo(Ent, CLIP)
       
        cs_set_user_bpammo(id, CSW_BASEDON, BPAMMO)
       
        engfunc(EngFunc_MessageBegin, MSG_ONE_UNRELIABLE, g_Msg_CurWeapon, {0, 0, 0}, id)
        write_byte(1)
        write_byte(CSW_BASEDON)
        write_byte(CLIP)
        message_end()       
}

public Remove_Weapon(id)
{
        set_fov(id)
        ScreenFade(id, 0, 0, 0, 0, 0)
        UnSet_BitVar(g_Had_Weapon2, id)
        remove_task(id+TASK_USE)
        remove_task(id+TASK_RESET)
}
public weapon_hook(id)
{
        engclient_cmd(id, weapon_basedon)
        return PLUGIN_HANDLED
}
public client_connect(id)Remove_Weapon(id)
public client_disconnected(id)Remove_Weapon(id)
public Event_CurWeapon(id)
{
        if(!is_user_alive(id))
                return
       
        static CSWID; CSWID = read_data(2)
       
        if((CSWID == CSW_BASEDON && g_Old_Weapon[id] != CSW_BASEDON) && Get_BitVar(g_Had_Weapon2, id))
        {
                set_pev(id, pev_viewmodel2, V_MODEL)
                set_pev(id, pev_weaponmodel2, "")
                if(Get_BitVar(g_System, id))
                {
                        g_holding_attack[id] = 0
                        g_Shoot_Count[id] = 0
                        UnSet_BitVar(Max_Shoot, id)
                        UnSet_BitVar(g_System, id)
                        set_fov(id)
                        ScreenFade(id, 0, 0, 0, 0, 0)
                        remove_task(id+TASK_USE)
                        remove_task(id+TASK_RESET)
                        set_weapon_anim(id, ANIM_DRAW)
                }
                else set_weapon_anim(id, Get_BitVar(Max_Shoot, id)? ANIM_DRAW2 : ANIM_DRAW)
                Draw_NewWeapon(id, CSWID)
        } else if((CSWID == CSW_BASEDON && g_Old_Weapon[id] == CSW_BASEDON) && Get_BitVar(g_Had_Weapon2, id)) {
                static Ent; Ent = fm_get_user_weapon_entity(id, CSW_BASEDON)
                if(!pev_valid(Ent))
                {
                        g_Old_Weapon[id] = get_user_weapon(id)
                        return
                }
                new Float:flSpeed[33]
                if(Get_BitVar(g_System, id))
                {
                        flSpeed[id] = SPEED_B
                }
                else flSpeed[id] = SPEED_A
                set_pdata_float(Ent, 46, get_pdata_float(Ent, 46, 4) * flSpeed[id], 4)
                set_pdata_float(Ent, 47, get_pdata_float(Ent, 47, 4) * flSpeed[id], 4)
        } else if(CSWID != CSW_BASEDON && g_Old_Weapon[id] == CSW_BASEDON) Draw_NewWeapon(id, CSWID)
       
        g_Old_Weapon[id] = get_user_weapon(id)
}
public Message_DeathMsg(msg_id, msg_dest, id)
{
        static szTruncatedWeapon[33], iAttacker, iVictim
       
        get_msg_arg_string(4, szTruncatedWeapon, charsmax(szTruncatedWeapon))
       
        iAttacker = get_msg_arg_int(1)
        iVictim = get_msg_arg_int(2)
       
        if(!is_user_connected(iAttacker) || iAttacker == iVictim) return PLUGIN_CONTINUE
       
        if(get_user_weapon(iAttacker) == CSW_BASEDON)
        {
                if(Get_BitVar(g_Had_Weapon2, iAttacker))
                        set_msg_arg_string(4, "p90")
        }
               
        return PLUGIN_CONTINUE
}
public Draw_NewWeapon(id, CSW_ID)
{
        if(CSW_ID == CSW_BASEDON)
        {
                static ent
                ent = fm_get_user_weapon_entity(id, CSW_BASEDON)
               
                if(pev_valid(ent) && Get_BitVar(g_Had_Weapon2, id))
                {
                        set_pev(ent, pev_effects, pev(ent, pev_effects) &~ EF_NODRAW)
                        engfunc(EngFunc_SetModel, ent, P_MODEL)       
                        set_pev(ent, pev_body, BODY_NUM)
                }
        } else {
                static ent
                ent = fm_get_user_weapon_entity(id, CSW_BASEDON)
               
                if(pev_valid(ent)) set_pev(ent, pev_effects, pev(ent, pev_effects) | EF_NODRAW)                       
        }
       
}

public fw_UpdateClientData_Post(id, sendweapons, cd_handle)
{
        if(!is_user_alive(id))
                return FMRES_IGNORED       
        if(get_user_weapon(id) == CSW_BASEDON && Get_BitVar(g_Had_Weapon2, id))
                set_cd(cd_handle, CD_flNextAttack, get_gametime() + 0.001)
       
        return FMRES_HANDLED
}

public fw_PlaybackEvent(flags, invoker, eventid, Float:delay, Float:origin[3], Float:angles[3], Float:fparam1, Float:fparam2, iParam1, iParam2, bParam1, bParam2)
{
        if (!is_user_connected(invoker))
                return FMRES_IGNORED       
        if(get_user_weapon(invoker) != CSW_BASEDON || !Get_BitVar(g_Had_Weapon2, invoker))
                return FMRES_IGNORED
        if(eventid != g_weapon_event)
                return FMRES_IGNORED
       
        engfunc(EngFunc_PlaybackEvent, flags | FEV_HOSTONLY, invoker, eventid, delay, origin, angles, fparam1, fparam2, iParam1, iParam2, bParam1, bParam2)
                       
        Eject_Shell(invoker, g_ShellId, 0.0)
               
        return FMRES_SUPERCEDE
}

public fw_SetModel(entity, model[])
{
        if(!pev_valid(entity))
                return FMRES_IGNORED
       
        static Classname[32]
        pev(entity, pev_classname, Classname, sizeof(Classname))
       
        if(!equal(Classname, "weaponbox"))
                return FMRES_IGNORED
       
        static iOwner
        iOwner = pev(entity, pev_owner)
       
        if(equal(model, OLD_W_MODEL))
        {
                static weapon; weapon = fm_find_ent_by_owner(-1, weapon_basedon, entity)
               
                if(!pev_valid(weapon))
                        return FMRES_IGNORED;
               
                if(Get_BitVar(g_Had_Weapon2, iOwner))
                {
                        set_fov(iOwner)
                        ScreenFade(iOwner, 0, 0, 0, 0, 0)
                        UnSet_BitVar(g_Had_Weapon2, iOwner)
                       
                        set_pev(weapon, pev_impulse, WEAPON_SECRETCODE)
                        engfunc(EngFunc_SetModel, entity, W_MODEL)
                        set_pev(entity, pev_body, BODY_NUM)
                       
                        return FMRES_SUPERCEDE
                }
        }

        return FMRES_IGNORED;
}

public fw_TraceAttack_World(Victim, Attacker, Float:Damage, Float:Direction[3], Ptr, DamageBits)
{
        if(!is_user_connected(Attacker))
                return HAM_IGNORED       
        if(get_user_weapon(Attacker) != CSW_BASEDON || !Get_BitVar(g_Had_Weapon2, Attacker))
                return HAM_IGNORED
               
        static Float:flEnd[3], Float:vecPlane[3]
       
        get_tr2(Ptr, TR_vecEndPos, flEnd)
        get_tr2(Ptr, TR_vecPlaneNormal, vecPlane)               
               
        Make_BulletHole(Attacker, flEnd, Damage)
        Make_BulletSmoke(Attacker, Ptr)

        SetHamParamFloat(3, Get_BitVar(g_System, Attacker) ? DAMAGE_B : DAMAGE_A)
       
        return HAM_IGNORED
}

public fw_TraceAttack_Player(Victim, Attacker, Float:Damage, Float:Direction[3], Ptr, DamageBits)
{
        if(!is_user_connected(Attacker))
                return HAM_IGNORED       
        if(get_user_weapon(Attacker) != CSW_BASEDON || !Get_BitVar(g_Had_Weapon2, Attacker))
                return HAM_IGNORED
        if(get_user_team(Victim) == get_user_team(Attacker))
                return HAM_IGNORED
       
        static Float:flEnd[3]
        get_tr2(Ptr, TR_vecEndPos, flEnd)
       
        if(g_holding_attack[Attacker]) g_Shoot_Count[Attacker]++

        if(g_Shoot_Count[Attacker] >= MAX_SHOOT)
        {
                g_Shoot_Count[Attacker] = 0
                Set_BitVar(Max_Shoot, Attacker)
        }
       
        SetHamParamFloat(3, Get_BitVar(g_System, Attacker) ? DAMAGE_B : DAMAGE_A)

        return HAM_IGNORED
}
public Create_Tracer(id, Float:Target[3])
{
        static Float:Start[3];
        Get_Position(id, 48.0, 0.0, -6.0, Start)
       
        message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
        write_byte(TE_BEAMPOINTS)
        write_coord_f(Start[0])
        write_coord_f(Start[1])
        write_coord_f(Start[2])
        write_coord_f(Target[0])
        write_coord_f(Target[1])
        write_coord_f(Target[2])
        write_short(m_spriteTexture)
        write_byte(0) // framerate
        write_byte(0) // framerate
        write_byte(5) // life
        write_byte(2)  // width
        write_byte(0)  // noise
        write_byte(200)  // r, g, b
        write_byte(200)  // r, g, b
        write_byte(200)  // r, g, b
        write_byte(40)        // brightness
        write_byte(1)                // speed
        message_end()
}

public fw_WeaponIdle(Ent)
{
        static id; id = get_pdata_cbase(Ent, 41, 4)
        if(!Get_BitVar(g_Had_Weapon2, id))return HAM_IGNORED
       
        static Float:flTimeWeaponIdle; flTimeWeaponIdle = get_pdata_float(Ent,48, 4)
        if(!(flTimeWeaponIdle < 0.1)) return HAM_IGNORED
       
        if(Get_BitVar(g_System, id))Stock_SetAnimIdle(id, Ent, ANIM_IDLE3, 2.5)
        else Stock_SetAnimIdle(id, Ent, Get_BitVar(Max_Shoot, id)? ANIM_IDLE2 : ANIM_IDLE, 2.5)
       
        return HAM_IGNORED
}
       
public fw_Weapon_PrimaryAttack(Ent)
{
        static id; id = pev(Ent, pev_owner)
        pev(id, pev_punchangle, g_Recoil[id])
        if(!Get_BitVar(g_Had_Weapon2, id))return HAM_IGNORED
       
        static iClip; iClip = get_pdata_int(Ent, 51, 4)
        set_pdata_int(Ent, 14, iClip, 4)
        set_pdata_int(Ent, 16, iClip?1:0, 4)
       
        return HAM_IGNORED
}
public fw_Weapon_PrimaryAttack_Post(Ent)
{
        static id; id = pev(Ent, pev_owner)
        if(!Get_BitVar(g_Had_Weapon2, id))return HAM_IGNORED
        if(get_pdata_int(Ent, 14, 4) <= get_pdata_int(Ent, 51, 4)) return HAM_SUPERCEDE
       
        /*if(!get_pdata_int(Ent, 16, 4)) return HAM_IGNORED
        set_pdata_int(Ent, 16, 0, 4)*/
        static Accena; Accena = ACCURATE
        if(Accena != -1)
        {
                static Float:Accuracy
                Accuracy = (float(100 - ACCURATE) * 1.5) / 100.0

                set_pdata_float(Ent, 62, Accuracy, 4);
        }
        set_pdata_int(Ent, 64, 0, 4)
       
        static Float:Push[3]
        pev(id, pev_punchangle, Push)
        xs_vec_sub(Push, g_Recoil[id], Push)
               
        xs_vec_mul_scalar(Push, RECOIL, Push)
        xs_vec_add(Push, g_Recoil[id], Push)
        set_pev(id, pev_punchangle, Push)
       
        MakeMuzzleFlash(id)
        emit_sound(id, CHAN_WEAPON, ExtraSounds[8], VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
       
        AutoLockSystem(id,Get_BitVar(g_System, id)? true : false)
       
        if(Get_BitVar(g_System, id)) set_weapon_anim(id, ANIM_SHOOT3)
        else set_weapon_anim(id, Get_BitVar(Max_Shoot, id)? ANIM_SHOOT2 : ANIM_SHOOT1)
       
        return HAM_IGNORED
}
public AutoLockSystem(iPlayer,bool:active)
{
        if(!IsAlive(iPlayer) || !Get_BitVar(g_Had_Weapon2, iPlayer))
                return 1;
        if(zp_get_user_zombie(iPlayer))
                return 1;
               
        if(active)
        {
                for(new i = MAX_TARGET; i < g_MaxPlayers; i++)
                {
                        if(entity_range(i, iPlayer) <= RANGE)
                        {
                                KnifeAttack_Global(iPlayer, true, RANGE, ANGLE, DAMAGE_B, KNOCKBACK)
                        }
                }
        }
        else
        {
                return 1;
        }
       
        return 0;
}
public fw_CmdStart(id, uc_handle, seed)
{
        if(!is_user_alive(id))return FMRES_IGNORED       
        if(get_user_weapon(id) != CSW_BASEDON || !Get_BitVar(g_Had_Weapon2, id))return FMRES_IGNORED       
       
        static PressButton; PressButton = get_uc(uc_handle, UC_Buttons)
        static OldButton; OldButton = pev(id, pev_oldbuttons)
       
        if((PressButton & IN_RELOAD) && Get_BitVar(g_System, id))
                return FMRES_SUPERCEDE
       
        if((PressButton & IN_ATTACK))
        {
                if(!g_holding_attack[id]) g_holding_attack[id] = 1
        } else {
                if(OldButton & IN_ATTACK)
                {
                        g_holding_attack[id] = 0
                }
        }
               
        if((PressButton & IN_ATTACK2))
        {
                PressButton &= ~IN_ATTACK2
                set_uc(uc_handle, UC_Buttons, PressButton)
               
                if((pev(id, pev_oldbuttons) & IN_ATTACK2))
                        return FMRES_IGNORED
                if(!Get_BitVar(Max_Shoot, id) || Get_BitVar(g_System, id))
                        return FMRES_IGNORED
                       
                set_weapon_anim(id, ANIM_ZOOM)
                set_pdata_float(id, 83, 1.0, 5)
                set_task(0.7, "Activate_Kronos5System", id+TASK_USE)
        }
        if(get_gametime() - 1.0 > TargetLock[id])
        {
                static Body, Target; get_user_aiming(id, Target, Body, 99999)
               
                if(Get_BitVar(g_System, id))
                {
                        if(is_user_alive(Target))
                        {
                                emit_sound(id, CHAN_BODY, ExtraSounds[6], 1.0, ATTN_NORM, 0, PITCH_NORM)
                        } else {
                                //Do nothing
                        }
                }
                TargetLock[id] = get_gametime()
        }
        return FMRES_IGNORED
}
public client_PreThink(id)
{
        if(!is_user_alive(id))return
        if(get_user_weapon(id) != CSW_BASEDON || !Get_BitVar(g_Had_Weapon2, id))return
       
        if(Get_BitVar(g_System, id))
        {
                Create_CheatEsp(id, 1)
        }
        else
        {
                Create_CheatEsp(id, 0)
        }
}
public Activate_Kronos5System(id)
{
        id -= TASK_USE
        if(!Get_BitVar(g_Had_Weapon2, id))return
        if(!Get_BitVar(Max_Shoot, id))return
       
        Set_BitVar(g_System, id)
        UnSet_BitVar(Max_Shoot, id)
        client_cmd(id, "spk %s", ExtraSounds[6])
       
        set_task(5.0, "Deactivate_Kronos5System_Stage01", id+TASK_RESET)
        ScreenFade(id, 1, 246, 155, 0, 80)
        set_fov(id, 60)
}
public Deactivate_Kronos5System_Stage01(id)
{
        id -= TASK_RESET
        if(!Get_BitVar(g_Had_Weapon2, id))return
        if(!Get_BitVar(g_System, id))return
       
        set_task(0.5, "Deactivate_Kronos5System_Stage02", id+TASK_RESET)
       
        set_weapon_anim(id, ANIM_SCAN_DEACTIVATE)
        set_fov(id)
        ScreenFade(id, 0, 0, 0, 0, 0)
        set_pdata_float(id, 83, 1.0, 5)
}
public Deactivate_Kronos5System_Stage02(id)
{
        id -= TASK_RESET
        if(!Get_BitVar(g_Had_Weapon2, id))return
        if(!Get_BitVar(g_System, id))return
       
        set_weapon_anim(id, ANIM_IDLE)
       
        g_holding_attack[id] = 0
        g_Shoot_Count[id] = 0
        UnSet_BitVar(Max_Shoot, id)
        UnSet_BitVar(g_System, id)
}
public fw_Item_AddToPlayer_Post(ent, id)
{
        if(!pev_valid(ent))
                return HAM_IGNORED
               
        if(pev(ent, pev_impulse) == WEAPON_SECRETCODE)
        {
                Set_BitVar(g_Had_Weapon2, id)
                set_pev(ent, pev_impulse, 0)
        }

        return HAM_HANDLED       
}

public fw_Item_PostFrame(ent)
{
        if(!pev_valid(ent))
                return HAM_IGNORED
       
        static id
        id = pev(ent, pev_owner)
       
        if(is_user_alive(id) && Get_BitVar(g_Had_Weapon2, id))
        {       
                static Float:flNextAttack; flNextAttack = get_pdata_float(id, 83, 5)
                static bpammo; bpammo = cs_get_user_bpammo(id, CSW_BASEDON)
                static iClip; iClip = get_pdata_int(ent, 51, 4)
                static fInReload; fInReload = get_pdata_int(ent, 54, 4)
               
                if(fInReload && flNextAttack <= 0.0)
                {
                        static temp1; temp1 = min(CLIP - iClip, bpammo)

                        set_pdata_int(ent, 51, iClip + temp1, 4)
                        cs_set_user_bpammo(id, CSW_BASEDON, bpammo - temp1)               
                       
                        set_pdata_int(ent, 54, 0, 4)
                       
                        fInReload = 0
                }               
        }
       
        return HAM_IGNORED       
}
public fw_MF_Think2(ent)
{
        if(!pev_valid(ent))
                return
       
        static Classname[32]
        pev(ent, pev_classname, Classname, sizeof(Classname))
       
        if(equal(Classname, mf_cls))
        {
                new Float:iFrame, Float:iFramemax
                if(iFramemax >= 3.0)
                {
                        iFrame = 0.0
                        set_pev(ent, pev_flags, pev(ent, pev_flags) | FL_KILLME)
                }
                else
                {
                        iFrame += 1.0
                        set_pev(ent, pev_frame, iFrame)
                }
        }
}
stock MakeMuzzleFlash(id)
{
        static iMuz
        iMuz = Stock_CreateEntityBase(id, "env_sprite", MOVETYPE_FOLLOW, mf_spr, mf_cls, SOLID_NOT,0.15,Float:{0.0,0.0,0.0},Float:{0.0,0.0,0.0})

        set_pev(iMuz, pev_body, 1)
        set_pev(iMuz, pev_rendermode, kRenderTransAdd)
        set_pev(iMuz, pev_renderamt, 255.0)
        set_pev(iMuz, pev_aiment, id)
        set_pev(iMuz, pev_scale, 0.1)
        set_pev(iMuz, pev_frame, 0.0)
        dllfunc(DLLFunc_Spawn, iMuz)
}
public fw_Weapon_Reload(ent)
{
        static id; id = pev(ent, pev_owner)
        if(!is_user_alive(id))
                return HAM_IGNORED
        if(!Get_BitVar(g_Had_Weapon2, id))
                return HAM_IGNORED
       
        g_Clip[id] = -1
       
        static bpammo; bpammo = cs_get_user_bpammo(id, CSW_BASEDON)
        static iClip; iClip = get_pdata_int(ent, 51, 4)
       
        if(bpammo <= 0) return HAM_SUPERCEDE
       
        if(iClip >= CLIP) return HAM_SUPERCEDE               
               
        g_Clip[id] = iClip

        return HAM_HANDLED
}

public fw_Weapon_Reload_Post(ent)
{
        static id; id = pev(ent, pev_owner)
        if(!is_user_alive(id))
                return HAM_IGNORED
        if(!Get_BitVar(g_Had_Weapon2, id))
                return HAM_IGNORED

        if (g_Clip[id] == -1)
                return HAM_IGNORED
       
        set_pdata_int(ent, 51, g_Clip[id], 4)
        set_pdata_int(ent, 54, 1, 4)
       
        if(Get_BitVar(g_System, id))
        {
                g_holding_attack[id] = 0
                g_Shoot_Count[id] = 0
                UnSet_BitVar(Max_Shoot, id)
                UnSet_BitVar(g_System, id)
                set_fov(id)
                remove_task(id+TASK_USE)
                remove_task(id+TASK_RESET)
                ScreenFade(id, 0, 0, 0, 0, 0)
                set_weapon_anim(id, ANIM_RELOAD)
        }
        else set_weapon_anim(id, Get_BitVar(Max_Shoot, id)? ANIM_RELOAD2 : ANIM_RELOAD)
       
        set_pdata_float(id, 83, RELOAD_TIME, 5)

        return HAM_HANDLED
}

stock Make_BulletHole(id, Float:Origin[3], Float:Damage)
{
        // Find target
        static Decal; Decal = random_num(41, 45)
        static LoopTime;
       
        if(Damage > 100.0) LoopTime = 2
        else LoopTime = 1
       
        for(new i = 0; i < LoopTime; i++)
        {
                // Put decal on "world" (a wall)
                message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
                write_byte(TE_WORLDDECAL)
                engfunc(EngFunc_WriteCoord, Origin[0])
                engfunc(EngFunc_WriteCoord, Origin[1])
                engfunc(EngFunc_WriteCoord, Origin[2])
                write_byte(Decal)
                message_end()
               
                // Show sparcles
                message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
                write_byte(TE_GUNSHOTDECAL)
                engfunc(EngFunc_WriteCoord, Origin[0])
                engfunc(EngFunc_WriteCoord, Origin[1])
                engfunc(EngFunc_WriteCoord, Origin[2])
                write_short(id)
                write_byte(Decal)
                message_end()
        }
}

public Make_BulletSmoke(id, TrResult)
{
        static Float:vecSrc[3], Float:vecEnd[3], TE_FLAG
       
        get_weapon_attachment(id, vecSrc)
        global_get(glb_v_forward, vecEnd)
   
        xs_vec_mul_scalar(vecEnd, 8192.0, vecEnd)
        xs_vec_add(vecSrc, vecEnd, vecEnd)

        get_tr2(TrResult, TR_vecEndPos, vecSrc)
        get_tr2(TrResult, TR_vecPlaneNormal, vecEnd)
   
        xs_vec_mul_scalar(vecEnd, 2.5, vecEnd)
        xs_vec_add(vecSrc, vecEnd, vecEnd)
   
        TE_FLAG |= TE_EXPLFLAG_NODLIGHTS
        TE_FLAG |= TE_EXPLFLAG_NOSOUND
        TE_FLAG |= TE_EXPLFLAG_NOPARTICLES
       
        engfunc(EngFunc_MessageBegin, MSG_PAS, SVC_TEMPENTITY, vecEnd, 0)
        write_byte(TE_EXPLOSION)
        engfunc(EngFunc_WriteCoord, vecEnd[0])
        engfunc(EngFunc_WriteCoord, vecEnd[1])
        engfunc(EngFunc_WriteCoord, vecEnd[2] - 10.0)
        write_short(g_SmokePuff_SprId)
        write_byte(2)
        write_byte(50)
        write_byte(TE_FLAG)
        message_end()
}

// Stock
stock Stock_DropSlot(iPlayer, Slot)
{
        new item = get_pdata_cbase(iPlayer, 367+Slot, 4)
        while(item > 0)
        {
                static classname[24]
                pev(item, pev_classname, classname, charsmax(classname))
                engclient_cmd(iPlayer, "drop", classname)
                item = get_pdata_cbase(item, 42, 5)
        }
        set_pdata_cbase(iPlayer, 367, -1, 4)
}
stock Stock_CreateEntityBase(id, classtype[], mvtyp, mdl[], class[], solid, Float:fNext,Float:vOrg[3], Float:vAng[3])
{
        new pEntity = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, classtype))
        set_pev(pEntity, pev_movetype, mvtyp);
        set_pev(pEntity, pev_owner, id);
        engfunc(EngFunc_SetModel, pEntity, mdl);
        set_pev(pEntity, pev_classname, class);
        set_pev(pEntity, pev_solid, solid);
        if(vOrg[0]) set_pev(pEntity, pev_origin, vOrg)
        if(vAng[0]) set_pev(pEntity, pev_angles, vAng)
        if(fNext) set_pev(pEntity, pev_nextthink, get_gametime() + fNext)
        return pEntity
}
stock hook_ent2(ent, Float:VicOrigin[3], Float:speed, Float:multi, type)
{
        static Float:fl_Velocity[3]
        static Float:EntOrigin[3]
        static Float:EntVelocity[3]
       
        pev(ent, pev_velocity, EntVelocity)
        pev(ent, pev_origin, EntOrigin)
        static Float:distance_f
        distance_f = get_distance_f(EntOrigin, VicOrigin)
       
        static Float:fl_Time; fl_Time = distance_f / speed
        static Float:fl_Time2; fl_Time2 = distance_f / (speed * multi)
       
        if(type == 1)
        {
                fl_Velocity[0] = ((VicOrigin[0] - EntOrigin[0]) / fl_Time2) * 1.5
                fl_Velocity[1] = ((VicOrigin[1] - EntOrigin[1]) / fl_Time2) * 1.5
                fl_Velocity[2] = (VicOrigin[2] - EntOrigin[2]) / fl_Time               
        } else if(type == 2) {
                fl_Velocity[0] = ((EntOrigin[0] - VicOrigin[0]) / fl_Time2) * 1.5
                fl_Velocity[1] = ((EntOrigin[1] - VicOrigin[1]) / fl_Time2) * 1.5
                fl_Velocity[2] = (EntOrigin[2] - VicOrigin[2]) / fl_Time
        }

        xs_vec_add(EntVelocity, fl_Velocity, fl_Velocity)
        set_pev(ent, pev_velocity, fl_Velocity)
}

stock get_weapon_attachment(id, Float:output[3], Float:fDis = 40.0)
{
        static Float:vfEnd[3], viEnd[3]
        get_user_origin(id, viEnd, 3) 
        IVecFVec(viEnd, vfEnd)
       
        static Float:fOrigin[3], Float:fAngle[3]
       
        pev(id, pev_origin, fOrigin)
        pev(id, pev_view_ofs, fAngle)
       
        xs_vec_add(fOrigin, fAngle, fOrigin)
       
        static Float:fAttack[3]
       
        xs_vec_sub(vfEnd, fOrigin, fAttack)
        xs_vec_sub(vfEnd, fOrigin, fAttack)
       
        static Float:fRate
       
        fRate = fDis / vector_length(fAttack)
        xs_vec_mul_scalar(fAttack, fRate, fAttack)
       
        xs_vec_add(fOrigin, fAttack, output)
}

stock Eject_Shell(id, Shell_ModelIndex, Float:Time) // By Dias
{
        static Ent; Ent = get_pdata_cbase(id, 373, 5)
        if(!pev_valid(Ent))
                return

        set_pdata_int(Ent, 57, Shell_ModelIndex, 4)
        set_pdata_float(id, 111, get_gametime() + Time)
}

stock set_weapon_anim(id, anim)
{
        if(!is_user_alive(id))
                return
       
        set_pev(id, pev_weaponanim, anim)
       
        message_begin(MSG_ONE_UNRELIABLE, SVC_WEAPONANIM, {0, 0, 0}, id)
        write_byte(anim)
        write_byte(pev(id, pev_body))
        message_end()
}
stock set_fov(id, fov = 90)
{
        message_begin(MSG_ONE, get_user_msgid("SetFOV"), {0,0,0}, id)
        write_byte(fov)
        message_end()
}
stock Stock_SetAnimIdle(id, iEnt, iAnim, Float:flTime) //NST Ed Cyti
{
        if(iAnim == -1) return
        if(pev(id, pev_weaponanim) != iAnim) set_weapon_anim(id, iAnim)
        set_pdata_float(iEnt, 48, flTime, 4)
}
stock get_position(id,Float:forw, Float:right, Float:up, Float:vStart[])
{
        new Float:vOrigin[3], Float:vAngle[3], Float:vForward[3], Float:vRight[3], Float:vUp[3]
       
        pev(id, pev_origin, vOrigin)
        pev(id, pev_view_ofs,vUp) //for player
        xs_vec_add(vOrigin,vUp,vOrigin)
        pev(id, pev_v_angle, vAngle) // if normal entity ,use pev_angles
       
        angle_vector(vAngle,ANGLEVECTOR_FORWARD,vForward) //or use EngFunc_AngleVectors
        angle_vector(vAngle,ANGLEVECTOR_RIGHT,vRight)
        angle_vector(vAngle,ANGLEVECTOR_UP,vUp)
       
        vStart[0] = vOrigin[0] + vForward[0] * forw + vRight[0] * right + vUp[0] * up
        vStart[1] = vOrigin[1] + vForward[1] * forw + vRight[1] * right + vUp[1] * up
        vStart[2] = vOrigin[2] + vForward[2] * forw + vRight[2] * right + vUp[2] * up
}
stock Create_CheatEsp(id, active)
{
        new Float:fStartOrigin [ 3 ] , Float:fView [ 3 ] , Float:fEnd [ 3 ] , Float:fOrginPlayer [ 3 ] ,bool:bSee = false , Float:fEndPosEsp [ 3 ] ,Float: fVectorTmp2 [ 3 ] , Float: fAnglesEsp [ 3 ] , Float: fRight[ 3 ], Float: fUp [ 3 ]
        if(!is_user_alive(id))return
        if(get_user_weapon(id) != CSW_BASEDON || !Get_BitVar(g_Had_Weapon2, id))return
        if(!active)return
       
        pev( id ,pev_origin , fStartOrigin );
        pev( id ,pev_view_ofs , fView ) ;
               
        pev( id , pev_v_angle , fAnglesEsp );
               
        angle_vector( fAnglesEsp , ANGLEVECTOR_UP , fUp )
        angle_vector( fAnglesEsp , ANGLEVECTOR_RIGHT , fRight )
               
        xs_vec_normalize( fRight , fRight );
        xs_vec_normalize( fUp , fUp )
               
        xs_vec_add( fStartOrigin , fView , fStartOrigin );
       
        for ( new i = 1 ; i <= 32 ; i++ ){
                if( !is_user_alive( i ))continue;
                if( cs_get_user_team(i) == cs_get_user_team(id) )continue
               
                bSee = false
                pev( i , pev_origin , fEnd );
                       
                new tr        =        create_tr2();
                       
                engfunc( EngFunc_TraceLine , fStartOrigin , fEnd , IGNORE_GLASS | IGNORE_MONSTERS , id , tr );
                       
                if( pev_valid( get_tr2( tr , TR_pHit ) ) && ( get_tr2( tr , TR_pHit ) == i || pev( get_tr2( tr , TR_pHit ) , pev_owner ) == i )){
                        bSee        =        true;
                        get_tr2( tr , TR_vecEndPos , fEndPosEsp );
                }
                       
                free_tr2( tr );
                if( !bSee ){
                               
                        pev( i ,pev_view_ofs , fView );
                               
                        xs_vec_add( fEnd , fView , fEnd );
                               
                        tr        =        create_tr2();
                               
                        engfunc( EngFunc_TraceLine , fStartOrigin , fEnd , IGNORE_GLASS | IGNORE_MONSTERS , id , tr );
                               
                        if( pev_valid( get_tr2( tr , TR_pHit ) ) && ( get_tr2( tr , TR_pHit ) == i || pev( get_tr2( tr , TR_pHit ) , pev_owner ) == i )){
                                bSee        =        true;
                                get_tr2( tr , TR_vecEndPos , fEndPosEsp );
                        }
                               
                        free_tr2( tr );
                }
                if( bSee || entity_range( i , id ) < 750.0){
                        if( !bSee ){
                                pev( i , pev_origin , fEnd );
                                       
                                new tr        =        create_tr2();
                               
                                engfunc( EngFunc_TraceLine , fStartOrigin , fEnd , IGNORE_GLASS | IGNORE_MONSTERS , id , tr );
                                       
                                get_tr2( tr , TR_vecEndPos , fEndPosEsp );
                                       
                                free_tr2( tr );
                        }
                               
                        new Float: fVector [ 3 ] , Float:fVectorTmp [ 3 ];
                               
                        xs_vec_sub( fEndPosEsp , fStartOrigin , fVector );
                        xs_vec_normalize( fVector , fVector );
                        xs_vec_mul_scalar( fVector , 5.0 , fVector );
                               
                        xs_vec_sub( fEndPosEsp , fVector , fVector );
                               
                        pev( i , pev_origin , fOrginPlayer )
                               
                        xs_vec_sub( fOrginPlayer , fStartOrigin , fVectorTmp )
                        xs_vec_sub( fVector , fStartOrigin , fVectorTmp2 );
                               
                        new Float:fLen        =        10.0 * ( xs_vec_len(fVectorTmp2) / xs_vec_len( fVectorTmp ));
                               
                        new Float: fFourPoints [ 4 ][ 3 ] , Float: fTmpUp [ 3 ] , Float: fTmpRight[ 3 ];
                               
                        xs_vec_copy( fUp , fTmpUp );
                        xs_vec_copy( fRight , fTmpRight );
                               
                        xs_vec_mul_scalar( fTmpUp , fLen , fTmpUp );
                        xs_vec_mul_scalar( fTmpRight , fLen , fTmpRight );
                               
                        xs_vec_copy( fVector , fFourPoints [ 0 ] );
                        xs_vec_add( fFourPoints [ 0 ] , fTmpUp , fFourPoints [ 0 ] );
                        xs_vec_add( fFourPoints [ 0 ] , fTmpRight , fFourPoints [ 0 ] );
                               
                        xs_vec_copy( fVector , fFourPoints [ 1 ] );
                        xs_vec_add( fFourPoints [ 1 ] , fTmpUp , fFourPoints [ 1 ] );
                        xs_vec_sub( fFourPoints [ 1 ] , fTmpRight , fFourPoints [ 1 ] );
                               
                        xs_vec_copy( fVector , fFourPoints [ 2 ] );
                        xs_vec_sub( fFourPoints [ 2 ] , fTmpUp , fFourPoints [ 2 ] );
                        xs_vec_add( fFourPoints [ 2 ] , fTmpRight , fFourPoints [ 2 ] );
                               
                        xs_vec_copy( fVector , fFourPoints [ 3 ] );
                        xs_vec_sub( fFourPoints [ 3 ] , fTmpUp , fFourPoints [ 3 ] );
                        xs_vec_sub( fFourPoints [ 3 ] , fTmpRight , fFourPoints [ 3 ] );
                               
                        new iRed , iBlue , iGreen, Brightness ;
                        iRed        =        255;
                        iBlue        =        0;
                        iGreen        =        0;
                        Brightness = 160
                               
                        message_begin(MSG_ONE_UNRELIABLE ,SVC_TEMPENTITY,{0,0,0},id) //message begin
                        write_byte(0)
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 0 ][ 0 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 0 ][ 1 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 0 ][ 2 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 1 ][ 0 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 1 ][ 1 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 1 ][ 2 ] )
                        write_short(laser) // sprite index
                        write_byte(3) // starting frame
                        write_byte(0) // frame rate in 0.1's
                        write_byte(1) // life in 0.1's
                        write_byte(10) // line width in 0.1's
                        write_byte(0) // noise amplitude in 0.01's
                        write_byte(iRed)
                        write_byte(iGreen)
                        write_byte(iBlue)
                        write_byte(Brightness)
                        write_byte(0) // scroll speed in 0.1's
                        message_end()
                               
                        message_begin(MSG_ONE_UNRELIABLE ,SVC_TEMPENTITY,{0,0,0},id) //message begin
                        write_byte(0)
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 0 ][ 0 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 0 ][ 1 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 0 ][ 2 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 2 ][ 0 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 2 ][ 1 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 2 ][ 2 ] )
                        write_short(laser) // sprite index
                        write_byte(3) // starting frame
                        write_byte(0) // frame rate in 0.1's
                        write_byte(1) // life in 0.1's
                        write_byte(10) // line width in 0.1's
                        write_byte(0) // noise amplitude in 0.01's
                        write_byte(iRed)
                        write_byte(iGreen)
                        write_byte(iBlue)
                        write_byte(Brightness)
                        write_byte(0) // scroll speed in 0.1's
                        message_end()
                               
                        message_begin(MSG_ONE_UNRELIABLE ,SVC_TEMPENTITY,{0,0,0},id) //message begin
                        write_byte(0)
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 2 ][ 0 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 2 ][ 1 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 2 ][ 2 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 3 ][ 0 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 3 ][ 1 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 3 ][ 2 ] )
                        write_short(laser) // sprite index
                        write_byte(3) // starting frame
                        write_byte(0) // frame rate in 0.1's
                        write_byte(1) // life in 0.1's
                        write_byte(10) // line width in 0.1's
                        write_byte(0) // noise amplitude in 0.01's
                        write_byte(iRed)
                        write_byte(iGreen)
                        write_byte(iBlue)
                        write_byte(Brightness)
                        write_byte(0) // scroll speed in 0.1's
                        message_end()
                       
                        message_begin(MSG_ONE_UNRELIABLE ,SVC_TEMPENTITY,{0,0,0},id) //message begin
                        write_byte(0)
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 3 ][ 0 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 3 ][ 1 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 3 ][ 2 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 1 ][ 0 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 1 ][ 1 ] )
                        engfunc( EngFunc_WriteCoord , fFourPoints [ 1 ][ 2 ] )
                        write_short(laser) // sprite index
                        write_byte(3) // starting frame
                        write_byte(0) // frame rate in 0.1's
                        write_byte(1) // life in 0.1's
                        write_byte(10) // line width in 0.1's
                        write_byte(0) // noise amplitude in 0.01's
                        write_byte(iRed)
                        write_byte(iGreen)
                        write_byte(iBlue)
                        write_byte(Brightness)
                        write_byte(0) // scroll speed in 0.1's
                        message_end()
                }
        }
}
stock ScreenFade(id, active, red, green, blue, alpha)
{
        if(!active || get_user_weapon(id) != CSW_BASEDON || !Get_BitVar(g_Had_Weapon2, id) ||!Get_BitVar(g_System, id))
        {
                message_begin(MSG_ONE, get_user_msgid( "ScreenFade"), _, id)
                write_short(0) // duration
                write_short(0) // hold time
                write_short(0x0000) // fade type
                write_byte(255) // red
                write_byte(100) // green
                write_byte(100) // blue
                write_byte(140) // alpha
                message_end()
               
        } else {
               
                message_begin(MSG_ONE, get_user_msgid( "ScreenFade"), _, id)
                write_short((1<<12)*2) // duration
                write_short((1<<10)*10) // hold time
                write_short(0x0004) // fade type
                write_byte(red) // red
                write_byte(green) // green
                write_byte(blue) // blue
                write_byte(alpha) // alpha
                message_end()
        }
}
public Stock_Fake_KnockBack(id, iVic, Float:iKb)
{
        if(iVic > 32) return
       
        new Float:vAttacker[3], Float:vVictim[3], Float:vVelocity[3], flags
        pev(id, pev_origin, vAttacker)
        pev(iVic, pev_origin, vVictim)
        vAttacker[2] = vVictim[2] = 0.0
        flags = pev(id, pev_flags)
       
        xs_vec_sub(vVictim, vAttacker, vVictim)
        new Float:fDistance
        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)
        xs_vec_mul_scalar(vVictim, 50.0, vVictim)
        vVictim[2] = xs_vec_len(vVictim) * 0.15
       
        if(flags &~ FL_ONGROUND)
        {
                xs_vec_mul_scalar(vVictim, 1.2, vVictim)
                vVictim[2] *= 0.4
        }
        if(xs_vec_len(vVictim) > xs_vec_len(vVelocity)) set_pev(iVic, pev_velocity, vVictim)
}       
stock KnifeAttack_Global(id, bStab, Float:flRange, Float:fAngle, Float:flDamage, Float:flKnockBack)
{
        new iHitResult
        if(fAngle > 0.0) iHitResult = KnifeAttack2(id, bStab, Float:flRange, Float:fAngle, Float:flDamage, Float:flKnockBack)
        else iHitResult = KnifeAttack(id, bStab, Float:flRange, Float:flDamage, Float:flKnockBack)

        return iHitResult
}
stock KnifeAttack(id, bStab, Float:flRange, Float:flDamage, Float:flKnockBack, iHitgroup = -1, bitsDamageType = DMG_NEVERGIB | DMG_CLUB)
{
        new Float:vecSrc[3], Float:vecEnd[3], Float:v_angle[3], Float:vecForward[3];
        GetGunPosition(id, vecSrc);

        pev(id, pev_v_angle, v_angle);
        engfunc(EngFunc_MakeVectors, v_angle);

        global_get(glb_v_forward, vecForward);
        xs_vec_mul_scalar(vecForward, flRange, vecForward);
        xs_vec_add(vecSrc, vecForward, vecEnd);

        new tr = create_tr2();
        engfunc(EngFunc_TraceLine, vecSrc, vecEnd, 0, id, tr);

        new Float:flFraction; get_tr2(tr, TR_flFraction, flFraction);
        if (flFraction >= 1.0) engfunc(EngFunc_TraceHull, vecSrc, vecEnd, 0, 3, id, tr);
       
        get_tr2(tr, TR_flFraction, flFraction);

        new iHitResult = RESULT_HIT_NONE;
       
        if (flFraction < 1.0)
        {
                new pEntity = get_tr2(tr, TR_pHit);
                iHitResult = RESULT_HIT_WORLD;
               
                if (pev_valid(pEntity) && (IsPlayer(pEntity) || IsHostage(pEntity)))
                {
                        if (CheckBack(id, pEntity) && bStab && iHitgroup == -1)
                                flDamage *= 1.0;

                        iHitResult = RESULT_HIT_PLAYER;
                }

                if (pev_valid(pEntity))
                {
                        engfunc(EngFunc_MakeVectors, v_angle);
                        global_get(glb_v_forward, vecForward);

                        if (iHitgroup != -1)
                                set_tr2(tr, TR_iHitgroup, iHitgroup);

                        ExecuteHamB(Ham_TraceAttack, pEntity, id, flDamage, vecForward, tr, bitsDamageType);
                        ExecuteHamB(Ham_TakeDamage, pEntity, id, id, flDamage, bitsDamageType)
                        Stock_Fake_KnockBack(id, pEntity, flKnockBack)
                       
                        if (IsAlive(pEntity))
                        {
                                free_tr2(tr);
                                return iHitResult;
                        }
                }
        }
        free_tr2(tr);
        return iHitResult;
}
stock KnifeAttack2(id, bStab, Float:flRange, Float:fAngle, Float:flDamage, Float:flKnockBack, iHitgroup = -1, bNoTraceCheck = 0)
{
        new Float:vecOrigin[3], Float:vecSrc[3], Float:vecEnd[3], Float:v_angle[3], Float:vecForward[3];
        pev(id, pev_origin, vecOrigin);

        new iHitResult = RESULT_HIT_NONE;
        GetGunPosition(id, vecSrc);

        pev(id, pev_v_angle, v_angle);
        engfunc(EngFunc_MakeVectors, v_angle);

        global_get(glb_v_forward, vecForward);
        xs_vec_mul_scalar(vecForward, flRange, vecForward);
        xs_vec_add(vecSrc, vecForward, vecEnd);

        new tr = create_tr2();
        engfunc(EngFunc_TraceLine, vecSrc, vecEnd, 0, id, tr);
       
        new Float:EndPos2[3]
        get_tr2(tr, TR_vecEndPos, EndPos2)
       
        new Float:flFraction; get_tr2(tr, TR_flFraction, flFraction);
        if (flFraction < 1.0)
        {
                iHitResult = RESULT_HIT_WORLD;
        }
       
        new Float:vecEndZ = vecEnd[2];
       
        new pEntity = -1;
        while ((pEntity = engfunc(EngFunc_FindEntityInSphere, pEntity, vecOrigin, flRange)) != 0)
        {
                if (!pev_valid(pEntity))
                        continue;
                if (IsPlayerTeam(id) == IsPlayerTeam(pEntity))
                        continue;
                if (!IsAlive(pEntity))
                        continue;
                if (!CheckAngle(id, pEntity, fAngle))
                        continue;

                GetGunPosition(id, vecSrc);
                Stock_Get_Origin(pEntity, vecEnd);

                vecEnd[2] = vecSrc[2] + (vecEndZ - vecSrc[2]) * (get_distance_f(vecSrc, vecEnd) / flRange);

                xs_vec_sub(vecEnd, vecSrc, vecForward);
                xs_vec_normalize(vecForward, vecForward);
                xs_vec_mul_scalar(vecForward, flRange, vecForward);
                xs_vec_add(vecSrc, vecForward, vecEnd);

                engfunc(EngFunc_TraceLine, vecSrc, vecEnd, 0, id, tr);
                get_tr2(tr, TR_flFraction, flFraction);

                if (flFraction >= 1.0) engfunc(EngFunc_TraceHull, vecSrc, vecEnd, 0, 3, id, tr);
                get_tr2(tr, TR_flFraction, flFraction);

                if (flFraction < 1.0)
                {
                        if (IsPlayer(pEntity) || IsHostage(pEntity))
                        {
                                iHitResult = RESULT_HIT_PLAYER;
                               
                                if (CheckBack(id, pEntity) && bStab && iHitgroup == -1)
                                        flDamage *= 1.0;
                        }

                        if (get_tr2(tr, TR_pHit) == pEntity || bNoTraceCheck)
                        {
                                engfunc(EngFunc_MakeVectors, v_angle);
                                global_get(glb_v_forward, vecForward);

                                if (iHitgroup != -1) set_tr2(tr, TR_iHitgroup, iHitgroup);
                               
                                new Float:VecVic[3]; pev(pEntity, pev_origin, VecVic)
                                if(IsAlive(pEntity) && zp_get_user_zombie(pEntity)) Create_Tracer(id, VecVic)

                                ExecuteHamB(Ham_TraceAttack, pEntity, id, flDamage, vecForward, tr, DMG_NEVERGIB | DMG_BULLET);
                                ExecuteHamB(Ham_TakeDamage, pEntity, id, id, flDamage, DMG_NEVERGIB | DMG_BULLET)
                               
                                Stock_Fake_KnockBack(id, pEntity, flKnockBack)
                        }
                }
                free_tr2(tr);
        }
        return iHitResult;
}
stock KnifeAttack3(id, bStab, Float:flRange, Float:fAngle, Float:flDamage, Float:flKnockBack, iHitgroup = -1, bNoTraceCheck = 0)
{
        new Float:vecOrigin[3], Float:vecSrc[3], Float:vecEnd[3], Float:v_angle[3], Float:vecForward[3];
        pev(id, pev_origin, vecOrigin);

        new iHitResult = RESULT_HIT_NONE;
        GetGunPosition(id, vecSrc);

        pev(id, pev_v_angle, v_angle);
        engfunc(EngFunc_MakeVectors, v_angle);

        global_get(glb_v_forward, vecForward);
        xs_vec_mul_scalar(vecForward, flRange, vecForward);
        xs_vec_add(vecSrc, vecForward, vecEnd);

        new tr = create_tr2();
        engfunc(EngFunc_TraceLine, vecSrc, vecEnd, 0, id, tr);
       
        new Float:EndPos2[3]
        get_tr2(tr, TR_vecEndPos, EndPos2)
       
        new Float:flFraction; get_tr2(tr, TR_flFraction, flFraction);
        if (flFraction < 1.0) iHitResult = RESULT_HIT_WORLD;
       
        new Float:vecEndZ = vecEnd[2];
       
        new pEntity = -1;
        while ((pEntity = engfunc(EngFunc_FindEntityInSphere, pEntity, vecOrigin, flRange)) != 0)
        {
                if (!pev_valid(pEntity))
                        continue;
                if (IsPlayerTeam(id) == IsPlayerTeam(pEntity))
                        continue;
                if (!IsAlive(pEntity) && !zp_get_user_zombie(pEntity))
                        continue;
                if (!can_damage(id, pEntity))
                        continue
                if (Stock_CheckAngle(id, pEntity) > floatcos(fAngle,degrees))
                        continue;

                GetGunPosition(id, vecSrc);
                pev(pEntity, pev_origin, vecEnd);

                vecEnd[2] = vecSrc[2] + (vecEndZ - vecSrc[2]) * (get_distance_f(vecSrc, vecEnd) / flRange);

                xs_vec_sub(vecEnd, vecSrc, vecForward);
                xs_vec_normalize(vecForward, vecForward);
                xs_vec_mul_scalar(vecForward, flRange, vecForward);
                xs_vec_add(vecSrc, vecForward, vecEnd);

                engfunc(EngFunc_TraceLine, vecSrc, vecEnd, 0, id, tr);
                get_tr2(tr, TR_flFraction, flFraction);

                if (flFraction >= 1.0) engfunc(EngFunc_TraceHull, vecSrc, vecEnd, 0, 3, id, tr);
                get_tr2(tr, TR_flFraction, flFraction);

                if (flFraction < 1.0)
                {
                        if (IsPlayer(pEntity) || IsHostage(pEntity))
                        {
                                iHitResult = RESULT_HIT_PLAYER;
                               
                                if (CheckBack(id, pEntity) && bStab && iHitgroup == -1)
                                        flDamage *= 1.0;
                        }

                        if (get_tr2(tr, TR_pHit) == pEntity || bNoTraceCheck)
                        {
                                engfunc(EngFunc_MakeVectors, v_angle);
                                global_get(glb_v_forward, vecForward);

                                if (iHitgroup != -1) set_tr2(tr, TR_iHitgroup, iHitgroup);
                                ExecuteHamB(Ham_TraceAttack, pEntity, id, 1.0, vecForward, tr, DMG_NEVERGIB | DMG_CLUB);
                                ExecuteHamB(Ham_TakeDamage, pEntity, id, id, flDamage, DMG_NEVERGIB | DMG_CLUB)
                                Stock_Fake_KnockBack(id, pEntity, flKnockBack)
                        }
                }
                free_tr2(tr);
        }
        return iHitResult;
}
stock can_damage(id1, id2)
{
        if(id1 <= 0 || id1 >= 33 || id2 <= 0 || id2 >= 33)
                return 1
               
        // Check team
        return(get_pdata_int(id1, 114, 5) != get_pdata_int(id2, 114, 5))
}
stock Stock_Get_Origin(id, Float:origin[3])
{
        new Float:maxs[3],Float:mins[3]
        if (pev(id, pev_solid) == SOLID_BSP)
        {
                pev(id,pev_maxs,maxs)
                pev(id,pev_mins,mins)
                origin[0] = (maxs[0] - mins[0]) / 2 + mins[0]
                origin[1] = (maxs[1] - mins[1]) / 2 + mins[1]
                origin[2] = (maxs[2] - mins[2]) / 2 + mins[2]
        } else pev(id, pev_origin, origin)
}
stock GetGunPosition(id, Float:vecScr[3])
{
        new Float:vecViewOfs[3]
        pev(id, pev_origin, vecScr)
        pev(id, pev_view_ofs, vecViewOfs)
        xs_vec_add(vecScr, vecViewOfs, vecScr)
}

stock CheckBack(iEnemy,id)
{
        new Float:anglea[3], Float:anglev[3]
        pev(iEnemy, pev_v_angle, anglea)
        pev(id, pev_v_angle, anglev)
        new Float:angle = anglea[1] - anglev[1]
        if (angle < -180.0) angle += 360.0
        if (angle <= 45.0 && angle >= -45.0) return 1
        return 0
}

stock CheckAngle(iAttacker, iVictim, Float:fAngle)  return(Stock_CheckAngle(iAttacker, iVictim) > floatcos(fAngle,degrees))

stock Float:Stock_CheckAngle(id,iTarget)
{
        new Float:vOricross[2],Float:fRad,Float:vId_ori[3],Float:vTar_ori[3],Float:vId_ang[3],Float:fLength,Float:vForward[3]
        Stock_Get_Origin(id, vId_ori)
        Stock_Get_Origin(iTarget, vTar_ori)
       
        pev(id,pev_angles,vId_ang)
        for(new i=0;i<2;i++) vOricross = vTar_ori - vId_ori
       
        fLength = floatsqroot(vOricross[0]*vOricross[0] + vOricross[1]*vOricross[1])
       
        if (fLength<=0.0)
        {
                vOricross[0]=0.0
                vOricross[1]=0.0
        } else {
                vOricross[0]=vOricross[0]*(1.0/fLength)
                vOricross[1]=vOricross[1]*(1.0/fLength)
        }
       
        engfunc(EngFunc_MakeVectors,vId_ang)
        global_get(glb_v_forward,vForward)
       
        fRad = vOricross[0]*vForward[0]+vOricross[1]*vForward[1]
       
        return fRad  //->  RAD 90' = 0.5rad
}
stock IsPlayer(pEntity) return is_user_connected(pEntity)
stock IsPlayerTeam(pEntity) return get_user_team(pEntity)
stock Stock_BloodEffect(Float:vecOri[3], scale)
{
        message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
        write_byte(TE_BLOODSPRITE)
        engfunc(EngFunc_WriteCoord,vecOri[0])
        engfunc(EngFunc_WriteCoord,vecOri[1])
        engfunc(EngFunc_WriteCoord,vecOri[2])
        write_short(spr_blood_spray)
        write_short(spr_blood_drop)
        write_byte(75)
        write_byte(scale)
        message_end()
}
stock IsHostage(pEntity)
{
        new classname[32]; pev(pEntity, pev_classname, classname, charsmax(classname))
        return equal(classname, "hostage_entity")
}

stock IsAlive(pEntity)
{
        if (pEntity < 1) return 0
        return (pev(pEntity, pev_deadflag) == DEAD_NO && pev(pEntity, pev_health) > 0)
}
stock Get_Position(id,Float:forw, Float:right, Float:up, Float:vStart[])
{
        static Float:vOrigin[3], Float:vAngle[3], Float:vForward[3], Float:vRight[3], Float:vUp[3]
       
        pev(id, pev_origin, vOrigin)
        pev(id, pev_view_ofs,vUp) //for player
        xs_vec_add(vOrigin,vUp,vOrigin)
        pev(id, pev_v_angle, vAngle) // if normal entity ,use pev_angles
       
        angle_vector(vAngle,ANGLEVECTOR_FORWARD,vForward) //or use EngFunc_AngleVectors
        angle_vector(vAngle,ANGLEVECTOR_RIGHT,vRight)
        angle_vector(vAngle,ANGLEVECTOR_UP,vUp)
       
        vStart[0] = vOrigin[0] + vForward[0] * forw + vRight[0] * right + vUp[0] * up
        vStart[1] = vOrigin[1] + vForward[1] * forw + vRight[1] * right + vUp[1] * up
        vStart[2] = vOrigin[2] + vForward[2] * forw + vRight[2] * right + vUp[2] * up
}
stock Set_WeaponIdleTime(id, WeaponId ,Float:TimeIdle)
{
        static entwpn; entwpn = fm_get_user_weapon_entity(id, WeaponId)
        if(!pev_valid(entwpn))
                return
               
        set_pdata_float(entwpn, 46, TimeIdle, 4)
        set_pdata_float(entwpn, 47, TimeIdle, 4)
        set_pdata_float(entwpn, 48, TimeIdle, 4)
}

stock Set_PlayerNextAttack(id, Float:nexttime)
{
        set_pdata_float(id, 83, nexttime, 5)
}

Przeczytaj cały wpis

Odnośnik do komentarza
Udostępnij na innych stronach

Gość
Ten temat został zamknięty. Brak możliwości dodania odpowiedzi.
 Udostępnij

×
×
  • Dodaj nową pozycję...