AlliedModders

AlliedModders (https://forums.alliedmods.net/index.php)
-   Scripting Help (https://forums.alliedmods.net/forumdisplay.php?f=11)
-   -   Solved Beretta Gunslinger little problem (https://forums.alliedmods.net/showthread.php?t=333891)

zollymaN 08-14-2021 11:44

Beretta Gunslinger little problem
 
I have a small problem this weapon activates its ability especially when all the bullets are fired, but those with VIP have infinite bullets and the ability does not activate what can I do?
I use the vip plugin 1.7.2 from this site

Code:

#include <amxmodx>
#include <fakemeta>
#include <engine>
#include <fakemeta_util>
#include <hamsandwich>
#include <cstrike>
#include <fun>
#include <zp_apocalypse>
#include <zp50_colorchat>

#define PLUGIN "[Luna's Weapon] Dual Beretta Gunslinger"
#define VERSION "1.0.2"
#define AUTHOR "Celena Lunan/Aoki Melodia"

#define V_MODEL "models/v_gunkata.mdl"
#define P_MODEL "models/p_gunkata.mdl"
#define W_MODEL "models/w_gunkata.mdl"
#define EF_HOLE "models/ef_hole.mdl"

#define S_Shoot "weapons/gunkata-1.wav"

#define EXP_CLASSNAME "ef_hole_cso"

new const WeaponSkillSounds[7][] =
{
        "weapons/gunkata_skill_01.wav",
        "weapons/gunkata_skill_02.wav",
        "weapons/gunkata_skill_03.wav",
        "weapons/gunkata_skill_04.wav",
        "weapons/gunkata_skill_05.wav",
        "weapons/gunkata_skill_last.wav",
        "weapons/gunkata_skill_last_exp.wav"

}

#define SECRET_CODE 312512

#define TASK_DRAW 1000
#define TASK_EXPLODE 1100

const PDATA_SAFE = 2
const OFFSET_LINUX_WEAPONS = 4
const OFFSET_WEAPONOWNER = 41

enum
{
        ANIM_IDLE = 0,
        ANIM_IDLE2,
        ANIM_SHOOT,
        ANIM_SHOOT_LAST,
        ANIM_SHOOT2,
        ANIM_SHOOT2_LAST,
        ANIM_RELOAD,
        ANIM_RELOAD2,
        ANIM_DRAW,
        ANIM_DRAW2,
        ANIM_SKILL1,
        ANIM_SKILL2,
        ANIM_SKILL3,
        ANIM_SKILL4,
        ANIM_SKILL5,
        ANIM_SKILL_END
}

#define DRAW_TIME 0.75
#define RELOAD_TIME 2.0

#define DAMAGEA 34
#define DAMAGEB 30
#define CLIP 36
#define SPEED 0.07
#define BPAMMO 200
#define SPEED_B 0.1
#define RECOIL 0.05
#define ATTACK_DISTANCE 250.0
#define KB_POWER 50.0

#define WEAPON_EVENT "events/elite.sc"
#define OLD_W_MODEL "models/w_elite.mdl"

// 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))

new g_shoot_counter[33], g_Clip[33], g_OldWeapon[33], g_skill_counter[33], Float:g_Recoil[33], g_Weapon
new g_dbg_event
new g_Had_Beretta, g_Shoot_R, g_InSpecial, g_StartSpecial, g_BlockReload
new g_SmokePuff_SprId

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

        register_event("CurWeapon", "Event_CurWeapon", "be", "1=1")
        register_event("DeathMsg", "Event_MsgDeath", "a")

        register_forward(FM_UpdateClientData, "fw_UpdateClientData_Post", 1)       
        register_forward(FM_PlaybackEvent, "fw_PlaybackEvent")       
        register_forward(FM_SetModel, "fw_SetModel")

        RegisterHam(Ham_Item_Deploy, "weapon_elite", "fw_Item_Deploy_Post", 1)
        RegisterHam(Ham_Item_AddToPlayer, "weapon_elite", "fw_Item_AddToPlayer_Post", 1)       
        RegisterHam(Ham_Item_PostFrame, "weapon_elite", "fw_Item_PostFrame")       
        RegisterHam(Ham_Weapon_Reload, "weapon_elite", "fw_Weapon_Reload")
        RegisterHam(Ham_Weapon_Reload, "weapon_elite", "fw_Weapon_Reload_Post", 1)
        RegisterHam(Ham_Weapon_WeaponIdle, "weapon_elite", "fw_Weapon_WeaponIdle_Post", 1)
        RegisterHam(Ham_Weapon_PrimaryAttack, "weapon_elite", "fw_Weapon_PrimaryAttack_Pre", false)
        RegisterHam(Ham_Weapon_PrimaryAttack, "weapon_elite", "fw_Weapon_PrimaryAttack_Post", true)
        RegisterHam(Ham_Weapon_SecondaryAttack, "weapon_elite", "fw_Weapon_SecondaryAttack_Pre", false)
        RegisterHam(Ham_Item_Holster, "weapon_elite", "fw_Item_Holster_Post", 1)
        RegisterHam(Ham_TraceAttack, "worldspawn", "fw_TraceAttack_World", 1)
        RegisterHam(Ham_TraceAttack, "player", "fw_TraceAttack", 1)

        RegisterHam(Ham_Spawn, "player", "fw_Spawn_Post", 1)

        register_think(EXP_CLASSNAME, "EXP_Think")

        g_Weapon = zp_register_extra_item("Dual Beretta Gunslinger", 60, ZP_TEAM_HUMAN)
}

public plugin_precache()
{
        engfunc(EngFunc_PrecacheModel, V_MODEL)
        engfunc(EngFunc_PrecacheModel, P_MODEL)
        engfunc(EngFunc_PrecacheModel, W_MODEL)
        engfunc(EngFunc_PrecacheModel, EF_HOLE)

        precache_sound(S_Shoot)

        for(new i = 0; i < sizeof(WeaponSkillSounds); i++)
                precache_sound(WeaponSkillSounds[i])

        g_SmokePuff_SprId = engfunc(EngFunc_PrecacheModel, "sprites/wall_puff1.spr")

        register_forward(FM_PrecacheEvent, "fw_PrecacheEvent_Post", 1)
}

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

public client_disconnect(id)
{
        Remove_Beretta(id)
}

public Event_MsgDeath()
{
        static id; id = read_data(2)
        Remove_Beretta(id)
}

public fw_Spawn_Post(id)
{
        Remove_Beretta(id)
}

public zp_user_infected_post(id)
{
        if (zp_get_user_zombie(id))
        {
                Remove_Beretta(id)
        }
}

public zp_extra_item_selected(id, itemid)
{
        if ( itemid == g_Weapon )
        {
                if ( user_has_weapon(id, CSW_ELITE) )
                {
                        drop_usp(id)
                }
               
                Get_Beretta(id)
                zp_colored_print(id, "^x04[ZP] ^x01 You have bought Dual Beretta Gunslinger")
        }
}

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

        Set_BitVar(g_Had_Beretta, id)
        UnSet_BitVar(g_Shoot_R, id)

        give_item(id, "weapon_elite")

        static Ent; Ent = fm_get_user_weapon_entity(id, CSW_ELITE)
        if(pev_valid(Ent)) cs_set_weapon_ammo(Ent, CLIP)
        cs_set_user_bpammo(id, CSW_ELITE, BPAMMO)
        ExecuteHamB(Ham_Item_Deploy, Ent)
        g_skill_counter[id] = ANIM_SKILL1
}

public Remove_Beretta(id)
{
        UnSet_BitVar(g_Had_Beretta, id)
        UnSet_BitVar(g_Shoot_R, id)
        UnSet_BitVar(g_BlockReload, id)
        UnSet_BitVar(g_InSpecial, id)
        UnSet_BitVar(g_StartSpecial, id)
        g_skill_counter[id] = 0
        g_shoot_counter[id] = 0
        if(task_exists(id+TASK_DRAW)) remove_task(id+TASK_DRAW)
        if(task_exists(id+TASK_EXPLODE)) remove_task(id+TASK_EXPLODE)
}


public Event_CurWeapon(id)
{
        static CSWID; CSWID = read_data(2)
       
        if((CSWID == CSW_ELITE && g_OldWeapon[id] != CSW_ELITE) && Get_BitVar(g_Had_Beretta, id))
        {
                Draw_NewWeapon(id, CSWID)
        } else if((CSWID == CSW_ELITE && g_OldWeapon[id] == CSW_ELITE) && Get_BitVar(g_Had_Beretta, id)) {
                static Ent; Ent = fm_get_user_weapon_entity(id, CSW_ELITE)
                if(!pev_valid(Ent))
                {
                        g_OldWeapon[id] = get_user_weapon(id)
                        return
                }
               
                if(!Get_BitVar(g_InSpecial, id))
                {
                        if(g_shoot_counter[id] == 0)
                        {
                                set_pdata_float(Ent, 46, 0.4, 4)
                                set_pdata_float(Ent, 47, 0.4, 4)
                        }
                        else
                        {
                                set_pdata_float(Ent, 46, SPEED, 4)
                                set_pdata_float(Ent, 47, SPEED, 4)
                        }
                }
               
        } else if(CSWID != CSW_ELITE && g_OldWeapon[id] == CSW_ELITE) Draw_NewWeapon(id, CSWID)
       
        g_OldWeapon[id] = get_user_weapon(id)
}

public Draw_NewWeapon(id, CSW_ID)
{
        if(CSW_ID == CSW_ELITE)
        {
                static ent
                ent = fm_get_user_weapon_entity(id, CSW_ELITE)
               
                if(pev_valid(ent) && Get_BitVar(g_Had_Beretta, id))
                {
                        set_pev(ent, pev_effects, pev(ent, pev_effects) &~ EF_NODRAW)
                        engfunc(EngFunc_SetModel, ent, P_MODEL)       
                }
        } else {
                static ent
                ent = fm_get_user_weapon_entity(id, CSW_ELITE)
               
                if(pev_valid(ent)) set_pev(ent, pev_effects, pev(ent, pev_effects) | EF_NODRAW)                       
        }
}

public Get_Beretta2(id)
{
        //Make_FakeHand(id, ANIM_SKILL5, 5.0)
}

public fw_UpdateClientData_Post(id, sendweapons, cd_handle)
{
        if(!is_user_alive(id))
                return FMRES_IGNORED       
        if(get_user_weapon(id) == CSW_ELITE && Get_BitVar(g_Had_Beretta, 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_alive(invoker))
                return FMRES_IGNORED       
        if(get_user_weapon(invoker) != CSW_ELITE || !Get_BitVar(g_Had_Beretta, invoker))
                return FMRES_IGNORED
       
        if(eventid == g_dbg_event)
        {
                engfunc(EngFunc_PlaybackEvent, flags | FEV_HOSTONLY, invoker, eventid, delay, origin, angles, fparam1, fparam2, iParam1, iParam2, bParam1, bParam2)
                if(!Get_BitVar(g_InSpecial, invoker))
                {
                        if(Get_BitVar(g_Shoot_R, invoker))
                        {
                                if(g_shoot_counter[invoker] == 2) set_weapon_anim(invoker, ANIM_SHOOT2_LAST)
                                else set_weapon_anim(invoker, ANIM_SHOOT2)
                        }
                        else
                        {
                                if(g_shoot_counter[invoker] == 2) set_weapon_anim(invoker, ANIM_SHOOT_LAST)
                                else set_weapon_anim(invoker, ANIM_SHOOT)
                        }

                        emit_sound(invoker, CHAN_WEAPON, S_Shoot, 1.0, 0.4, 0, 94 + random_num(0, 15))
                }
                else
                {
                        if(g_shoot_counter[invoker] == 2) Weapon_Skill(invoker)
                }
               
                if(g_shoot_counter[invoker] == 2)
                {
                        g_shoot_counter[invoker] = 0
                        if(Get_BitVar(g_Shoot_R, invoker))        UnSet_BitVar(g_Shoot_R, invoker)
                        else Set_BitVar(g_Shoot_R, invoker)
                }
                else
                {
                        g_shoot_counter[invoker] += 1
                }

                return FMRES_SUPERCEDE
        }
       
        return FMRES_HANDLED
}

public fw_Item_PostFrame(ent)
{
        static id; id = pev(ent, pev_owner)
        if(!is_user_alive(id))
                return HAM_IGNORED
        if(!Get_BitVar(g_Had_Beretta, id))
                return HAM_IGNORED       
       
        static Float:flNextAttack; flNextAttack = get_pdata_float(id, 83, 5)
        static Float:flNextSecondaryAttack; flNextSecondaryAttack = get_pdata_float(ent, 47, 4)
        static bpammo; bpammo = cs_get_user_bpammo(id, CSW_ELITE)
       
        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_ELITE, bpammo - temp1)               
               
                set_pdata_int(ent, 54, 0, 4)
               
                fInReload = 0
        }
        else
        {
                new iButton = pev(id, pev_button)
               
                if((iButton & IN_ATTACK2))
                {
                        if(flNextAttack <= 0 && flNextSecondaryAttack <= 0 && iClip)
                        {
                                Set_BitVar(g_InSpecial, id)
                                if(!Get_BitVar(g_StartSpecial, id))
                                {
                                        g_shoot_counter[id] = 2
                                        g_skill_counter[id] = ANIM_SKILL1
                                        Set_BitVar(g_StartSpecial, id)
                                }
                                ExecuteHamB(Ham_Weapon_PrimaryAttack, ent)
                                set_pdata_float(ent, 46, SPEED_B, 4)
                                set_pdata_float(ent, 47, SPEED_B, 4)
                                if(task_exists(id+TASK_DRAW)) remove_task(id+TASK_DRAW)
                                set_task(1.0, "Draw_AnimWeapon", id+TASK_DRAW)
                                Set_BitVar(g_BlockReload, id)
                        }
                        else
                        {
                                if(!iClip && Get_BitVar(g_InSpecial, id))
                                {
                                        UnSet_BitVar(g_BlockReload, id)
                                        ExecuteHamB(Ham_Weapon_Reload, ent)
                                        return HAM_HANDLED
                                }
                        }
                       
                        iButton &= ~IN_ATTACK2
                        //iButton &= ~IN_ATTACK
                        set_pev(id, pev_button, iButton)
                }
                else if((iButton & IN_ATTACK))
                {
                        UnSet_BitVar(g_BlockReload, id)
                        UnSet_BitVar(g_InSpecial, id)
                }
        }
       
        return HAM_IGNORED
}

