Cambiar tipo de balas

[Saber]

Buenas, quisiera saber como hago para cambiar el tipo de balas de un arma especial ejemplo

La thunderbolt al comprarla me da 30 balas raras xD pero si le pongo infinita se bug.

Quiero saber como hago para que salga

1|30 balas y que la BPAMMO sea infinita, porfavor.

[El pirucho XP-007]

Te refieres a este:
--->>>

Código PHP:

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

#define PLUGIN "[Mileage] Primary: Thunderbolt"
#define VERSION "2014"
#define AUTHOR "Dias"

#define DAMAGE 600
#define DEFAULT_AMMO 20
#define RELOAD_TIME 2.67

#define CSW_THUNDERBOLT CSW_AWP
#define weapon_thunderbolt "weapon_awp"
#define old_event "events/awp.sc"
#define old_w_model "models/w_awp.mdl"
#define WEAPON_SECRETCODE 4234234

#define SUBMODEL 11
#define V_MODEL "models/v_sfsniperF.mdl"
#define P_MODEL "models/p_primary.mdl"
#define W_MODEL "models/w_primary.mdl"

new const WeaponSounds[2][] = 
{
    "weapons/sfsniper-1.wav",
    "weapons/sfsniper_insight1.wav"
    //"weapons/sfsniper_zoom.wav",
    //"weapons/sfsniper_idle.wav",
    //"weapons/sfsniper_draw.wav"
}

/*
new const WeaponResources[4][] = 
{
    "sprites/weapon_sfsniperF.txt",
    "sprites/640hud2_2.spr",
    "sprites/640hud10_2.spr",
    "sprites/640hud81_2.spr"
}*/

enum
{
    TB_ANIM_IDLE = 0,
    TB_ANIM_SHOOT,
    TB_ANIM_DRAW
}

enum
{
    ZOOM_NONE = 0,
    ZOOM_ACT
}

// 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_Thunderbolt
new g_Had_Thunderbolt, g_Zoom[33], g_OldWeapon[33]
new g_IsAlive
new Float:CheckDelay[33], g_TempAttack
new g_Msg_CurWeapon, g_Msg_AmmoX
new g_Beam_SprId, g_HamBot_Register, g_Event_Thunderbolt

public plugin_init() 
{
    register_plugin(PLUGIN, VERSION, AUTHOR)
    
    register_event("CurWeapon", "Event_CurWeapon", "be", "1=1")
    register_event("DeathMsg", "Event_Death", "a")
    
    register_forward(FM_UpdateClientData, "fw_UpdateClientData_Post", 1)    
    register_forward(FM_PlaybackEvent, "fw_PlaybackEvent")        
    register_forward(FM_SetModel, "fw_SetModel")    
    register_forward(FM_CmdStart, "fw_CmdStart")
    register_forward(FM_EmitSound, "fw_EmitSound")
    register_forward(FM_TraceLine, "fw_TraceLine")
    register_forward(FM_TraceHull, "fw_TraceHull")
    
    RegisterHam(Ham_Spawn, "player", "fw_PlayerSpawn_Post", 1)
    RegisterHam(Ham_Item_AddToPlayer, weapon_thunderbolt, "fw_AddToPlayer_Post", 1)
    RegisterHam(Ham_Item_Deploy, weapon_thunderbolt, "fw_Item_Deploy_Post", 1)    
    RegisterHam(Ham_Weapon_WeaponIdle, weapon_thunderbolt, "fw_Weapon_WeaponIdle_Post", 1)
    //RegisterHam(Ham_Weapon_SecondaryAttack, "weapon_awp", "fw_Weapon_SecondaryAttack")
    
    g_Msg_CurWeapon = get_user_msgid("CurWeapon")
    g_Msg_AmmoX = get_user_msgid("AmmoX")    
    
    register_clcmd("weapon_sfsniperF", "CLCMD_HookWeapon")
    g_Thunderbolt = zp_register_extra_item("Thunderbolt", 0, ZP_TEAM_HUMAN)
}

public zp_extra_item_selected(id, itemid)
{
    // Check if the selected item matches any of our registered ones
    if (itemid == g_Thunderbolt) Get_Thunderbolt(id)
}

public plugin_precache()
{
    precache_model(V_MODEL)
    precache_model(P_MODEL)
    precache_model(W_MODEL)
    
    for(new i = 0; i < sizeof(WeaponSounds); i++) 
        engfunc(EngFunc_PrecacheSound, WeaponSounds[i])
    /*
    for(new i = 0; i < sizeof(WeaponResources); i++)
    {
        if(i == 0) engfunc(EngFunc_PrecacheGeneric, WeaponResources[0])
        else engfunc(EngFunc_PrecacheModel, WeaponResources[i])
    }*/
    
    g_Beam_SprId =  engfunc(EngFunc_PrecacheModel, "sprites/laserbeam.spr")
}

public client_putinserver(id)
{
    if(is_user_bot(id) && !g_HamBot_Register)
    {
        g_HamBot_Register = 1
        set_task(0.1, "Do_RegisterHamBot", id)
    }
    
    UnSet_BitVar(g_TempAttack, id)
    UnSet_BitVar(g_IsAlive, id)
}

public Do_RegisterHamBot(id)
{
    RegisterHamFromEntity(Ham_Spawn, id, "fw_PlayerSpawn_Post", 1)
}

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

public plugin_natives ()
{
    register_native("Get_Thunderbolt", "Mileage_WeaponGet", 1)
    register_native("Refill_Thunderbolt", "Mileage_WeaponRefillAmmo", 1)
}

public Mileage_WeaponGet(id)
{
    Get_Thunderbolt(id)
}

public Mileage_WeaponRefillAmmo(id)
{
    Refill_Thunderbolt(id)
}

public Mileage_WeaponRemove(id)
{
    Remove_Thunderbolt(id)
}

public Refill_Thunderbolt(id)
{
    cs_set_user_bpammo(id, CSW_THUNDERBOLT, DEFAULT_AMMO)
}

public Get_Thunderbolt(id)
{
    g_Zoom[id] = ZOOM_NONE
    Set_BitVar(g_Had_Thunderbolt, id)
    
    give_item(id, weapon_thunderbolt)
    
    static weapon_ent; weapon_ent = fm_find_ent_by_owner(-1, weapon_thunderbolt, id)
    if(pev_valid(weapon_ent)) cs_set_weapon_ammo(weapon_ent, 10)
    
    cs_set_user_bpammo(id, CSW_THUNDERBOLT, DEFAULT_AMMO)
}

public Remove_Thunderbolt(id)
{
    g_Zoom[id] = ZOOM_NONE
    UnSet_BitVar(g_Had_Thunderbolt, id)
}

public Event_CurWeapon(id)
{
    static CSWID; CSWID = read_data(2)
    static SubModel; SubModel = SUBMODEL
    
    if((CSWID == CSW_THUNDERBOLT && g_OldWeapon[id] != CSW_THUNDERBOLT) && Get_BitVar(g_Had_Thunderbolt, id))
    {
        if(SubModel != -1) Draw_NewWeapon(id, CSWID)
        UpdateAmmo(id, -1, cs_get_user_bpammo(id, CSW_THUNDERBOLT))
    } else if((CSWID == CSW_THUNDERBOLT && g_OldWeapon[id] == CSW_THUNDERBOLT) && Get_BitVar(g_Had_Thunderbolt, id)) {
        if(cs_get_user_zoom(id) == 1)
        {
            set_pev(id, pev_viewmodel2, V_MODEL)
        } else if(cs_get_user_zoom(id) == 2 || cs_get_user_zoom(id) == 3) {
            set_pev(id, pev_viewmodel2, "")
        }
        
        UpdateAmmo(id, -1, cs_get_user_bpammo(id, CSW_THUNDERBOLT))
    } else if(CSWID != CSW_THUNDERBOLT && g_OldWeapon[id] == CSW_THUNDERBOLT) {
        if(SubModel != -1) Draw_NewWeapon(id, CSWID)
    }
    
    g_OldWeapon[id] = get_user_weapon(id)
}

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

public Event_Death()
{
    static Victim; Victim = read_data(2)
    UnSet_BitVar(g_IsAlive, Victim)
}

public CLCMD_HookWeapon(id)
{
    engclient_cmd(id, weapon_thunderbolt)
    return
}

public fw_UpdateClientData_Post(id, sendweapons, cd_handle)
{
    if(!Get_BitVar(g_IsAlive, id))
        return FMRES_IGNORED    
    if(get_user_weapon(id) == CSW_THUNDERBOLT && Get_BitVar(g_Had_Thunderbolt, 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(eventid != g_Event_Thunderbolt)
        return FMRES_IGNORED
    if(!Get_BitVar(g_IsAlive, invoker))
        return FMRES_IGNORED        
    if(get_user_weapon(invoker) != CSW_THUNDERBOLT || !Get_BitVar(g_Had_Thunderbolt, invoker))
        return FMRES_IGNORED
    
    engfunc(EngFunc_PlaybackEvent, flags | FEV_HOSTONLY, invoker, eventid, delay, origin, angles, fparam1, fparam2, iParam1, iParam2, bParam1, bParam2)

    return FMRES_SUPERCEDE
}

public fw_SetModel(entity, model[])
{
    if(!pev_valid(entity))
        return FMRES_IGNORED
    
    static Classname[64]
    pev(entity, pev_classname, Classname, sizeof(Classname))
    
    if(!equal(Classname, "weaponbox"))
        return FMRES_IGNORED
    
    static id
    id = pev(entity, pev_owner)
    
    if(equal(model, old_w_model))
    {
        static weapon
        weapon = fm_get_user_weapon_entity(entity, CSW_THUNDERBOLT)
        
        if(!pev_valid(weapon))
            return FMRES_IGNORED
        
        if(Get_BitVar(g_Had_Thunderbolt, id))
        {
            UnSet_BitVar(g_Had_Thunderbolt, id)
            
            set_pev(weapon, pev_impulse, WEAPON_SECRETCODE)
            set_pev(weapon, pev_iuser4, cs_get_user_bpammo(id, CSW_THUNDERBOLT))
            
            engfunc(EngFunc_SetModel, entity, W_MODEL)
            set_pev(entity, pev_body, SUBMODEL)
            
            return FMRES_SUPERCEDE
        }
    }

    return FMRES_IGNORED;
}

public fw_CmdStart(id, UcHandle, Seed)
{
    if(!Get_BitVar(g_IsAlive, id))
        return
    if(get_user_weapon(id) != CSW_THUNDERBOLT || !Get_BitVar(g_Had_Thunderbolt, id))
        return
    if(get_pdata_float(id, 83, 5) > 0.0)
        return
    
    static CurButton; CurButton = get_uc(UcHandle, UC_Buttons)
    if(CurButton & IN_ATTACK)
    {
        CurButton &= ~IN_ATTACK
        set_uc(UcHandle, UC_Buttons, CurButton)
        
        if(get_gametime() - RELOAD_TIME > CheckDelay[id])
        {
            Thunderbolt_Shooting(id)
            CheckDelay[id] = get_gametime()
        }
    }
}

public fw_EmitSound(id, channel, const sample[], Float:volume, Float:attn, flags, pitch)
{
    if(!Get_BitVar(g_IsAlive, id))
        return FMRES_IGNORED
    if(!Get_BitVar(g_TempAttack, id))
        return FMRES_IGNORED
        
    if(sample[8] == 'k' && sample[9] == 'n' && sample[10] == 'i')
    {
        if(sample[14] == 's' && sample[15] == 'l' && sample[16] == 'a')
            return FMRES_SUPERCEDE
        if (sample[14] == 'h' && sample[15] == 'i' && sample[16] == 't')
        {
            if (sample[17] == 'w')  return FMRES_SUPERCEDE
            else  return FMRES_SUPERCEDE
        }
        if (sample[14] == 's' && sample[15] == 't' && sample[16] == 'a')
            return FMRES_SUPERCEDE;
    }
    
    return FMRES_IGNORED
}

public fw_TraceLine(Float:vector_start[3], Float:vector_end[3], ignored_monster, id, handle)
{
    if(!Get_BitVar(g_IsAlive, id))
        return FMRES_IGNORED
    if(!Get_BitVar(g_TempAttack, id))
        return FMRES_IGNORED
    
    static Float:vecStart[3], Float:vecEnd[3], Float:v_angle[3], Float:v_forward[3], Float:view_ofs[3], Float:fOrigin[3]
    
    pev(id, pev_origin, fOrigin)
    pev(id, pev_view_ofs, view_ofs)
    xs_vec_add(fOrigin, view_ofs, vecStart)
    pev(id, pev_v_angle, v_angle)
    
    engfunc(EngFunc_MakeVectors, v_angle)
    get_global_vector(GL_v_forward, v_forward)

    xs_vec_mul_scalar(v_forward, 0.0, v_forward)
    xs_vec_add(vecStart, v_forward, vecEnd)
    
    engfunc(EngFunc_TraceLine, vecStart, vecEnd, ignored_monster, id, handle)
    
    return FMRES_SUPERCEDE
}

public fw_TraceHull(Float:vector_start[3], Float:vector_end[3], ignored_monster, hull, id, handle)
{
    if(!Get_BitVar(g_IsAlive, id))
        return FMRES_IGNORED
    if(!Get_BitVar(g_TempAttack, id))
        return FMRES_IGNORED
    
    static Float:vecStart[3], Float:vecEnd[3], Float:v_angle[3], Float:v_forward[3], Float:view_ofs[3], Float:fOrigin[3]
    
    pev(id, pev_origin, fOrigin)
    pev(id, pev_view_ofs, view_ofs)
    xs_vec_add(fOrigin, view_ofs, vecStart)
    pev(id, pev_v_angle, v_angle)
    
    engfunc(EngFunc_MakeVectors, v_angle)
    get_global_vector(GL_v_forward, v_forward)
    
    xs_vec_mul_scalar(v_forward, 0.0, v_forward)
    xs_vec_add(vecStart, v_forward, vecEnd)
    
    engfunc(EngFunc_TraceHull, vecStart, vecEnd, ignored_monster, hull, id, handle)
    
    return FMRES_SUPERCEDE
}

public fw_PlayerSpawn_Post(id) Set_BitVar(g_IsAlive, id)
public fw_AddToPlayer_Post(ent, id)
{
    if(pev(ent, pev_impulse) == WEAPON_SECRETCODE)
    {
        Set_BitVar(g_Had_Thunderbolt, id)
        cs_set_user_bpammo(id, CSW_THUNDERBOLT, pev(ent, pev_iuser4))
        
        set_pev(ent, pev_impulse, 0)
    }            
    
    /*
    message_begin(MSG_ONE_UNRELIABLE, g_Msg_WeaponList, _, id)
    write_string((Get_BitVar(g_Had_Thunderbolt, id) ? "weapon_sfsniperF" : "weapon_awp"))
    write_byte(1)
    write_byte(30)
    write_byte(-1)
    write_byte(-1)
    write_byte(0)
    write_byte(2)
    write_byte(CSW_THUNDERBOLT)
    write_byte(0)
    message_end()*/
}

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_Thunderbolt, Id))
        return
    
    static SubModel; SubModel = SUBMODEL
    
    set_pev(Id, pev_viewmodel2, V_MODEL)
    set_pev(Id, pev_weaponmodel2, SubModel != -1 ? "" : P_MODEL)
    
    Set_WeaponAnim(Id, TB_ANIM_DRAW)
    remove_task(Id+111)
}