public Weapon_Skill(id)
{
        g_skill_counter[id] += 1
        if(g_skill_counter[id] > ANIM_SKILL5) g_skill_counter[id] = ANIM_SKILL1

        set_weapon_anim(id, g_skill_counter[id])
        emit_sound(id, CHAN_AUTO, WeaponSkillSounds[g_skill_counter[id]-10], 1.0, 0.4, 0, 94 + random_num(0, 15))
}

Explode_Exp(id)
{
        static Origin[3], Float:fOrigin[3]
       
        get_user_origin(id, Origin, 1)
        IVecFVec(Origin, fOrigin)
       
        static Ent; Ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))

        set_pev(Ent, pev_classname, EXP_CLASSNAME)
       
        get_position(id, 0.0, 0.0, -15.0, fOrigin)
        set_pev(Ent, pev_origin, fOrigin)

        set_pev(Ent, pev_scale, 0.05)

        set_entity_anim(Ent, 1, 1)

        set_pev(Ent, pev_fuser1, get_gametime() + 0.5)

        set_pev(Ent, pev_owner, id)

        set_pev(Ent, pev_nextthink, get_gametime()+0.1)
       
        engfunc(EngFunc_SetModel, Ent, EF_HOLE)
}

public EXP_Think(iEnt)
{
        new Float:endtime;
        endtime = entity_get_float(iEnt, EV_FL_fuser1)

        if(!pev_valid(iEnt))       
                return

        if(endtime <= get_gametime())
        {
                entity_set_int(iEnt, EV_INT_flags, FL_KILLME)
                remove_entity(iEnt)
                return
        }

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

public fw_Item_Deploy_Post(Ent)
{
        if(pev_valid(Ent) != 2)
                return
        static Id; Id = get_pdata_cbase(Ent, 41, 4)
        if(get_pdata_cbase(Id, 373) != Ent)
                return
        if(!Get_BitVar(g_Had_Beretta, Id))
                return
       
        set_pev(Id, pev_viewmodel2, V_MODEL)
        set_pev(Id, pev_weaponmodel2, P_MODEL)
       
        static Draw; Draw = Get_BitVar(g_Shoot_R, Id) ? ANIM_DRAW2 : ANIM_DRAW
        if(Draw != -1) set_weapon_anim(Id, Get_BitVar(g_Shoot_R, Id) ? ANIM_DRAW2 : ANIM_DRAW)

        UnSet_BitVar(g_InSpecial, Id)
        UnSet_BitVar(g_StartSpecial, Id)
        UnSet_BitVar(g_BlockReload, Id)
}

public fw_Item_AddToPlayer_Post(Ent, id)
{
        if(!pev_valid(Ent))
                return HAM_IGNORED
               
        if(pev(Ent, pev_impulse) == SECRET_CODE)
        {
                Set_BitVar(g_Had_Beretta, id)
               
                set_pev(Ent, pev_impulse, 0)
        }
       
        return HAM_HANDLED       
}

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_Beretta, id))
                return HAM_IGNORED
        if(Get_BitVar(g_BlockReload, id))
                return HAM_SUPERCEDE

        g_Clip[id] = -1
               
        static BPAmmo; BPAmmo = cs_get_user_bpammo(id, CSW_ELITE)
        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_Beretta, id))
                return HAM_IGNORED
               
        if((get_pdata_int(ent, 54, 4) == 1))
        { // Reload
                if(g_Clip[id] == -1)
                        return HAM_IGNORED
               
                set_pdata_int(ent, 51, g_Clip[id], 4)
               
                if(Get_BitVar(g_InSpecial, id))
                {
                        if(task_exists(id+TASK_DRAW)) remove_task(id+TASK_DRAW)
                        set_weapon_anim(id, ANIM_SKILL_END)
                        set_task(0.5, "Explode", id+TASK_EXPLODE)
                        set_task(1.0, "Draw_AnimWeapon", id+TASK_DRAW)
                        set_weapon_timeidle(id, CSW_ELITE, 1.0)
                        set_player_nextattack(id, 1.0)
                }
                else
                {
                        if(random_num(0, 1) == 1) set_weapon_anim(id, ANIM_RELOAD)
                        else set_weapon_anim(id, ANIM_RELOAD2)
                        set_weapon_timeidle(id, CSW_ELITE, RELOAD_TIME)
                        set_player_nextattack(id, RELOAD_TIME)
                }
               
                //set_weapon_timeidle(id, CSW_ELITE, RELOAD_TIME)
                //set_player_nextattack(id, RELOAD_TIME)
                g_shoot_counter[id] = 0
                UnSet_BitVar(g_Shoot_R, id)
        }
       
        return HAM_HANDLED
}

public fw_Weapon_WeaponIdle_Post(ent)
{
        static id; id = pev(ent, pev_owner)
        if(!is_user_alive(id))
                return HAM_IGNORED
        if(!Get_BitVar(g_Had_Beretta, id))
                return HAM_IGNORED
               
        if(get_pdata_float(ent, 48, 4) <= 0.1)
        {
                if(Get_BitVar(g_Shoot_R, id)) set_weapon_anim(id, ANIM_IDLE2)
                else set_weapon_anim(id, ANIM_IDLE)

                set_pdata_float(ent, 48, 20.0, 4)
        }
       
        return HAM_IGNORED
}

public fw_Weapon_PrimaryAttack_Pre(Ent)
{
        new id = get_pdata_cbase(Ent, 41, 4)
       
        if (!Get_BitVar(g_Had_Beretta, id))
                return HAM_IGNORED

        pev(id, pev_punchangle, g_Recoil[id])
               
        set_pdata_int(Ent, 64, -1)

        return HAM_IGNORED
}

public fw_Weapon_PrimaryAttack_Post(Ent)
{
        new id = get_pdata_cbase(Ent, 41, 4)
       
        if (!Get_BitVar(g_Had_Beretta, id))
                return

        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)
               
        Push[1] *= 0.5
        set_pev(id, pev_punchangle, Push)

        if(Get_BitVar(g_InSpecial,id))
        {
                g_Recoil[0] = 0.0
                g_Recoil[1] = 0.0
                g_Recoil[2] = 0.0
                set_pev(id, pev_punchangle, g_Recoil)
                set_pdata_float(Ent, 62, 0.0, 4)
                HamRadiusDamage(id, ATTACK_DISTANCE, float(DAMAGEB))
        }
}