public fw_Weapon_WeaponIdle_Post(Ent)
{
    if(pev_valid(Ent) != 2)
        return HAM_IGNORED    
    static Id; Id = get_pdata_cbase(Ent, 41, 4)
    if(get_pdata_cbase(Id, 373) != Ent)
        return HAM_IGNORED    
    if(!Get_BitVar(g_Had_Thunderbolt, Id))
        return HAM_IGNORED    

    if(get_pdata_float(Ent, 48, 4) <= 0.1) 
    {
        Set_WeaponAnim(Id, TB_ANIM_IDLE)
        set_pdata_float(Ent, 48, 20.0, 4)
    }
    
    return HAM_IGNORED    
}

public fw_Weapon_SecondaryAttack(Ent)
{
    static Id; Id = get_pdata_cbase(Ent, 41, 4)
    //if(get_pdata_cbase(Id, 373) != Ent)
        //return HAM_IGNORED    
    if(!Get_BitVar(g_Had_Thunderbolt, Id))
        return HAM_IGNORED    
        
    return HAM_SUPERCEDE
}

public Thunderbolt_Shooting(id)
{
    if(cs_get_user_bpammo(id, CSW_THUNDERBOLT) <= 0)
        return
        
    Set_BitVar(g_TempAttack, id)
    static Ent; Ent = fm_get_user_weapon_entity(id, CSW_KNIFE)
    if(pev_valid(Ent)) ExecuteHamB(Ham_Weapon_PrimaryAttack, Ent)
    UnSet_BitVar(g_TempAttack, id)
    
    g_Zoom[id] = cs_get_user_zoom(id)
    cs_set_user_zoom(id, CS_SET_NO_ZOOM, 1)
    cs_set_user_bpammo(id, CSW_THUNDERBOLT, cs_get_user_bpammo(id, CSW_THUNDERBOLT) - 1)
    
    set_task(RELOAD_TIME - 0.15, "Set_SniperModel", id+111)
    
    Set_WeaponAnim(id, TB_ANIM_SHOOT)
    emit_sound(id, CHAN_WEAPON, WeaponSounds[0], 1.0, 0.4, 0, 94 + random_num(0, 15))
    
    Make_FakePunch(id)
    
    // Set Idle
    Ent = fm_get_user_weapon_entity(id, CSW_THUNDERBOLT)
    if(pev_valid(Ent)) 
    {
        set_pdata_float(id, 83, RELOAD_TIME, 5)
        
        set_pdata_float(Ent, 46, RELOAD_TIME, 4)
        set_pdata_float(Ent, 47, RELOAD_TIME, 4)
        set_pdata_float(Ent, 48, RELOAD_TIME + 0.25, 4)
    }
        
    Check_Damage(id)
        
    // Set Bullet reject
    set_pdata_float(id, 111, 0.0)
}

public Set_SniperModel(id)
{
    id -= 111
    if(!is_user_alive(id))
        return
    if(!Get_BitVar(g_Had_Thunderbolt, id))
        return
        
    cs_set_user_zoom(id, g_Zoom[id], 1)
}

public Make_FakePunch(id)
{
    static Float:PunchAngles[3]
    PunchAngles[0] = random_float(-3.5, -7.0)
    
    set_pev(id, pev_punchangle, PunchAngles)
}

public Check_Damage(id)
{
    static Float:StartOrigin[3], Float:EndOrigin[3], Float:EndOrigin2[3]
    
    Stock_Get_Postion(id, 40.0, 7.5, -5.0, StartOrigin)
    Stock_Get_Postion(id, 4096.0, 0.0, 0.0, EndOrigin)
    
    static TrResult; TrResult = create_tr2()
    engfunc(EngFunc_TraceLine, StartOrigin, EndOrigin, IGNORE_MONSTERS, id, TrResult) 
    get_tr2(TrResult, TR_vecEndPos, EndOrigin2)
    free_tr2(TrResult)
    
    message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
    write_byte(TE_BEAMPOINTS)
    engfunc(EngFunc_WriteCoord, StartOrigin[0])
    engfunc(EngFunc_WriteCoord, StartOrigin[1])
    engfunc(EngFunc_WriteCoord, StartOrigin[2])
    engfunc(EngFunc_WriteCoord, EndOrigin2[0])
    engfunc(EngFunc_WriteCoord, EndOrigin2[1])
    engfunc(EngFunc_WriteCoord, EndOrigin2[2])
    write_short(g_Beam_SprId)
    write_byte(0)
    write_byte(0)
    write_byte(10)
    write_byte(25)
    write_byte(0)
    write_byte(0)
    write_byte(0)
    write_byte(200)
    write_byte(200)
    write_byte(0)
    message_end()    

    message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
    write_byte(TE_SPARKS) //TE_SPARKS
    engfunc(EngFunc_WriteCoord, EndOrigin2[0])
    engfunc(EngFunc_WriteCoord, EndOrigin2[1])
    engfunc(EngFunc_WriteCoord, EndOrigin2[2])
    message_end()    
    
    DealDamage(id, StartOrigin, EndOrigin2)    
}