public fw_Weapon_SecondaryAttack_Pre(Ent)
{
        new id = get_pdata_cbase(Ent, 41, 4)
       
        if (!Get_BitVar(g_Had_Beretta, id))
                return HAM_IGNORED
               
        return HAM_SUPERCEDE
}

public fw_Item_Holster_Post(Ent)
{
        if(pev_valid(Ent) != 2)
                return
       
        new id = get_pdata_cbase(Ent, 41, 4)

        if(!is_user_alive(id))
                return
       
        if(!Get_BitVar(g_Had_Beretta,id))
                return
       
        if(task_exists(id+TASK_DRAW)) remove_task(id+TASK_DRAW)
        if(task_exists(id+TASK_EXPLODE))  remove_task(id+TASK_DRAW)

        UnSet_BitVar(g_InSpecial, id)
        UnSet_BitVar(g_StartSpecial, id)
}

public fw_TraceAttack(Victim, Attacker, Float:Damage, Float:Direction[3], Ptr, DamageBits)
{
        if(!is_user_alive(Attacker))
                return HAM_IGNORED       
        if(get_user_weapon(Attacker) != CSW_ELITE || !Get_BitVar(g_Had_Beretta, Attacker))
                return HAM_IGNORED
        if(Get_BitVar(g_InSpecial, Attacker))
                return HAM_SUPERCEDE

        SetHamParamFloat(3, float(DAMAGEA))

        return HAM_IGNORED
}

public fw_TraceAttack_World(Victim, Attacker, Float:Damage, Float:Direction[3], Ptr, DamageBits)
{
        if(!is_user_alive(Attacker))
                return HAM_IGNORED       
        if(get_user_weapon(Attacker) != CSW_ELITE || !Get_BitVar(g_Had_Beretta, Attacker))
                return HAM_IGNORED
        if(Get_BitVar(g_InSpecial, Attacker))
                return HAM_SUPERCEDE

        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)

        return HAM_IGNORED
}


stock HamRadiusDamage(id, Float:radius, Float:damage) 

        new i = -1, Float:origin[3] 
        pev(id, pev_origin, origin)
        static Ent; Ent = fm_get_user_weapon_entity(id, CSW_ELITE)
     
        while(( i = find_ent_in_sphere(i, origin, radius) )) 
        {
                if(!is_user_alive(i))
                        continue
                if(id == i)
                        continue
                if(entity_range(id, i) > radius)
                        continue
         
                ExecuteHamB(Ham_TakeDamage, i, Ent, id, damage, HIT_GENERIC, DMG_BULLET) 
        } 
}

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_elite", entity)
               
                if(!pev_valid(weapon))
                        return FMRES_IGNORED;
               
                if(Get_BitVar(g_Had_Beretta, iOwner))
                {
                        Remove_Beretta(iOwner)
                       
                        set_pev(weapon, pev_impulse, SECRET_CODE)
                        engfunc(EngFunc_SetModel, entity, W_MODEL)
                        set_pev(entity, pev_body, 0)
                       
                        return FMRES_SUPERCEDE
                }
        }

        return FMRES_IGNORED;
}