public DealDamage(id, Float:Start[3], Float:End[3])
{
    static TrResult; TrResult = create_tr2()
    
    // Trace First Time
    engfunc(EngFunc_TraceLine, Start, End, DONT_IGNORE_MONSTERS, id, TrResult) 
    new pHit1; pHit1 = get_tr2(TrResult, TR_pHit)
    static Float:End1[3]; get_tr2(TrResult, TR_vecEndPos, End1)
    
    if(is_user_alive(pHit1)) 
    {
        do_attack(id, pHit1, 0, float(DAMAGE) * 1.5)
        engfunc(EngFunc_TraceLine, End1, End, DONT_IGNORE_MONSTERS, pHit1, TrResult) 
    } else engfunc(EngFunc_TraceLine, End1, End, DONT_IGNORE_MONSTERS, -1, TrResult) 
    
    // Trace Second Time
    new pHit2; pHit2 = get_tr2(TrResult, TR_pHit)
    static Float:End2[3]; get_tr2(TrResult, TR_vecEndPos, End2)
    
    if(is_user_alive(pHit2)) 
    {
        do_attack(id, pHit2, 0, float(DAMAGE) * 1.5)
        engfunc(EngFunc_TraceLine, End2, End, DONT_IGNORE_MONSTERS, pHit2, TrResult) 
    } else engfunc(EngFunc_TraceLine, End2, End, DONT_IGNORE_MONSTERS, -1, TrResult) 
    
    // Trace Third Time
    new pHit3; pHit3 = get_tr2(TrResult, TR_pHit)
    static Float:End3[3]; get_tr2(TrResult, TR_vecEndPos, End3)
    
    if(is_user_alive(pHit3)) 
    {
        do_attack(id, pHit3, 0, float(DAMAGE) * 1.5)
        engfunc(EngFunc_TraceLine, End3, End, DONT_IGNORE_MONSTERS, pHit3, TrResult) 
    } else engfunc(EngFunc_TraceLine, End3, End, DONT_IGNORE_MONSTERS, -1, TrResult) 
    
    // Trace Fourth Time
    new pHit4; pHit4 = get_tr2(TrResult, TR_pHit)
    if(is_user_alive(pHit4)) do_attack(id, pHit4, 0, float(DAMAGE) * 1.5)

    free_tr2(TrResult)
}

public UpdateAmmo(Id, Ammo, BpAmmo)
{
    static weapon_ent; weapon_ent = fm_get_user_weapon_entity(Id, CSW_THUNDERBOLT)
    if(pev_valid(weapon_ent))
    {
        if(BpAmmo > 0) cs_set_weapon_ammo(weapon_ent, 1)
        else cs_set_weapon_ammo(weapon_ent, 0)
    }
    
    engfunc(EngFunc_MessageBegin, MSG_ONE_UNRELIABLE, g_Msg_CurWeapon, {0, 0, 0}, Id)
    write_byte(1)
    write_byte(CSW_THUNDERBOLT)
    write_byte(-1)
    message_end()
    
    message_begin(MSG_ONE_UNRELIABLE, g_Msg_AmmoX, _, Id)
    write_byte(1)
    write_byte(BpAmmo)
    message_end()
    
    cs_set_user_bpammo(Id, CSW_THUNDERBOLT, BpAmmo)
}

stock Set_WeaponAnim(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 Stock_Get_Postion(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
} 


do_attack(Attacker, Victim, Inflictor, Float:fDamage)
{
    fake_player_trace_attack(Attacker, Victim, fDamage)
    fake_take_damage(Attacker, Victim, fDamage, Inflictor)
}

fake_player_trace_attack(iAttacker, iVictim, &Float:fDamage)
{
    // get fDirection
    new Float:fAngles[3], Float:fDirection[3]
    pev(iAttacker, pev_angles, fAngles)
    angle_vector(fAngles, ANGLEVECTOR_FORWARD, fDirection)
    
    // get fStart
    new Float:fStart[3], Float:fViewOfs[3]
    pev(iAttacker, pev_origin, fStart)
    pev(iAttacker, pev_view_ofs, fViewOfs)
    xs_vec_add(fViewOfs, fStart, fStart)
    
    // get aimOrigin
    new iAimOrigin[3], Float:fAimOrigin[3]
    get_user_origin(iAttacker, iAimOrigin, 3)
    IVecFVec(iAimOrigin, fAimOrigin)
    
    // TraceLine from fStart to AimOrigin
    new ptr; ptr = create_tr2() 
    engfunc(EngFunc_TraceLine, fStart, fAimOrigin, DONT_IGNORE_MONSTERS, iAttacker, ptr)
    new pHit; pHit = get_tr2(ptr, TR_pHit)
    new iHitgroup; iHitgroup = get_tr2(ptr, TR_iHitgroup)
    new Float:fEndPos[3]
    get_tr2(ptr, TR_vecEndPos, fEndPos)

    // get target & body at aiming
    new iTarget, iBody
    get_user_aiming(iAttacker, iTarget, iBody)
    
    // if aiming find target is iVictim then update iHitgroup
    if (iTarget == iVictim)
    {
        iHitgroup = iBody
    }
    
    // if ptr find target not is iVictim
    else if (pHit != iVictim)
    {
        // get AimOrigin in iVictim
        new Float:fVicOrigin[3], Float:fVicViewOfs[3], Float:fAimInVictim[3]
        pev(iVictim, pev_origin, fVicOrigin)
        pev(iVictim, pev_view_ofs, fVicViewOfs) 
        xs_vec_add(fVicViewOfs, fVicOrigin, fAimInVictim)
        fAimInVictim[2] = fStart[2]
        fAimInVictim[2] += get_distance_f(fStart, fAimInVictim) * floattan( fAngles[0] * 2.0, degrees )
        
        // check aim in size of iVictim
        new iAngleToVictim; iAngleToVictim = get_angle_to_target(iAttacker, fVicOrigin)
        iAngleToVictim = abs(iAngleToVictim)
        new Float:fDis; fDis = 2.0 * get_distance_f(fStart, fAimInVictim) * floatsin( float(iAngleToVictim) * 0.5, degrees )
        new Float:fVicSize[3]
        pev(iVictim, pev_size , fVicSize)
        if ( fDis <= fVicSize[0] * 0.5 )
        {
            // TraceLine from fStart to aimOrigin in iVictim
            new ptr2; ptr2 = create_tr2() 
            engfunc(EngFunc_TraceLine, fStart, fAimInVictim, DONT_IGNORE_MONSTERS, iAttacker, ptr2)
            new pHit2; pHit2 = get_tr2(ptr2, TR_pHit)
            new iHitgroup2; iHitgroup2 = get_tr2(ptr2, TR_iHitgroup)
            
            // if ptr2 find target is iVictim
            if ( pHit2 == iVictim && (iHitgroup2 != HIT_HEAD || fDis <= fVicSize[0] * 0.25) )
            {
                pHit = iVictim
                iHitgroup = iHitgroup2
                get_tr2(ptr2, TR_vecEndPos, fEndPos)
            }
            
            free_tr2(ptr2)
        }
        
        // if pHit still not is iVictim then set default HitGroup
        if (pHit != iVictim)
        {
            // set default iHitgroup
            iHitgroup = HIT_GENERIC
            
            new ptr3; ptr3 = create_tr2() 
            engfunc(EngFunc_TraceLine, fStart, fVicOrigin, DONT_IGNORE_MONSTERS, iAttacker, ptr3)
            get_tr2(ptr3, TR_vecEndPos, fEndPos)
            
            // free ptr3
            free_tr2(ptr3)
        }
    }
    
    // set new Hit & Hitgroup & EndPos
    set_tr2(ptr, TR_pHit, iVictim)
    set_tr2(ptr, TR_iHitgroup, iHitgroup)
    set_tr2(ptr, TR_vecEndPos, fEndPos)

    // ExecuteHam
    fake_trake_attack(iAttacker, iVictim, fDamage, fDirection, ptr)
    
    // free ptr
    free_tr2(ptr)
}

stock fake_trake_attack(iAttacker, iVictim, Float:fDamage, Float:fDirection[3], iTraceHandle, iDamageBit = (DMG_NEVERGIB | DMG_BULLET))
{
    ExecuteHamB(Ham_TraceAttack, iVictim, iAttacker, fDamage, fDirection, iTraceHandle, iDamageBit)
}

stock fake_take_damage(iAttacker, iVictim, Float:fDamage, iInflictor, iDamageBit = (DMG_NEVERGIB | DMG_BULLET))
{
    ExecuteHamB(Ham_TakeDamage, iVictim, iInflictor, iAttacker, fDamage, iDamageBit)
}

stock get_angle_to_target(id, const Float:fTarget[3], Float:TargetSize = 0.0)
{
    new Float:fOrigin[3], iAimOrigin[3], Float:fAimOrigin[3], Float:fV1[3]
    pev(id, pev_origin, fOrigin)
    get_user_origin(id, iAimOrigin, 3) // end position from eyes
    IVecFVec(iAimOrigin, fAimOrigin)
    xs_vec_sub(fAimOrigin, fOrigin, fV1)
    
    new Float:fV2[3]
    xs_vec_sub(fTarget, fOrigin, fV2)
    
    new iResult; iResult = get_angle_between_vectors(fV1, fV2)
    
    if (TargetSize > 0.0)
    {
        new Float:fTan; fTan = TargetSize / get_distance_f(fOrigin, fTarget)
        new fAngleToTargetSize; fAngleToTargetSize = floatround( floatatan(fTan, degrees) )
        iResult -= (iResult > 0) ? fAngleToTargetSize : -fAngleToTargetSize
    }
    
    return iResult
}

stock get_angle_between_vectors(const Float:fV1[3], const Float:fV2[3])
{
    new Float:fA1[3], Float:fA2[3]
    engfunc(EngFunc_VecToAngles, fV1, fA1)
    engfunc(EngFunc_VecToAngles, fV2, fA2)
    
    new iResult; iResult = floatround(fA1[1] - fA2[1])
    iResult = iResult % 360
    iResult = (iResult > 180) ? (iResult - 360) : iResult
    
    return iResult
}

stock Set_UserFov(id, FOV)
{
    if(!is_user_connected(id))
        return
        
    set_pdata_int(id, 363, FOV, 5)
    set_pev(id, pev_fov, FOV)
} 


Prueba este:
--->>>

Código PHP:

#include <amxmodx>
#include <engine>
#include <fakemeta>
#include <fun>
#include <hamsandwich>
#include <xs>
#include <cstrike>

#define ENG_NULLENT            -1
#define EV_INT_WEAPONKEY    EV_INT_impulse
#define sfgun_WEAPONKEY     861
#define MAX_PLAYERS          32
#define IsValidUser(%1) (1 <= %1 <= g_MaxPlayers)

const USE_STOPPED = 0
const OFFSET_ACTIVE_ITEM = 373
const OFFSET_WEAPONOWNER = 41
const OFFSET_LINUX = 5
const OFFSET_LINUX_WEAPONS = 4

#define WEAP_LINUX_XTRA_OFF        4
#define m_fKnown                    44
#define m_flNextPrimaryAttack         46
#define m_flTimeWeaponIdle            48
#define m_iClip                    51
#define m_fInReload                54
#define PLAYER_LINUX_XTRA_OFF    5
#define m_flNextAttack                83

#define sfgun_RELOAD_TIME     3.0
#define sfgun_RELOAD        1
#define sfgun_DRAW            2
#define sfgun_SHOOT1        3
#define sfgun_SHOOT2        4

#define write_coord_f(%1)    engfunc(EngFunc_WriteCoord,%1)

new const Fire_Sounds[][] = { "weapons/sfgun_shoot1.wav" }

new sfgun_V_MODEL[64] = "models/v_sfgun.mdl"
new sfgun_P_MODEL[64] = "models/p_sfgun.mdl"
new sfgun_W_MODEL[64] = "models/w_sfgun.mdl"

new const GUNSHOT_DECALS[] = { 41, 42, 43, 44, 45 }

new cvar_dmg_sfgun, cvar_recoil_sfgun, cvar_clip_sfgun, cvar_spd_sfgun, cvar_sfgun_ammo
new g_MaxPlayers, g_orig_event_sfgun, g_IsInPrimaryAttack
new Float:cl_pushangle[MAX_PLAYERS + 1][3], m_iBlood[2]
new g_has_sfgun[33], g_clip_ammo[33], g_sfgun_TmpClip[33], oldweap[33]
new gmsgWeaponList

const PRIMARY_WEAPONS_BIT_SUM = 
(1<<CSW_SCOUT)|(1<<CSW_XM1014)|(1<<CSW_MAC10)|(1<<CSW_AUG)|(1<<CSW_UMP45)|(1<<CSW_SG550)|(1<<CSW_GALIL)|(1<<CSW_FAMAS)|(1<<CSW_AWP)|(1<<
CSW_MP5NAVY)|(1<<CSW_M249)|(1<<CSW_M3)|(1<<CSW_M4A1)|(1<<CSW_TMP)|(1<<CSW_G3SG1)|(1<<CSW_SG552)|(1<<CSW_AK47)|(1<<CSW_P90)
new const WEAPONENTNAMES[][] = { "", "weapon_p228", "", "weapon_scout", "weapon_hegrenade", "weapon_xm1014", "weapon_c4", "weapon_mac10",
            "weapon_aug", "weapon_smokegrenade", "weapon_elite", "weapon_fiveseven", "weapon_ump45", "weapon_sg550",
            "weapon_galil", "weapon_famas", "weapon_usp", "weapon_glock18", "weapon_awp", "weapon_mp5navy", "weapon_m249",
            "weapon_m3", "weapon_m4a1", "weapon_tmp", "weapon_g3sg1", "weapon_flashbang", "weapon_deagle", "weapon_sg552",
            "weapon_ak47", "weapon_knife", "weapon_p90" }

public plugin_init()
{
    register_plugin("[ZP] Extra: Blaster [SFGUN]", "1.0", "Crock / =) (Poprogun4ik) / TeRKe")
    register_message(get_user_msgid("DeathMsg"), "message_DeathMsg")
    register_event("CurWeapon","CurrentWeapon","be","1=1")
    RegisterHam(Ham_Item_AddToPlayer, "weapon_mp5navy", "fw_sfgun_AddToPlayer")
    RegisterHam(Ham_Use, "func_tank", "fw_UseStationary_Post", 1)
    RegisterHam(Ham_Use, "func_tankmortar", "fw_UseStationary_Post", 1)
    RegisterHam(Ham_Use, "func_tankrocket", "fw_UseStationary_Post", 1)
    RegisterHam(Ham_Use, "func_tanklaser", "fw_UseStationary_Post", 1)
    for (new i = 1; i < sizeof WEAPONENTNAMES; i++)
    if (WEAPONENTNAMES[i][0]) RegisterHam(Ham_Item_Deploy, WEAPONENTNAMES[i], "fw_Item_Deploy_Post", 1)
    RegisterHam(Ham_Weapon_PrimaryAttack, "weapon_mp5navy", "fw_sfgun_PrimaryAttack")
    RegisterHam(Ham_Weapon_PrimaryAttack, "weapon_mp5navy", "fw_sfgun_PrimaryAttack_Post", 1)
    RegisterHam(Ham_Item_PostFrame, "weapon_mp5navy", "sfgun_ItemPostFrame")
    RegisterHam(Ham_Weapon_Reload, "weapon_mp5navy", "sfgun_Reload")
    RegisterHam(Ham_Weapon_Reload, "weapon_mp5navy", "sfgun_Reload_Post", 1)
    RegisterHam(Ham_TakeDamage, "player", "fw_TakeDamage")
    register_forward(FM_SetModel, "fw_SetModel")
    register_forward(FM_UpdateClientData, "fw_UpdateClientData_Post", 1)
    register_forward(FM_PlaybackEvent, "fwPlaybackEvent")
    
    RegisterHam(Ham_TraceAttack, "worldspawn", "fw_TraceAttack", 1)
    RegisterHam(Ham_TraceAttack, "func_breakable", "fw_TraceAttack", 1)
    RegisterHam(Ham_TraceAttack, "func_wall", "fw_TraceAttack", 1)
    RegisterHam(Ham_TraceAttack, "func_door", "fw_TraceAttack", 1)
    RegisterHam(Ham_TraceAttack, "func_door_rotating", "fw_TraceAttack", 1)
    RegisterHam(Ham_TraceAttack, "func_plat", "fw_TraceAttack", 1)
    RegisterHam(Ham_TraceAttack, "func_rotating", "fw_TraceAttack", 1)

    cvar_dmg_sfgun = register_cvar("zp_sfgun_dmg", "5.5")
    cvar_recoil_sfgun = register_cvar("zp_sfgun_recoil", "1.0")
    cvar_clip_sfgun = register_cvar("zp_sfgun_clip", "45")
    cvar_spd_sfgun = register_cvar("zp_sfgun_spd", "1.0")
    cvar_sfgun_ammo = register_cvar("zp_sfgun_ammo", "200")
    
    register_clcmd("say /sfgun", "give_sfgun")
    
    g_MaxPlayers = get_maxplayers()
    gmsgWeaponList = get_user_msgid("WeaponList")
}

public plugin_precache()
{
    precache_model(sfgun_V_MODEL)
    precache_model(sfgun_P_MODEL)
    precache_model(sfgun_W_MODEL)
    for(new i = 0; i < sizeof Fire_Sounds; i++)
    precache_sound(Fire_Sounds[i])    
    precache_sound("weapons/sfgun_clipin.wav")
    precache_sound("weapons/sfgun_clipout.wav")
    precache_sound("weapons/sfgun_draw.wav")
    m_iBlood[0] = precache_model("sprites/blood.spr")
    m_iBlood[1] = precache_model("sprites/bloodspray.spr")
    precache_generic("sprites/weapon_sfgun.txt")
    precache_generic("sprites/640hud58.spr")
    
    register_clcmd("weapon_sfgun", "weapon_hook")    

    register_forward(FM_PrecacheEvent, "fwPrecacheEvent_Post", 1)
}

public weapon_hook(id)
{
        engclient_cmd(id, "weapon_mp5navy")
        return PLUGIN_HANDLED
}

public fw_TraceAttack(iEnt, iAttacker, Float:flDamage, Float:fDir[3], ptr, iDamageType)
{
    if(!is_user_alive(iAttacker))
        return

    new g_currentweapon = get_user_weapon(iAttacker)

    if(g_currentweapon != CSW_MP5NAVY) return
    
    if(!g_has_sfgun[iAttacker]) return

    static Float:flEnd[3]
    get_tr2(ptr, TR_vecEndPos, flEnd)
    
    if(iEnt)
    {
        message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
        write_byte(TE_DECAL)
        write_coord_f(flEnd[0])
        write_coord_f(flEnd[1])
        write_coord_f(flEnd[2])
        write_byte(GUNSHOT_DECALS[random_num (0, sizeof GUNSHOT_DECALS -1)])
        write_short(iEnt)
        message_end()
    }
    else
    {
        message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
        write_byte(TE_WORLDDECAL)
        write_coord_f(flEnd[0])
        write_coord_f(flEnd[1])
        write_coord_f(flEnd[2])
        write_byte(GUNSHOT_DECALS[random_num (0, sizeof GUNSHOT_DECALS -1)])
        message_end()
    }
    message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
    write_byte(TE_GUNSHOTDECAL)
    write_coord_f(flEnd[0])
    write_coord_f(flEnd[1])
    write_coord_f(flEnd[2])
    write_short(iAttacker)
    write_byte(GUNSHOT_DECALS[random_num (0, sizeof GUNSHOT_DECALS -1)])
    message_end()
}

/*public zp_user_humanized_post(id)
{
    g_has_sfgun[id] = false
}*/

public plugin_natives ()
{
    register_native("give_weapon_sfgun", "native_give_weapon_add", 1)
}
public native_give_weapon_add(id)
{
    give_sfgun(id)
}

public fwPrecacheEvent_Post(type, const name[])
{
    if (equal("events/mp5n.sc", name))
    {
        g_orig_event_sfgun = get_orig_retval()
        return FMRES_HANDLED
    }
    return FMRES_IGNORED
}

public client_connect(id)
{
    g_has_sfgun[id] = false
}

public client_disconnect(id)
{
    g_has_sfgun[id] = false
}

/*public user_post(id)
{
    if (admin_get_user_counter_terrorist(id))
    {
        g_has_sfgun[id] = false
    }
}*/

public fw_SetModel(entity, model[])
{
    if(!is_valid_ent(entity))
        return FMRES_IGNORED
    
    static szClassName[33]
    entity_get_string(entity, EV_SZ_classname, szClassName, charsmax(szClassName))
        
    if(!equal(szClassName, "weaponbox"))
        return FMRES_IGNORED
    
    static iOwner
    
    iOwner = entity_get_edict(entity, EV_ENT_owner)
    
    if(equal(model, "models/w_mp5.mdl"))
    {
        static iStoredAugID
        
        iStoredAugID = find_ent_by_owner(ENG_NULLENT, "weapon_mp5navy", entity)
    
        if(!is_valid_ent(iStoredAugID))
            return FMRES_IGNORED
    
        if(g_has_sfgun[iOwner])
        {
            entity_set_int(iStoredAugID, EV_INT_WEAPONKEY, sfgun_WEAPONKEY)
            
            g_has_sfgun[iOwner] = false
            
            entity_set_model(entity, sfgun_W_MODEL)
            
            return FMRES_SUPERCEDE
        }
    }
    return FMRES_IGNORED
}

public give_sfgun(id)
{
    drop_weapons(id, 1)
    new iWep2 = give_item(id,"weapon_mp5navy")
    if( iWep2 > 0 )
    {
        cs_set_weapon_ammo(iWep2, get_pcvar_num(cvar_clip_sfgun))
        cs_set_user_bpammo (id, CSW_MP5NAVY, get_pcvar_num(cvar_sfgun_ammo))    
        UTIL_PlayWeaponAnimation(id, sfgun_DRAW)
        set_pdata_float(id, m_flNextAttack, 1.0, PLAYER_LINUX_XTRA_OFF)
        
        message_begin(MSG_ONE, gmsgWeaponList, _, id)
        write_string("weapon_sfgun")
        write_byte(10)
        write_byte(120)
        write_byte(-1)
        write_byte(-1)
        write_byte(0)
        write_byte(7)
        write_byte(CSW_MP5NAVY)
        message_end()

    }
    g_has_sfgun[id] = true
}

/*public zp_extra_item_selected(id, itemid)
{
    if(itemid != g_itemid_sfgun)
        return

    give_sfgun(id)
}*/

public fw_sfgun_AddToPlayer(sfgun, id)
{
    if(!is_valid_ent(sfgun) || !is_user_connected(id))
        return HAM_IGNORED
    
    if(entity_get_int(sfgun, EV_INT_WEAPONKEY) == sfgun_WEAPONKEY)
    {
        g_has_sfgun[id] = true
        
        entity_set_int(sfgun, EV_INT_WEAPONKEY, 0)
        
        message_begin(MSG_ONE, gmsgWeaponList, {0,0,0}, id)
        write_string("weapon_sfgun")
        write_byte(10)
        write_byte(120)
        write_byte(-1)
        write_byte(-1)
        write_byte(0)
        write_byte(7)
        write_byte(CSW_MP5NAVY)
        message_end()

        return HAM_HANDLED
    }
        else
    {
        message_begin(MSG_ONE, gmsgWeaponList, {0,0,0}, id)
        write_string("weapon_mp5navy")
        write_byte(10)
        write_byte(120)
        write_byte(-1)
        write_byte(-1)
        write_byte(0)
        write_byte(7)
        write_byte(CSW_MP5NAVY)
        message_end()
    }
    return HAM_IGNORED
}

public fw_UseStationary_Post(entity, caller, activator, use_type)
{
    if (use_type == USE_STOPPED && is_user_connected(caller))
        replace_weapon_models(caller, get_user_weapon(caller))
}

public fw_Item_Deploy_Post(weapon_ent)
{
    static owner
    owner = fm_cs_get_weapon_ent_owner(weapon_ent)
    
    static weaponid
    weaponid = cs_get_weapon_id(weapon_ent)
    
    replace_weapon_models(owner, weaponid)
}

public CurrentWeapon(id)
{
     replace_weapon_models(id, read_data(2))

     if(read_data(2) != CSW_MP5NAVY || !g_has_sfgun[id])
          return
     
     static Float:iSpeed
     if(g_has_sfgun[id])
          iSpeed = get_pcvar_float(cvar_spd_sfgun)
     
     static weapon[32],Ent
     get_weaponname(read_data(2),weapon,31)
     Ent = find_ent_by_owner(-1,weapon,id)
     if(Ent)
     {
          static Float:Delay
          Delay = get_pdata_float( Ent, 46, 4) * iSpeed
          if (Delay > 0.0)
          {
               set_pdata_float(Ent, 46, Delay, 4)
          }
     }
}

replace_weapon_models(id, weaponid)
{
    switch (weaponid)
    {
        case CSW_MP5NAVY:
        {
                
            if(g_has_sfgun[id])
            {
                set_pev(id, pev_viewmodel2, sfgun_V_MODEL)
                set_pev(id, pev_weaponmodel2, sfgun_P_MODEL)
                if(oldweap[id] != CSW_MP5NAVY) 
                {
                    UTIL_PlayWeaponAnimation(id, sfgun_DRAW)
                    set_pdata_float(id, m_flNextAttack, 1.0, PLAYER_LINUX_XTRA_OFF)
                    
                    message_begin(MSG_ONE, gmsgWeaponList, _, id)
                    write_string("weapon_sfgun")
                    write_byte(10)
                    write_byte(120)
                    write_byte(-1)
                    write_byte(-1)
                    write_byte(0)   
                    write_byte(7) 
                    write_byte(CSW_MP5NAVY)
                    message_end()
                }
            }
        }
    }
    oldweap[id] = weaponid
}

public fw_UpdateClientData_Post(Player, SendWeapons, CD_Handle)
{
    if(!is_user_alive(Player) || (get_user_weapon(Player) != CSW_MP5NAVY || !g_has_sfgun[Player]))
        return FMRES_IGNORED
    
    set_cd(CD_Handle, CD_flNextAttack, halflife_time () + 0.001)
    return FMRES_HANDLED
}

public fw_sfgun_PrimaryAttack(Weapon)
{
    new Player = get_pdata_cbase(Weapon, 41, 4)
    
    if (!g_has_sfgun[Player])
        return
    
    g_IsInPrimaryAttack = 1
    pev(Player,pev_punchangle,cl_pushangle[Player])
    
    g_clip_ammo[Player] = cs_get_weapon_ammo(Weapon)
}

public fwPlaybackEvent(flags, invoker, eventid, Float:delay, Float:origin[3], Float:angles[3], Float:fparam1, Float:fparam2, iParam1, iParam2, bParam1, bParam2)
{
    if ((eventid != g_orig_event_sfgun) || !g_IsInPrimaryAttack)
        return FMRES_IGNORED
    if (!(1 <= invoker <= g_MaxPlayers))
    return FMRES_IGNORED

    playback_event(flags | FEV_HOSTONLY, invoker, eventid, delay, origin, angles, fparam1, fparam2, iParam1, iParam2, bParam1, bParam2)
    return FMRES_SUPERCEDE
}

public fw_sfgun_PrimaryAttack_Post(Weapon)
{
    g_IsInPrimaryAttack = 0
    new Player = get_pdata_cbase(Weapon, 41, 4)
    
    new szClip, szAmmo
    get_user_weapon(Player, szClip, szAmmo)
    
    if(!is_user_alive(Player))
        return

    if(g_has_sfgun[Player])
    {
        if (!g_clip_ammo[Player])
            return

        new Float:push[3]
        pev(Player,pev_punchangle,push)
        xs_vec_sub(push,cl_pushangle[Player],push)
        
        xs_vec_mul_scalar(push,get_pcvar_float(cvar_recoil_sfgun),push)
        xs_vec_add(push,cl_pushangle[Player],push)
        set_pev(Player,pev_punchangle,push)
        
        emit_sound(Player, CHAN_WEAPON, Fire_Sounds[0], VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
        UTIL_PlayWeaponAnimation(Player, random_num(sfgun_SHOOT1, sfgun_SHOOT2))
    }
}

public fw_TakeDamage(victim, inflictor, attacker, Float:damage)
{
    if (victim != attacker && is_user_connected(attacker))
    {
        if(get_user_weapon(attacker) == CSW_MP5NAVY)
        {
            if(g_has_sfgun[attacker])
                SetHamParamFloat(4, damage * get_pcvar_float(cvar_dmg_sfgun))
        }
    }
}

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(equal(szTruncatedWeapon, "mp5navy") && get_user_weapon(iAttacker) == CSW_MP5NAVY)
    {
        if(g_has_sfgun[iAttacker])
            set_msg_arg_string(4, "mp5navy")
    }
    return PLUGIN_CONTINUE
}

stock fm_cs_get_current_weapon_ent(id)
{
    return get_pdata_cbase(id, OFFSET_ACTIVE_ITEM, OFFSET_LINUX)
}

stock fm_cs_get_weapon_ent_owner(ent)
{
    return get_pdata_cbase(ent, OFFSET_WEAPONOWNER, OFFSET_LINUX_WEAPONS)
}

stock UTIL_PlayWeaponAnimation(const Player, const Sequence)
{
    set_pev(Player, pev_weaponanim, Sequence)
    
    message_begin(MSG_ONE_UNRELIABLE, SVC_WEAPONANIM, .player = Player)
    write_byte(Sequence)
    write_byte(pev(Player, pev_body))
    message_end()
}

public sfgun_ItemPostFrame(weapon_entity) 
{
     new id = pev(weapon_entity, pev_owner)
     if (!is_user_connected(id))
          return HAM_IGNORED

     if (!g_has_sfgun[id])
          return HAM_IGNORED

     static iClipExtra
     
     iClipExtra = get_pcvar_num(cvar_clip_sfgun)
     new Float:flNextAttack = get_pdata_float(id, m_flNextAttack, PLAYER_LINUX_XTRA_OFF)

     new iBpAmmo = cs_get_user_bpammo(id, CSW_MP5NAVY)
     new iClip = get_pdata_int(weapon_entity, m_iClip, WEAP_LINUX_XTRA_OFF)

     new fInReload = get_pdata_int(weapon_entity, m_fInReload, WEAP_LINUX_XTRA_OFF) 

     if( fInReload && flNextAttack <= 0.0 )
     {
         new j = min(iClipExtra - iClip, iBpAmmo)
    
         set_pdata_int(weapon_entity, m_iClip, iClip + j, WEAP_LINUX_XTRA_OFF)
         cs_set_user_bpammo(id, CSW_MP5NAVY, iBpAmmo-j)
        
         set_pdata_int(weapon_entity, m_fInReload, 0, WEAP_LINUX_XTRA_OFF)
         fInReload = 0
     }
     return HAM_IGNORED
}

public sfgun_Reload(weapon_entity) 
{
     new id = pev(weapon_entity, pev_owner)
     if (!is_user_connected(id))
          return HAM_IGNORED

     if (!g_has_sfgun[id])
          return HAM_IGNORED

     static iClipExtra

     if(g_has_sfgun[id])
          iClipExtra = get_pcvar_num(cvar_clip_sfgun)

     g_sfgun_TmpClip[id] = -1

     new iBpAmmo = cs_get_user_bpammo(id, CSW_MP5NAVY)
     new iClip = get_pdata_int(weapon_entity, m_iClip, WEAP_LINUX_XTRA_OFF)

     if (iBpAmmo <= 0)
          return HAM_SUPERCEDE

     if (iClip >= iClipExtra)
          return HAM_SUPERCEDE

     g_sfgun_TmpClip[id] = iClip

     return HAM_IGNORED
}

public sfgun_Reload_Post(weapon_entity) 
{
    new id = pev(weapon_entity, pev_owner)
    if (!is_user_connected(id))
        return HAM_IGNORED

    if (!g_has_sfgun[id])
        return HAM_IGNORED

    if (g_sfgun_TmpClip[id] == -1)
        return HAM_IGNORED

    set_pdata_int(weapon_entity, m_iClip, g_sfgun_TmpClip[id], WEAP_LINUX_XTRA_OFF)

    set_pdata_float(weapon_entity, m_flTimeWeaponIdle, sfgun_RELOAD_TIME, WEAP_LINUX_XTRA_OFF)

    set_pdata_float(id, m_flNextAttack, sfgun_RELOAD_TIME, PLAYER_LINUX_XTRA_OFF)

    set_pdata_int(weapon_entity, m_fInReload, 1, WEAP_LINUX_XTRA_OFF)

    UTIL_PlayWeaponAnimation(id, sfgun_RELOAD)

    return HAM_IGNORED
}

stock drop_weapons(id, dropwhat)
{
     static weapons[32], num, i, weaponid
     num = 0
     get_user_weapons(id, weapons, num)
     
     for (i = 0; i < num; i++)
     {
          weaponid = weapons[i]
          
          if (dropwhat == 1 && ((1<<weaponid) & PRIMARY_WEAPONS_BIT_SUM))
          {
               static wname[32]
               get_weaponname(weaponid, wname, sizeof wname - 1)
               engclient_cmd(id, "drop", wname)
          }
     }
} 


[Saber]

mmm, yo pido es con la thunderbolt, ese de la SFGUN no me sirve, es que ando editando el ZTH y esa thunderbolt siempre jode

---

ese de la thunderbolt, me da 20 balas, pero tiene un bug, si activo el unlimited ammo de ZTH esa se bug al disparar me pone 20 balas, vuelvo a disparar me pone 21, y al gastar las 20 balas se bug y no dispara

a eso me refierpo

[El pirucho XP-007]

mmm, yo pido es con la thunderbolt, ese de la SFGUN no me sirve, es que ando editando el ZTH y esa thunderbolt siempre jode

---

ese de la thunderbolt, me da 20 balas, pero tiene un bug, si activo el unlimited ammo de ZTH esa se bug al disparar me pone 20 balas, vuelvo a disparar me pone 21, y al gastar las 20 balas se bug y no dispara

a eso me refierpo

Verga

Pd: nunca me a pasado ese bug con esa arma, aunque deje de usarlo y la remplace por la railcannon o la thanatos-7



Pd2: Aparte para que pones munición infinita a las arma en el servidor, eso es mantequilla

[Hernandez]

Que hermosa ortografía.

[FreDDy]

Que hermosa ortografía.

"futuro ingeniero en sistemas" y no sabe escribir

[Sugisaki]

madre hack willy, idlansito

[roccoxx]

el jueves me diagnosticaron astigmatismo y por leer "avilidades" me van a diagnosticar miopía

[OsweRRR]

Código PHP:

printf("amena%ca", pirucho ? 115 : 122);