stock RadiusKB(id, Float:radius, Float:Power)
{
        new i = -1, Float:origin[3] 
        pev(id, pev_origin, origin)
        //static Ent; Ent = fm_get_user_weapon_entity(id, CSW_ELITE)
     
        while(( i = find_ent_in_sphere(i, origin, radius) )) 
        {
                if(!is_user_alive(i))
                        continue
                if(id == i)
                        continue
                if(entity_range(id, i) > radius)
                        continue
         
                Stock_Fake_KnockBack(id, i, Power)
        }
       
}

stock set_weapon_timeidle(id, CSWID, Float:TimeIdle)
{
        static Ent; Ent = fm_get_user_weapon_entity(id, CSWID)
        if(!pev_valid(Ent))
                return
       
        set_pdata_float(Ent, 46, TimeIdle, 4)
        set_pdata_float(Ent, 47, TimeIdle, 4)
        set_pdata_float(Ent, 48, TimeIdle + 1.0, 4)
}

stock set_player_nextattack(id, Float:Time) set_pdata_float(id, 83, Time, 5)
stock set_weapon_anim(id, anim)
{
        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 fm_cs_get_weapon_ent_owner(ent)
{
        if (pev_valid(ent) != PDATA_SAFE)
                return -1
       
        return get_pdata_cbase(ent, OFFSET_WEAPONOWNER, OFFSET_LINUX_WEAPONS)
}

public Draw_AnimWeapon(taskid)
{
        static Id; Id = taskid - TASK_DRAW
        static Draw; Draw = Get_BitVar(g_Shoot_R, Id) ? ANIM_DRAW2 : ANIM_DRAW
        if(Draw != -1) set_weapon_anim(Id, Get_BitVar(g_Shoot_R, Id) ? ANIM_DRAW2 : ANIM_DRAW)
        UnSet_BitVar(g_BlockReload, Id)
        UnSet_BitVar(g_InSpecial, Id)
}

public Explode(taskid)
{
        static id; id = taskid - TASK_EXPLODE
        Explode_Exp(id)
        RadiusKB(id, ATTACK_DISTANCE, KB_POWER)
        emit_sound(id, CHAN_WEAPON, WeaponSkillSounds[6], 1.0, 0.4, 0, 94 + random_num(0, 15))

}

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_entity_anim(ent, anim, reset_frame)
{
        if(!pev_valid(ent)) return
       
        set_pev(ent, pev_animtime, get_gametime())
        set_pev(ent, pev_framerate, 1.0)
        if(reset_frame) set_pev(ent, pev_frame, 0.0)
       
        set_pev(ent, pev_sequence, anim)       
}

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()
}

public Stock_Fake_KnockBack(id, iVic, Float:iKb)
{
        if(iVic > 32) return
        if(is_user_alive(iVic) && !zp_get_user_zombie(iVic))
                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 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 drop_usp(id)
{
        new weapons[32], num
        get_user_weapons(id, weapons, num)
        for (new i = 0; i < num; i++) {
                if ((1<<CSW_ELITE) & (1<<weapons[i]))
                {
                        static wname[32]
                        get_weaponname(weapons[i], wname, sizeof wname - 1)
                        engclient_cmd(id, "drop", wname)
                }
        }
}


Celena Luna 08-16-2021 05:31

Re: Beretta Gunslinger little problem
 
Well, first thing first about forum rules
Quote:

Originally Posted by v3x (Post 2782)

Second, you put the Solved tag mean you "solved" it and don't need help anymore.

Third, The special ability with big AoE knockback only work when you run out of clip ammo and it act as special reload so if the VIP have unlimited clip ammo then he can never active the ability.

You can use g_shoot_counter to count the ammo shot, then make the special reload happened when the count reach number of shots


All times are GMT -4. The time now is 02:32.

Powered by vBulletin®
Copyright ©2000 - 2024, vBulletin Solutions, Inc.