Raised This Month: $ Target: $400
 0% 

[ Combine ] 4 Plugins ->


  
 
 
Thread Tools Display Modes
Prev Previous Post   Next Post Next
Author Message
FaNr
BANNED
Join Date: Aug 2013
Old 12-29-2013 , 10:31   [ Combine ] 4 Plugins ->
Reply With Quote #1

Hi all.
Can somebody combine me these plugins ? :
1.
Code:
#include <amxmodx>
#include <engine>
#include <fakemeta>
#include <fakemeta_util>
#include <hamsandwich>
#include <cstrike>

#define PLUGIN "AT4CS"
#define VERSION "1.0"

#define IsPlayer(%1)    ( 1 <= %1 <= g_iMaxPlayers )

#define weapon_at4cs "weapon_m249"
#define CSW_AT4CS CSW_M249

#define TASK_CHECKRELOAD 111112
#define TASK_RELOAD 111113

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)
const SECONDARY_WEAPONS_BIT_SUM = (1<<CSW_P228)|(1<<CSW_ELITE)|(1<<CSW_FIVESEVEN)|(1<<CSW_USP)|(1<<CSW_GLOCK18)|(1<<CSW_DEAGLE)

new g_had_at4cs[33], Float:g_lastfire[33], Float:g_lastaim[33], g_aiming[33],
g_smoke_id, g_spr_trail, g_spr_exp, is_reloading[33],
cvar_radius, cvar_maxdamage

new const v_model[] = "models/Furien2015_Weapons/Primary/v_at4ex.mdl"
new const p_model[] = "models/Furien2015_Weapons/Primary/p_at4ex.mdl"
new const w_model[] = "models/Furien2015_Weapons/Primary/w_at4ex.mdl"
new const s_model[] = "models/Furien2015_Weapons/Primary/s_rocket.mdl"

new const at4cs_sound[5][] = {
    "weapons/at4-1.wav", // Fire Sound
    "weapons/at4_clipin1.wav", // Clip in 1
    "weapons/at4_clipin2.wav", // Clip in 2
    "weapons/at4_clipin3.wav", // Clip in 3
    "weapons/at4_draw.wav"  // Draw
}
new g_iMaxPlayers;
public plugin_init() 
{
    register_plugin(PLUGIN, VERSION, "Dias")
    
    register_event("CurWeapon", "AT4CS_ViewModel", "be", "1=1")
    register_event("HLTV", "event_newround", "a", "1=0", "2=0")
    
    register_forward(FM_UpdateClientData, "AT4CS_UpClientData", 1)
    register_forward(FM_CmdStart, "AT4CS_CmdStart")
    register_forward(FM_SetModel, "AT4CS_SetModel")
    
    register_think("at4ex_rocket", "AT4CS_RocketThink")
    register_touch("at4ex_rocket", "*", "AT4CS_RocketTouch")
    
    RegisterHam(Ham_Weapon_Reload, weapon_at4cs, "AT4CS_WeaponReload")
    RegisterHam(Ham_Item_AddToPlayer, weapon_at4cs, "AT4CS_AddToPlayer", 1)
    
    cvar_radius = register_cvar("at4cs_radius", "300.0")
    cvar_maxdamage = register_cvar("at4cs_maxdamage", "250.0")
    
    g_iMaxPlayers = get_maxplayers()
}

public hook_weapon(id)
{
    engclient_cmd(id, weapon_at4cs)
    return PLUGIN_HANDLED
}

public plugin_precache()
{
    engfunc(EngFunc_PrecacheModel, v_model)
    engfunc(EngFunc_PrecacheModel, p_model)
    engfunc(EngFunc_PrecacheModel, w_model)
    engfunc(EngFunc_PrecacheModel, s_model)
    
    
    g_smoke_id = engfunc(EngFunc_PrecacheModel, "sprites/effects/rainsplash.spr")
    g_spr_trail = engfunc(EngFunc_PrecacheModel,"sprites/xbeam3.spr")
    g_spr_exp = engfunc(EngFunc_PrecacheModel,"sprites/zerogxplode.spr")
    
    for(new i = 0; i < sizeof(at4cs_sound); i++)
        engfunc(EngFunc_PrecacheSound, at4cs_sound[i])
}

public event_newround()
{
    remove_entity_name("at4ex_rocket")
    
    for(new i = 0; i < get_maxplayers(); i++)
    {
        if(is_user_alive(i) && is_user_connected(i))
        {
            remove_task(i+TASK_CHECKRELOAD)
            remove_task(i+TASK_RELOAD)    
        }
    }
}

public plugin_natives ()
{
    register_native("give_weapon_bazooka", "native_give_weapon_add", 1)
}
public native_give_weapon_add(id)
{
    give_bazooka(id)
}

public give_bazooka(id)
{
    if(!IsPlayer(id) || !is_user_alive(id) || is_user_bot(id))
        return 1;
    
    drop_weapons(id, 1)
    
    g_had_at4cs[id] = 1
    is_reloading[id] = 0
    g_aiming[id] = 0
    
    fm_give_item(id, weapon_at4cs)
    
    static at4cs
    at4cs = fm_get_user_weapon_entity(id, CSW_AT4CS)

    cs_set_weapon_ammo(at4cs, 1)
    cs_set_user_bpammo(id, CSW_AT4CS, 50)
    
    
    return PLUGIN_CONTINUE
}

public AT4CS_ViewModel(id)
{
    if(!IsPlayer(id) || !is_user_alive(id) || !is_user_connected(id))
        return PLUGIN_HANDLED
        
    if(get_user_weapon(id) == CSW_AT4CS && g_had_at4cs[id])
    {
        set_pev(id, pev_viewmodel2, v_model)
        set_pev(id, pev_weaponmodel2, p_model)
    }
    
    return PLUGIN_CONTINUE
}

public AT4CS_UpClientData(id, sendweapons, cd_handle)
{
    if(!IsPlayer(id) || !is_user_alive(id) || !is_user_connected(id))
        return FMRES_IGNORED
        
    if(get_user_weapon(id) != CSW_AT4CS || !g_had_at4cs[id])
        return FMRES_IGNORED
        
        
    set_cd(cd_handle, CD_flNextAttack, halflife_time() + 0.001)  

    return FMRES_HANDLED
}

public AT4CS_AddToPlayer(ent, id)
{
    if(!is_valid_ent(ent) || !is_user_alive(id))
        return HAM_IGNORED
            
    if(entity_get_int(ent, EV_INT_impulse) == 61296)
    {
        g_had_at4cs[id] = 1
        entity_set_int(id, EV_INT_impulse, 0)
        
        return HAM_HANDLED
    }        
    return HAM_HANDLED    
}

public AT4CS_CmdStart(id, uc_handle, seed)
{
    if(!IsPlayer(id) || !is_user_alive(id) || !is_user_connected(id))
        return FMRES_IGNORED

    if(get_user_weapon(id) != CSW_AT4CS || !g_had_at4cs[id])
        return FMRES_IGNORED
    
        
    static CurButton
    CurButton = get_uc(uc_handle, UC_Buttons)
    
    if(CurButton & IN_ATTACK)
    {
        static Float:CurTime
        CurTime = get_gametime()
        
        static at4cs
        at4cs = fm_find_ent_by_owner(-1, weapon_at4cs, id)        
        
        if(cs_get_weapon_ammo(at4cs) > 0 && !is_reloading[id])
        {
            if(CurTime - 4.5 > g_lastfire[id])
            {
                set_weapon_anim(id, 1)
                emit_sound(id, CHAN_WEAPON, at4cs_sound[0], 1.0, ATTN_NORM, 0, PITCH_NORM)
                
                create_rocket(id)
                
                static Float:Punch_Angles[3]
                
                Punch_Angles[0] = -20.0
                Punch_Angles[1] = 0.0
                Punch_Angles[2] = 0.0
                
                set_pev(id, pev_punchangle, Punch_Angles)
                cs_set_weapon_ammo(at4cs, cs_get_weapon_ammo(at4cs) - 1)
                
                if(cs_get_weapon_ammo(at4cs) <= 0 && !is_reloading[id])
                {
                    if(cs_get_user_bpammo(id, CSW_AT4CS) > 0)
                    {
                        set_task(1.0, "at4cs_reload", id)
                    }
                }
                
                if(cs_get_user_zoom(id))
                    cs_set_user_zoom(id, CS_RESET_ZOOM, 1)
                
                g_lastfire[id] = CurTime
            }
        } else {
            if(!is_reloading[id])
            {
                if(cs_get_user_bpammo(id, CSW_AT4CS) > 0)
                {
                    if(CurTime - 1.0 > g_lastfire[id])
                    {
                        at4cs_reload(id)
                        g_lastfire[id] = CurTime
                    }
                }
            }
        }
    }
    
    if(CurButton & IN_ATTACK2)
    {
        static Float:CurTime
        CurTime = get_gametime()
        
        if((CurTime - 0.5 > g_lastaim[id]) && !is_reloading[id])
        {
            if(!g_aiming[id])
            {
                cs_set_user_zoom(id, CS_SET_FIRST_ZOOM, 1)
                g_aiming[id] = 1
            } else {
                cs_set_user_zoom(id, CS_RESET_ZOOM, 1)
                g_aiming[id] = 0
            }
            
            g_lastaim[id] = CurTime
        }
    }
    
    CurButton &= ~IN_ATTACK
    set_uc(uc_handle, UC_Buttons, CurButton)
    
    CurButton &= ~IN_RELOAD
    set_uc(uc_handle, UC_Buttons, CurButton)

    return FMRES_HANDLED
}

public AT4CS_SetModel(ent, const model[])
{
    if(!is_valid_ent(ent))
        return FMRES_IGNORED
    
    static szClassName[33]
    entity_get_string(ent, EV_SZ_classname, szClassName, charsmax(szClassName))
    
    if(!equal(szClassName, "weaponbox"))
        return FMRES_IGNORED
    
    static iOwner
    iOwner = entity_get_edict(ent, EV_ENT_owner)
    
    if(equal(model, "models/w_m249.mdl"))
    {
        static at4cs
        at4cs = find_ent_by_owner(-1, "weapon_m249", ent)
        
        if(!is_valid_ent(at4cs))
            return FMRES_IGNORED;
        
        if(g_had_at4cs[iOwner])
        {
            entity_set_int(at4cs, EV_INT_impulse, 61296)
            g_had_at4cs[iOwner] = 0
            entity_set_model(ent, w_model)
            
            return FMRES_SUPERCEDE
        }
    }
    
    return FMRES_IGNORED
}

public at4cs_reload(id)
{
    if(is_reloading[id])
        return
    
    is_reloading[id] = 1
    set_weapon_anim(id, 3)
    
    set_task(0.1, "checking_reload", id+TASK_CHECKRELOAD, _, _, "b")
    set_task(4.0, "reload_complete", id+TASK_RELOAD)
}

public checking_reload(id)
{
    if(!IsPlayer(id) || !is_user_alive(id))
        return
    
    id -= TASK_CHECKRELOAD
    
    if(cs_get_user_zoom(id))
        cs_set_user_zoom(id, CS_RESET_ZOOM, 1)    
    
    if(get_user_weapon(id) != CSW_AT4CS || !g_had_at4cs[id])
    {
        remove_task(id+TASK_CHECKRELOAD)
        remove_task(id+TASK_RELOAD)
        
        is_reloading[id] = 0
    }
}

public reload_complete(id)
{
    id -= TASK_RELOAD
    
    if(!is_reloading[id] || !IsPlayer(id))
        return
        
    remove_task(id+TASK_CHECKRELOAD)    
        
    static at4cs
    at4cs = fm_find_ent_by_owner(-1, weapon_at4cs, id)    

    cs_set_weapon_ammo(at4cs, 1)
    
    cs_set_user_bpammo(id, CSW_AT4CS, cs_get_user_bpammo(id, CSW_AT4CS) - 1)
    is_reloading[id] = 0
}

public AT4CS_WeaponReload(ent)
{
    static id
    id = pev(ent, pev_owner)
    
    if(!is_user_alive(id) || !is_user_connected(id))
        return HAM_IGNORED
        
    if(get_user_weapon(id) != CSW_AT4CS || !g_had_at4cs[id])
        return HAM_IGNORED
            
        
    static Float:CurTime
    CurTime = get_gametime()        
        
    if(!is_reloading[id])
    {
        if(cs_get_user_bpammo(id, CSW_AT4CS) > 0)
        {
            if(CurTime - 1.0 > g_lastfire[id])
            {
                at4cs_reload(id)
                g_lastfire[id] = CurTime
            }
        }
    }    
        
    return HAM_SUPERCEDE
}

public create_rocket(id)
{
    new ent, Float:Origin[3], Float:Angles[3], Float:Velocity[3]
    
    ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))
    engfunc(EngFunc_GetAttachment, id, 0, Origin, Angles)
    pev(id, pev_angles, Angles)
    
    set_pev(ent, pev_origin, Origin)
    set_pev(ent, pev_angles, Angles)
    set_pev(ent, pev_solid, 2)
    set_pev(ent, pev_movetype, 5)
    set_pev(ent, pev_classname, "at4ex_rocket")
    set_pev(ent, pev_owner, id)
    engfunc(EngFunc_SetModel, ent, s_model)
    
    set_pev(ent, pev_mins, {-1.0, -1.0, -1.0})
    set_pev(ent, pev_maxs, {1.0, 1.0, 1.0})
    
    velocity_by_aim(id, 1750, Velocity)
    set_pev(ent, pev_velocity, Velocity)
    
    message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
    write_byte(TE_BEAMFOLLOW) // TE id
    write_short(ent) // entity:attachment to follow
    write_short(g_spr_trail) // sprite index
    write_byte(25) // life in 0.1's
    write_byte(2) // line width in 0.1's
    write_byte(255) // r
    write_byte(255) // g
    write_byte(255) // b
    write_byte(200) // brightness
    message_end()    
    
    set_pev(ent, pev_iuser4, 0)
    set_pev(ent, pev_nextthink, halflife_time() + 0.1)
}

public AT4CS_RocketThink(ent)
{
    if(!pev_valid(ent))
        return

    static Float:Origin[3]
    pev(ent, pev_origin, Origin)
        
    message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
    write_byte(TE_SPRITE)
    engfunc(EngFunc_WriteCoord, Origin[0])
    engfunc(EngFunc_WriteCoord, Origin[1])
    engfunc(EngFunc_WriteCoord, Origin[2])
    write_short(g_smoke_id) 
    write_byte(2) 
    write_byte(200)
    message_end()
    
    if(pev(ent, pev_iuser4) == 0)
    {
        static Victim
        Victim = FindClosesEnemy(ent)
        
        if(is_user_alive(Victim))
        {
            set_pev(ent, pev_iuser4, Victim)
        }
    } else {
        static Victim
        Victim = pev(ent, pev_iuser4)
        
        if(is_user_alive(Victim))
        {
            static Float:VicOrigin[3]
            pev(Victim, pev_origin, VicOrigin)
            
            turn_to_target(ent, Origin, Victim, VicOrigin)
            hook_ent(ent, Victim, 500.0)
        } else {
            set_pev(ent, pev_iuser4, 0)
        }
    }
        
    set_pev(ent, pev_nextthink, halflife_time() + 0.075)
}

public AT4CS_RocketTouch(rocket, touch)
{
    if(!pev_valid(rocket))
        return    
        
    if(is_user_alive(touch) && pev(rocket, pev_owner) == touch)
        return
        
    static Float:Origin[3]
    pev(rocket, pev_origin, Origin)        
        
    message_begin(MSG_BROADCAST ,SVC_TEMPENTITY)
    write_byte(TE_EXPLOSION)
    engfunc(EngFunc_WriteCoord, Origin[0])
    engfunc(EngFunc_WriteCoord, Origin[1])
    engfunc(EngFunc_WriteCoord, Origin[2])
    write_short(g_spr_exp)    // sprite index
    write_byte(20)    // scale in 0.1's
    write_byte(30)    // framerate
    write_byte(0)    // flags
    message_end()
    
    static owner, iVictim
    
    iVictim = -1
    owner = pev(rocket, pev_owner)    

    while((iVictim = find_ent_in_sphere(iVictim, Origin, get_pcvar_float(cvar_radius))) != 0)
    {
        if((0 < iVictim < 32) && is_user_alive(iVictim)
        && iVictim != owner && get_user_team(iVictim) == 1)
        {
            new Float:MaxDamage, Float:Damage
            
            MaxDamage = get_pcvar_float(cvar_maxdamage)
            Damage = random_float(MaxDamage - random_float(0.0, 100.0), MaxDamage + random_float(0.0, 100.0))
            
            ExecuteHam(Ham_TakeDamage, iVictim, 0, owner, 0, DMG_BULLET)
            
            static health
            health = get_user_health(iVictim)
                
            if(health - Damage >= 1)
            {
                fm_set_user_health(iVictim, health - floatround(Damage))
            }
            else
            {
                death_message(owner, iVictim, 1)
            }            
        }
    }    
    
    engfunc(EngFunc_RemoveEntity, rocket)
}

stock set_weapon_anim(id, anim)
{
    set_pev(id, pev_weaponanim, anim)

    message_begin(MSG_ONE_UNRELIABLE, SVC_WEAPONANIM, _, id)
    write_byte(anim)
    write_byte(pev(id,pev_body))
    message_end()
}

stock death_message(Killer, Victim, ScoreBoard)
{
    // Block death msg
    set_msg_block(get_user_msgid("DeathMsg"), BLOCK_SET)
    ExecuteHamB(Ham_Killed, Victim, Killer, 2)
    set_msg_block(get_user_msgid("DeathMsg"), BLOCK_NOT)
    
    // Death
    make_deathmsg(Killer, Victim, 0, "")

    // Update score board
    if (ScoreBoard)
    {
        message_begin(MSG_BROADCAST, get_user_msgid("ScoreInfo"))
        write_byte(Killer) // id
        write_short(pev(Killer, pev_frags)) // frags
        write_short(cs_get_user_deaths(Killer)) // deaths
        write_short(0) // class?
        write_short(get_user_team(Killer)) // team
        message_end()
        
        message_begin(MSG_BROADCAST, get_user_msgid("ScoreInfo"))
        write_byte(Victim) // id
        write_short(pev(Victim, pev_frags)) // frags
        write_short(cs_get_user_deaths(Victim)) // deaths
        write_short(0) // class?
        write_short(get_user_team(Victim)) // team
        message_end()
    }
}

stock FindClosesEnemy(entid)
{
    new Float:Dist
    new Float:maxdistance=300.0
    new indexid=0    
    for(new i=1;i<=get_maxplayers();i++){
        if(is_user_alive(i) && is_valid_ent(i) && can_see_fm(entid, i)
        && pev(entid, pev_owner) != i && cs_get_user_team(pev(entid, pev_owner)) != cs_get_user_team(i))
        {
            Dist = entity_range(entid, i)
            if(Dist <= maxdistance)
            {
                maxdistance=Dist
                indexid=i
                
                return indexid
            }
        }    
    }    
    return 0
}

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

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

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

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

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

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

stock turn_to_target(ent, Float:Ent_Origin[3], target, Float:Vic_Origin[3]) 
{
    if(target) 
    {
        new Float:newAngle[3]
        entity_get_vector(ent, EV_VEC_angles, newAngle)
        new Float:x = Vic_Origin[0] - Ent_Origin[0]
        new Float:z = Vic_Origin[1] - Ent_Origin[1]

        new Float:radians = floatatan(z/x, radian)
        newAngle[1] = radians * (180 / 3.14)
        if (Vic_Origin[0] < Ent_Origin[0])
            newAngle[1] -= 180.0
        
        entity_set_vector(ent, EV_VEC_angles, newAngle)
    }
}

stock hook_ent(ent, victim, Float:speed)
{
    static Float:fl_Velocity[3]
    static Float:VicOrigin[3], Float:EntOrigin[3]

    pev(ent, pev_origin, EntOrigin)
    pev(victim, pev_origin, VicOrigin)
    
    static Float:distance_f
    distance_f = get_distance_f(EntOrigin, VicOrigin)

    if (distance_f > 10.0)
    {
        new Float:fl_Time = distance_f / speed

        fl_Velocity[0] = (VicOrigin[0] - EntOrigin[0]) / fl_Time
        fl_Velocity[1] = (VicOrigin[1] - EntOrigin[1]) / fl_Time
        fl_Velocity[2] = (VicOrigin[2] - EntOrigin[2]) / fl_Time
    } else
    {
        fl_Velocity[0] = 0.0
        fl_Velocity[1] = 0.0
        fl_Velocity[2] = 0.0
    }

    entity_set_vector(ent, EV_VEC_velocity, fl_Velocity)
}

stock drop_weapons(id, dropwhat)
{
    // Get user weapons
    static weapons[32], num, i, weaponid
    num = 0 // reset passed weapons count (bugfix)
    get_user_weapons(id, weapons, num)
    
    // Loop through them and drop primaries or secondaries
    for (i = 0; i < num; i++)
    {
        // Prevent re-indexing the array
        weaponid = weapons[i]
        
        if ((dropwhat == 1 && ((1<<weaponid) & PRIMARY_WEAPONS_BIT_SUM)) || (dropwhat == 2 && ((1<<weaponid) & SECONDARY_WEAPONS_BIT_SUM)))
        {
            // Get weapon entity
            static wname[32]
            get_weaponname(weaponid, wname, charsmax(wname))
            
            // Player drops the weapon and looses his bpammo
            engclient_cmd(id, "drop", wname)
            cs_set_user_bpammo(id, weaponid, 0)
        }
    }
}
2.
Code:
#include <amxmodx>
#include <engine>
#include <fakemeta>
#include <fakemeta_util>
#include <hamsandwich>
#include <cstrike>
#include <xs>
#include <fun>
// #include <zombieplague>

#define PLUGIN "Salamander"
#define VERSION "3.0"
#define AUTHOR "Dias"

#define DAMAGE 38
#define RECOIL 0.1
#define FIRE_SPEED 500.0

#define BURN_DAMAGE 15
#define BURN_LOOP 1.0
#define BURN_TIME 5.0
#define FIREBURN_CLASSNAME "fire_burn"

#define CSW_SALAMANDER CSW_M249
#define weapon_salamander "weapon_m249"

#define DEFAULT_W_MODEL "models/w_m249.mdl"
#define WEAPON_SECRET_CODE 1962+400
#define FIRE_CLASSNAME "fire"

// Fire Start
#define WEAPON_ATTACH_F 40.0
#define WEAPON_ATTACH_R 5.0
#define WEAPON_ATTACH_U -15.0

#define TASK_RESET_AMMO 5434

const pev_ammo = pev_iuser4

new const WeaponModel[3][] =
{
    "models/Furien2015_Weapons/Primary/v_salamander.mdl",
    "models/Furien2015_Weapons/Primary/p_salamander.mdl",
    "models/Furien2015_Weapons/Primary/w_salamander.mdl"
}

new const WeaponSound[6][] =
{
    "weapons/flamegun-1.wav",
    "weapons/flamegun-2.wav",
    "weapons/flamegun_draw.wav",
    "weapons/flamegun_clipin1.wav",
    "weapons/flamegun_clipout1.wav",
    "weapons/flamegun_clipout2.wav"
}

new const WeaponResource[7][] = 
{
    "sprites/flame_puff01.spr",
    "sprites/flame_burn01.spr",
    "sprites/weapon_flamethrower.txt",
    "sprites/640hud7_2.spr",
    "sprites/640hud59_2.spr",
    "sprites/640hud60_2.spr",
    "sprites/smokepuff.spr"
}

enum
{
    MODEL_V = 0,
    MODEL_P,
    MODEL_W
}

enum
{
    SALAMANDER_ANIM_IDLE = 0,
    SALAMANDER_ANIM_SHOOT_BEGIN,
    SALAMANDER_ANIM_SHOOT_END,
    SALAMANDER_ANIM_RELOAD,
    SALAMANDER_ANIM_DRAW
}

new g_salamander
new g_had_salamander[33], g_old_weapon[33], Float:g_PunchAngles[33][3]
new g_smokepuff_id, g_weapon_event, g_register

public plugin_init() 
{
    register_plugin(PLUGIN, VERSION, AUTHOR)
    
    register_event("HLTV", "Event_NewRound", "a", "1=0", "2=0")
    register_event("CurWeapon", "event_CurWeapon", "be", "1=1")

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

    register_think(FIRE_CLASSNAME, "fw_Fire_Think")
    register_think(FIREBURN_CLASSNAME, "fw_FireBurn_Think")
    register_touch(FIRE_CLASSNAME, "*", "fw_Fire_Touch")
    
    RegisterHam(Ham_Spawn, "player", "fw_Spawn_Post", 1)
    RegisterHam(Ham_Item_AddToPlayer, weapon_salamander, "fw_AddToPlayer_Post", 1)
    RegisterHam(Ham_TraceAttack, "player", "fw_TraceAttack")
    RegisterHam(Ham_TraceAttack, "worldspawn", "fw_TraceAttack")
    RegisterHam(Ham_Weapon_PrimaryAttack, weapon_salamander, "fw_Weapon_PrimaryAttack")
    RegisterHam(Ham_Weapon_PrimaryAttack, weapon_salamander, "fw_Weapon_PrimaryAttack_Post", 1)
    
    //g_dragoncannon = zp_register_extra_item("Dragon Cannon", 1, ZP_TEAM_HUMAN)
    
    register_clcmd("admin_get_salamander", "get_salamander", ADMIN_RCON)
    register_clcmd("weapon_flamethrower", "hook_weapon")
    //register_clcmd("do_shoot", "do_shoot")
    
    register_forward(FM_PrecacheEvent, "fw_PrecacheEvent_Post", 1)
}

/*
public do_shoot(id)
{
    static Body, Target
    get_user_aiming(id, Target, Body, 9999)
    
    if(is_user_alive(Target))
    {
        static Ent; Ent = fm_get_user_weapon_entity(Target, get_user_weapon(Target))
        ExecuteHamB(Ham_Weapon_PrimaryAttack, Ent)
    }
}*/

public plugin_precache()
{
    new i
    for(i = 0; i < sizeof(WeaponModel); i++)
        engfunc(EngFunc_PrecacheModel, WeaponModel[i])
    for(i = 0; i < sizeof(WeaponSound); i++)
        engfunc(EngFunc_PrecacheSound, WeaponSound[i])
        
    engfunc(EngFunc_PrecacheModel, WeaponResource[0])
    engfunc(EngFunc_PrecacheModel, WeaponResource[1])
    engfunc(EngFunc_PrecacheGeneric, WeaponResource[2])
    engfunc(EngFunc_PrecacheModel, WeaponResource[3])
    engfunc(EngFunc_PrecacheModel, WeaponResource[4])
    engfunc(EngFunc_PrecacheModel, WeaponResource[5])
    g_smokepuff_id = engfunc(EngFunc_PrecacheModel, WeaponResource[6])
}

public fw_PrecacheEvent_Post(type, const name[])
{
    if(equal("events/m249.sc", name))
        g_weapon_event = get_orig_retval()
}

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

public do_register(id)
{
    RegisterHamFromEntity(Ham_TraceAttack, id, "fw_TraceAttack")            
}

public zp_extra_item_selected(id, itemid)
{
    if(itemid == g_salamander) get_salamander(id)
}

public plugin_natives ()
{
    register_native("give_weapon_salamander", "native_give_weapon_add", 1)
}
public native_give_weapon_add(id)
{
    get_salamander(id)
}

public get_salamander(id)
{
    if(!is_user_alive(id))
        return
        
    drop_weapons(id, 1)
        
    g_had_salamander[id] = 1
    fm_give_item(id, weapon_salamander)
    
    message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("CurWeapon"), _, id)
    write_byte(1)
    write_byte(CSW_SALAMANDER)
    write_byte(100)
    message_end()
    
    cs_set_user_bpammo(id, CSW_SALAMANDER, 200)
}

public remove_salamnader(id)
{
    if(!is_user_connected(id))
        return
        
    g_had_salamander[id] = 0
}

public hook_weapon(id) engclient_cmd(id, weapon_salamander)
public Event_NewRound()
{
    remove_entity_name(FIRE_CLASSNAME)
    remove_entity_name(FIREBURN_CLASSNAME)
}
public event_CurWeapon(id)
{
    if(!is_user_alive(id))
        return
        
    if(get_user_weapon(id) == CSW_SALAMANDER && g_had_salamander[id])
    {
        set_pev(id, pev_viewmodel2, WeaponModel[MODEL_V])
        set_pev(id, pev_weaponmodel2, WeaponModel[MODEL_P])
        
        if(g_old_weapon[id] != CSW_SALAMANDER)
        {
            set_weapon_anim(id, SALAMANDER_ANIM_DRAW)
            set_pdata_float(id, 83, 1.0, 5)
        }
    }
    
    g_old_weapon[id] = get_user_weapon(id)
}

public fw_UpdateClientData_Post(id, sendweapons, cd_handle)
{
    if(!is_user_connected(id) || !is_user_alive(id))
        return FMRES_IGNORED
    if(get_user_weapon(id) != CSW_SALAMANDER || !g_had_salamander[id])
        return FMRES_IGNORED
    
    set_cd(cd_handle, CD_flNextAttack, get_gametime() + 0.001) 
    
    return FMRES_HANDLED
}

public fw_SetModel(entity, model[])
{
    if(!pev_valid(entity))
        return FMRES_IGNORED
    
    static szClassName[33]
    pev(entity, pev_classname, szClassName, charsmax(szClassName))
    
    if(!equal(szClassName, "weaponbox"))
        return FMRES_IGNORED
    
    static id
    id = pev(entity, pev_owner)
    
    if(equal(model, DEFAULT_W_MODEL))
    {
        static weapon
        weapon = fm_find_ent_by_owner(-1, weapon_salamander, entity)
        
        if(!pev_valid(weapon))
            return FMRES_IGNORED
        
        if(g_had_salamander[id])
        {
            set_pev(weapon, pev_impulse, WEAPON_SECRET_CODE)
            engfunc(EngFunc_SetModel, entity, WeaponModel[MODEL_W])
            
            remove_salamnader(id)
            
            return FMRES_SUPERCEDE
        }
    }

    return FMRES_IGNORED
}

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) || !is_user_alive(invoker))
        return FMRES_IGNORED
    if(get_user_weapon(invoker) != CSW_SALAMANDER || !g_had_salamander[invoker])
        return FMRES_IGNORED    
    if(eventid == g_weapon_event)
    {
        playback_event(flags | FEV_HOSTONLY, invoker, eventid, delay, origin, angles, fparam1, fparam2, iParam1, iParam2, bParam1, bParam2)    

        set_weapon_anim(invoker, SALAMANDER_ANIM_SHOOT_BEGIN)
        
        /*
        if(get_gametime() - 0.1 > FireSound_Delay[invoker])
        {
            emit_sound(invoker, CHAN_WEAPON, WeaponSound[random_num(0, 1)], 1.0, ATTN_NORM, 0, PITCH_NORM)    
            FireSound_Delay[invoker] = get_gametime()
        }*/
        
        return FMRES_SUPERCEDE
    }
    
    return FMRES_HANDLED
}

public fw_CmdStart(id, uc_handle, seed)
{
    if(!is_user_connected(id) || !is_user_alive(id))
        return FMRES_IGNORED
    if(get_user_weapon(id) != CSW_SALAMANDER || !g_had_salamander[id])
        return FMRES_IGNORED
        
    static PressedButton
    PressedButton = get_uc(uc_handle, UC_Buttons)
    
    if(!(PressedButton & IN_ATTACK))
    {
        if((pev(id, pev_oldbuttons) & IN_ATTACK) && pev(id, pev_weaponanim) == SALAMANDER_ANIM_SHOOT_BEGIN)
        {
            static weapon; weapon = fm_get_user_weapon_entity(id, CSW_SALAMANDER)
            if(pev_valid(weapon)) set_pdata_float(weapon, 48, 2.0, 4)
            set_weapon_anim(id, SALAMANDER_ANIM_SHOOT_END)
            make_fire_smoke(id)
        }
    }
        
    return FMRES_HANDLED
}

public fw_Spawn_Post(id)
{
    remove_salamnader(id)
}

public fw_AddToPlayer_Post(ent, id)
{
    if(!pev_valid(ent))
        return HAM_IGNORED
        
    if(pev(ent, pev_impulse) == WEAPON_SECRET_CODE)
    {
        remove_salamnader(id)
        g_had_salamander[id] = 1
    }
    
    message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("WeaponList"), _, id)
    write_string(g_had_salamander[id] == 1 ? "weapon_flamethrower" : "weapon_m249")
    write_byte(3)
    write_byte(200)
    write_byte(-1)
    write_byte(-1)
    write_byte(0)
    write_byte(4)
    write_byte(CSW_SALAMANDER)
    write_byte(0)
    message_end()            
    
    return HAM_HANDLED    
}

public fw_TraceAttack(Ent, Attacker, Float:Damage, Float:Dir[3], ptr, DamageType)
{
    if(!is_user_alive(Attacker))
        return HAM_IGNORED
    if(get_user_weapon(Attacker) != CSW_SALAMANDER || !g_had_salamander[Attacker])
        return HAM_IGNORED
        
    static Float:Origin[3], Float:TargetOrigin[3]
    //get_tr2(ptr, TR_vecEndPos, TargetOrigin)
    
    get_position(Attacker, WEAPON_ATTACH_F, WEAPON_ATTACH_R, WEAPON_ATTACH_U + 10.0, Origin)
    get_position(Attacker, WEAPON_ATTACH_F * 100.0, WEAPON_ATTACH_R, WEAPON_ATTACH_U + 10.0, TargetOrigin)
    
    create_fire(Attacker, Origin, TargetOrigin, FIRE_SPEED)
        
    return HAM_SUPERCEDE
}

public fw_Weapon_PrimaryAttack(ent)
{
    static id; id = pev(ent, pev_owner)
    pev(id, pev_punchangle, g_PunchAngles[id])
    
    return HAM_IGNORED    
}

public fw_Weapon_PrimaryAttack_Post(ent)
{
    static id; id = pev(ent,pev_owner)

    if(get_user_weapon(id) == CSW_SALAMANDER && g_had_salamander[id])
    {
        static Float:push[3]
        pev(id, pev_punchangle, push)
        xs_vec_sub(push, g_PunchAngles[id], push)
        
        xs_vec_mul_scalar(push, RECOIL, push)
        xs_vec_add(push, g_PunchAngles[id], push)
        set_pev(id, pev_punchangle, push)
    }
    
    return HAM_IGNORED    
}

public create_fake_attack(id)
{
    static weapon
    weapon = fm_find_ent_by_owner(-1, "weapon_knife", id)
    
    if(pev_valid(weapon)) ExecuteHamB(Ham_Weapon_PrimaryAttack, weapon)
}

public create_fire(id, Float:Origin[3], Float:TargetOrigin[3], Float:Speed)
{
    new iEnt = create_entity("env_sprite")
    static Float:vfAngle[3], Float:MyOrigin[3], Float:Velocity[3]
    
    pev(id, pev_angles, vfAngle)
    pev(id, pev_origin, MyOrigin)
    
    vfAngle[2] = float(random(18) * 20)

    // set info for ent
    set_pev(iEnt, pev_movetype, MOVETYPE_FLY)
    set_pev(iEnt, pev_rendermode, kRenderTransAdd)
    set_pev(iEnt, pev_renderamt, 250.0)
    set_pev(iEnt, pev_fuser1, get_gametime() + 1.0)    // time remove
    set_pev(iEnt, pev_scale, 0.5)
    set_pev(iEnt, pev_nextthink, get_gametime() + 0.05)
    
    entity_set_string(iEnt, EV_SZ_classname, FIRE_CLASSNAME)
    engfunc(EngFunc_SetModel, iEnt, WeaponResource[0])
    set_pev(iEnt, pev_mins, Float:{-1.0, -1.0, -1.0})
    set_pev(iEnt, pev_maxs, Float:{1.0, 1.0, 1.0})
    set_pev(iEnt, pev_origin, Origin)
    set_pev(iEnt, pev_gravity, 0.01)
    set_pev(iEnt, pev_angles, vfAngle)
    set_pev(iEnt, pev_solid, SOLID_TRIGGER)
    set_pev(iEnt, pev_owner, id)    
    set_pev(iEnt, pev_frame, 0.0)
    set_pev(iEnt, pev_iuser2, get_user_team(id))

    get_speed_vector(Origin, TargetOrigin, Speed, Velocity)
    set_pev(iEnt, pev_velocity, Velocity)
    
    emit_sound(iEnt, CHAN_BODY, WeaponSound[random_num(0, 1)], 1.0, ATTN_NORM, 0, PITCH_NORM)    
}

public fw_Fire_Think(iEnt)
{
    if(!pev_valid(iEnt)) 
        return
    
    new Float:fFrame, Float:fScale, Float:fNextThink
    pev(iEnt, pev_frame, fFrame)
    pev(iEnt, pev_scale, fScale)

    // effect exp
    new iMoveType = pev(iEnt, pev_movetype)
    if (iMoveType == MOVETYPE_NONE)
    {
        fNextThink = 0.015
        fFrame += 1.0
        fScale = floatmax(fScale, 1.75)
        
        if (fFrame > 21.0)
        {
            engfunc(EngFunc_RemoveEntity, iEnt)
            return
        }
    }
    
    // effect normal
    else
    {
        fNextThink = 0.045
        fFrame += 1.0
        fFrame = floatmin(21.0, fFrame)
        fScale += 0.2
        fScale = floatmin(fScale, 1.75)
    }

    set_pev(iEnt, pev_frame, fFrame)
    set_pev(iEnt, pev_scale, fScale)
    set_pev(iEnt, pev_nextthink, get_gametime() + fNextThink)
    
    // time remove
    static Float:fTimeRemove
    pev(iEnt, pev_fuser1, fTimeRemove)
    if (get_gametime() >= fTimeRemove)
    {
        engfunc(EngFunc_RemoveEntity, iEnt)
        return;
    }
}

public fw_Fire_Touch(ent, id)
{
    if(!pev_valid(ent))
        return
        
    if(pev_valid(id))
    {
        static Classname[32]
        pev(id, pev_classname, Classname, sizeof(Classname))
        
        if(equal(Classname, FIRE_CLASSNAME)) return
        else if(is_user_alive(id)) 
        {
            static EntTeam; EntTeam = pev(ent, pev_iuser2)
            if(get_user_team(id) != EntTeam)
            {
                do_attack(pev(ent, pev_owner), id, 0, float(DAMAGE))
                Make_FireBurn(id)
            }
        }
    }
        
    set_pev(ent, pev_movetype, MOVETYPE_NONE)
    set_pev(ent, pev_solid, SOLID_NOT)
}

public make_fire_smoke(id)
{
    static Float:Origin[3]
    get_position(id, WEAPON_ATTACH_F, WEAPON_ATTACH_R, WEAPON_ATTACH_U, Origin)
    
    message_begin(MSG_BROADCAST, SVC_TEMPENTITY) 
    write_byte(TE_EXPLOSION) 
    engfunc(EngFunc_WriteCoord, Origin[0])
    engfunc(EngFunc_WriteCoord, Origin[1])
    engfunc(EngFunc_WriteCoord, Origin[2])
    write_short(g_smokepuff_id) 
    write_byte(5)
    write_byte(30)
    write_byte(14)
    message_end()
}

public Make_FireBurn(id)
{
    static Ent; Ent = fm_find_ent_by_owner(-1, FIREBURN_CLASSNAME, id)
    if(!pev_valid(Ent))
    {
        new iEnt = create_entity("env_sprite")
        static Float:MyOrigin[3]
        
        pev(id, pev_origin, MyOrigin)
        
        // set info for ent
        set_pev(iEnt, pev_movetype, MOVETYPE_FLY)
        set_pev(iEnt, pev_rendermode, kRenderTransAdd)
        set_pev(iEnt, pev_renderamt, 250.0)
        set_pev(iEnt, pev_fuser1, get_gametime() + 5.0)    // time remove
        set_pev(iEnt, pev_scale, 1.0)
        set_pev(iEnt, pev_nextthink, get_gametime() + 0.5)
        
        entity_set_string(iEnt, EV_SZ_classname, FIREBURN_CLASSNAME)
        engfunc(EngFunc_SetModel, iEnt, WeaponResource[1])
        set_pev(iEnt, pev_origin, MyOrigin)
        set_pev(iEnt, pev_owner, id)
        set_pev(iEnt, pev_aiment, id)
        set_pev(iEnt, pev_frame, 0.0)
    }
}

public fw_FireBurn_Think(iEnt)
{
    if(!pev_valid(iEnt)) 
        return
    
    static Float:fFrame
    pev(iEnt, pev_frame, fFrame)

    // effect exp
    fFrame += 1.0
    if(fFrame > 15.0) fFrame = 0.0

    set_pev(iEnt, pev_frame, fFrame)
    set_pev(iEnt, pev_nextthink, get_gametime() + 0.05)
    
    static id
    id = pev(iEnt, pev_owner)
    
    if(get_gametime() - BURN_LOOP > pev(iEnt, pev_fuser2))
    {
        ExecuteHam(Ham_TakeDamage, id, 0, id, 0.0, DMG_BURN)
        if((get_user_health(id) - BURN_DAMAGE) > 0)
            set_user_health(id, get_user_health(id) - BURN_DAMAGE)
        else
            user_kill(id)
        set_pev(iEnt, pev_fuser2, get_gametime())
    }
    
    // time remove
    static Float:fTimeRemove
    pev(iEnt, pev_fuser1, fTimeRemove)
    if (get_gametime() >= fTimeRemove)
    {
        engfunc(EngFunc_RemoveEntity, iEnt)
        return;
    }
}

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 = create_tr2() 
    engfunc(EngFunc_TraceLine, fStart, fAimOrigin, DONT_IGNORE_MONSTERS, iAttacker, ptr)
    new pHit = get_tr2(ptr, TR_pHit)
    new 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 = get_angle_to_target(iAttacker, fVicOrigin)
        iAngleToVictim = abs(iAngleToVictim)
        new Float: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 = create_tr2() 
            engfunc(EngFunc_TraceLine, fStart, fAimInVictim, DONT_IGNORE_MONSTERS, iAttacker, ptr2)
            new pHit2 = get_tr2(ptr2, TR_pHit)
            new 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 = 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)
    
    // hitgroup multi fDamage
    new Float:fMultifDamage 
    switch(iHitgroup)
    {
        case HIT_HEAD: fMultifDamage  = 4.0
        case HIT_STOMACH: fMultifDamage  = 1.25
        case HIT_LEFTLEG: fMultifDamage  = 0.75
        case HIT_RIGHTLEG: fMultifDamage  = 0.75
        default: fMultifDamage  = 1.0
    }
    
    fDamage *= fMultifDamage
    
    // 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))
{
    ExecuteHam(Ham_TraceAttack, iVictim, iAttacker, fDamage, fDirection, iTraceHandle, iDamageBit)
}

stock fake_take_damage(iAttacker, iVictim, Float:fDamage, iInflictor, iDamageBit = (DMG_NEVERGIB | DMG_BULLET))
{
    ExecuteHam(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 = get_angle_between_vectors(fV1, fV2)
    
    if (TargetSize > 0.0)
    {
        new Float:fTan = TargetSize / get_distance_f(fOrigin, fTarget)
        new 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 = floatround(fA1[1] - fA2[1])
    iResult = iResult % 360
    iResult = (iResult > 180) ? (iResult - 360) : iResult
    
    return iResult
}

stock set_weapon_anim(id, anim)
{
    if(!is_user_alive(id) || pev(id, pev_weaponanim) == anim)
        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 drop_weapons(id, dropwhat)
{
    static weapons[32], num, i, weaponid
    num = 0
    get_user_weapons(id, weapons, num)
    
    const PRIMARY_WEAPONS_BIT_SUM = (1<<CSW_SCOUT)|(1<<CSW_XM1014)|(1<<CSW_MAC10)|(1<<CSW_MAC10)|(1<<CSW_UMP45)|(1<<CSW_SG550)|(1<<CSW_MAC10)|(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)
    
    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)
        }
    }
}

stock set_player_nextattack(player, weapon_id, Float:NextTime)
{
    const m_flNextPrimaryAttack = 46
    const m_flNextSecondaryAttack = 47
    const m_flTimeWeaponIdle = 48
    const m_flNextAttack = 83
    
    static weapon
    weapon = fm_get_user_weapon_entity(player, weapon_id)
    
    set_pdata_float(player, m_flNextAttack, NextTime, 5)
    if(pev_valid(weapon))
    {
        set_pdata_float(weapon, m_flNextPrimaryAttack , NextTime, 4)
        set_pdata_float(weapon, m_flNextSecondaryAttack, NextTime, 4)
        set_pdata_float(weapon, m_flTimeWeaponIdle, NextTime, 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 get_speed_vector(const Float:origin1[3],const Float:origin2[3],Float:speed, Float:new_velocity[3])
{
    new_velocity[0] = origin2[0] - origin1[0]
    new_velocity[1] = origin2[1] - origin1[1]
    new_velocity[2] = origin2[2] - origin1[2]
    new Float:num = floatsqroot(speed*speed / (new_velocity[0]*new_velocity[0] + new_velocity[1]*new_velocity[1] + new_velocity[2]*new_velocity[2]))
    new_velocity[0] *= num
    new_velocity[1] *= num
    new_velocity[2] *= num
    
    return 1;
}
/* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
*{\\ rtf1\\ ansi\\ deff0{\\ fonttbl{\\ f0\\ fnil Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ lang1033\\ f0\\ fs16 \n\\ par }
*/
3.
Code:
#include <amxmodx>
#include <engine>
#include <fakemeta>
#include <cstrike>
#include <hamsandwich>
#include <fun>

#define PLUGIN "[ZP] Extra Item: Quad Barrel"
#define VERSION "1.0"
#define AUTHOR "Dias" // Thank for the help of RedPlane

#define m_pPlayer                41
#define m_flNextPrimaryAttack        46
#define m_flNextSecondaryAttack    47
#define m_flTimeWeaponIdle        48
#define m_iClip                51
#define m_fInReload                54
#define m_fInSpecialReload        55

#define XTRA_OFS_WEAPON            4
#define XTRA_OFS_PLAYER        5
#define m_flNextAttack        83
#define m_rgAmmo_player_Slot0    376

new const v_model[] = "models/zombie_plague/v_qbarrel.mdl"
new const p_model[] = "models/zombie_plague/p_qbarrel.mdl"
new const w_model[] = "models/zombie_plague/w_qbarrel.mdl"

new const qb_sound[5][] = {
    "weapons/qbarrel_clipin1.wav",
    "weapons/qbarrel_clipin2.wav",
    "weapons/qbarrel_clipout1.wav",
    "weapons/qbarrel_draw.wav",
    "weapons/qbarrel_shoot.wav"
}

#define CSW_QB CSW_XM1014
new g_had_qb[33], Float:g_last_fire[33], Float:g_last_fire2[33], BloodSpray, BloodDrop
new cvar_default_clip, cvar_delayattack, cvar_reloadtime, cvar_randmg_start, cvar_randmg_end
new g_quad_barrel

public plugin_init()
{
    register_plugin(PLUGIN, VERSION, AUTHOR)
    
    register_event("HLTV", "NewRoundQbarrel", "a", "1=0", "2=0")
    register_event("CurWeapon", "Qb_ViewModel", "be", "1=1")
    register_forward(FM_CmdStart, "Qb_CmdStart")
    register_forward(FM_UpdateClientData, "Qb_ClientDataPost", 1)
    register_forward(FM_SetModel, "Qb_SetModel")    
    
    RegisterHam(Ham_TakeDamage, "player", "QbTakeDmg")
    RegisterHam(Ham_QbTraceAttack, "worldspawn", "QbTraceAttack", 1)
    RegisterHam(Ham_QbTraceAttack, "player", "QbTraceAttack", 1)    
    
    RegisterHam(Ham_Weapon_Reload, "weapon_xm1014", "QbReload", 1)
    RegisterHam(Ham_Weapon_PrimaryAttack, "weapon_xm1014", "QbPriAttack", 1)
    RegisterHam(Ham_Item_PostFrame, "weapon_xm1014", "QbPostFrame")
    RegisterHam(Ham_Item_AddToPlayer, "weapon_xm1014", "QbAddToPlayer", 1)
    
    register_clcmd("lastinv", "QbDrawWeapon")
    register_clcmd("slot1", "QbDrawWeapon")
    
    cvar_default_clip = register_cvar("zp_qbarrel_default_clip", "4")
    cvar_delayattack = register_cvar("zp_qbarrel_delay_attack", "0.35")
    cvar_reloadtime = register_cvar("zp_qbarrel_reload_time", "3.0")
    
    cvar_randmg_start = register_cvar("zp_qbarrel_randomdmg_start", "400.0")
    cvar_randmg_end = register_cvar("zp_qbarrel_randomdmg_end", "600.0")

}

public plugin_precache()
{
    BloodDrop = precache_model("sprites/blood.spr")
    BloodSpray = precache_model("sprites/bloodspray.spr")        
    
    precache_model(v_model)
    precache_model(p_model)
    precache_model(w_model)
    
    for(new i = 0; i < sizeof(qb_sound); i++)
        precache_sound(qb_sound[i])
}

public NewRoundQbarrel()
{
    new iPlayers[32], iNumber
    get_players(iPlayers, iNumber)
    
    for(new i = 0; i < iNumber; i++)
    {
        new id = iPlayers[i]
        
        if(is_user_alive(id) && is_user_connected(id))
            g_had_qb[i] = 0
    }
}

public zp_extra_item_selected(id, itemid)
{
    if(itemid != g_quad_barrel)
        return PLUGIN_HANDLED
    
    g_had_qb[id] = 1
    new ent = give_item(id, "weapon_xm1014")
    
    cs_set_weapon_ammo(ent, get_pcvar_num(cvar_default_clip))
    cs_set_user_bpammo(id, CSW_QB, 20)
    
    set_pdata_float(id, 83, 1.0, 4)
    set_weapon_anim(id, 4)
    
    return PLUGIN_CONTINUE
}


public QbDrawWeapon(id)
{
    set_task(0.001, "do_check", id)
}

public do_check(id)
{
    if(get_user_weapon(id) == CSW_QB && g_had_qb[id])
    {
        set_weapon_anim(id, 4)
    }
}

public Qb_ViewModel(id)
{
    if(!is_user_alive(id) || !is_user_connected(id))
        return
    if(get_user_weapon(id) != CSW_QB || !g_had_qb[id])
        return    
        
    set_pev(id, pev_viewmodel2, v_model)
    set_pev(id, pev_weaponmodel2, p_model)
        
    return 
}

public Qb_ClientDataPost(id, sendweapons, cd_handle)
{
    if(!is_user_alive(id) || !is_user_connected(id))
        return FMRES_IGNORED
    if(get_user_weapon(id) != CSW_QB || !g_had_qb[id])
        return FMRES_IGNORED
        
    set_cd(cd_handle, CD_flNextAttack, halflife_time() + 0.001) 
    
    return FMRES_HANDLED
}

public QbTraceAttack(iEnt, iAttacker, Float:flDamage, Float:fDir[3], ptr, iDamageType)
{
    if(!is_user_alive(iAttacker) || !is_user_connected(iAttacker))
        return HAM_IGNORED        
    if(get_user_weapon(iAttacker) != CSW_QB || !g_had_qb[iAttacker])
        return HAM_IGNORED
    
    static Float:flEnd[3]
    get_tr2(ptr, TR_vecEndPos, flEnd)

    make_bullet(iAttacker, flEnd)

    return HAM_HANDLED
}

public QbTakeDmg(victim, inflictor, attacker, Float:damage, damagebits)
{
    if(!is_user_alive(victim) || !is_user_alive(attacker))
        return HAM_IGNORED

    if(get_user_weapon(attacker) == CSW_QB && g_had_qb[attacker])
    {
        static Float:random_start, Float:random_end
    
        random_start = get_pcvar_float(cvar_randmg_start)
        random_end = get_pcvar_float(cvar_randmg_end)
    
        SetHamParamFloat(4, random_float(random_start, random_end))
    }
    
    return HAM_HANDLED
}

public make_bullet(id, Float:Origin[3])
{
    // Find target
    new target, body
    get_user_aiming(id, target, body, 999999)
    
    if(target > 0 && target <= get_maxplayers())
    {
        new Float:fStart[3], Float:fEnd[3], Float:fRes[3], Float:fVel[3]
        pev(id, pev_origin, fStart)
        
        // Get ids view direction
        velocity_by_aim(id, 64, fVel)
        
        // Calculate position where blood should be displayed
        fStart[0] = Origin[0]
        fStart[1] = Origin[1]
        fStart[2] = Origin[2]
        fEnd[0] = fStart[0]+fVel[0]
        fEnd[1] = fStart[1]+fVel[1]
        fEnd[2] = fStart[2]+fVel[2]
        
        // Draw traceline from victims origin into ids view direction to find
        // the location on the wall to put some blood on there
        new res
        engfunc(EngFunc_TraceLine, fStart, fEnd, 0, target, res)
        get_tr2(res, TR_vecEndPos, fRes)
        
        // Show some blood :)
        message_begin(MSG_BROADCAST, SVC_TEMPENTITY) 
        write_byte(TE_BLOODSPRITE)
        write_coord(floatround(fStart[0])) 
        write_coord(floatround(fStart[1])) 
        write_coord(floatround(fStart[2])) 
        write_short(BloodSpray)
        write_short(BloodDrop)
        write_byte(70)
        write_byte(random_num(1,2))
        message_end()
        
        
        } else {
        new decal = 41
        
        // Check if the wall hit is an entity
        if(target)
        {
            // Put decal on an entity
            message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
            write_byte(TE_DECAL)
            write_coord(floatround(Origin[0]))
            write_coord(floatround(Origin[1]))
            write_coord(floatround(Origin[2]))
            write_byte(decal)
            write_short(target)
            message_end()
            } else {
            // Put decal on "world" (a wall)
            message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
            write_byte(TE_WORLDDECAL)
            write_coord(floatround(Origin[0]))
            write_coord(floatround(Origin[1]))
            write_coord(floatround(Origin[2]))
            write_byte(decal)
            message_end()
        }
        
        // Show sparcles
        message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
        write_byte(TE_GUNSHOTDECAL)
        write_coord(floatround(Origin[0]))
        write_coord(floatround(Origin[1]))
        write_coord(floatround(Origin[2]))
        write_short(id)
        write_byte(decal)
        message_end()
    }
}

public Qb_CmdStart(id, uc_handle, seed)
{
    if(!is_user_alive(id) || !is_user_connected(id))
        return
    if(get_user_weapon(id) != CSW_QB || !g_had_qb[id])
        return 

    new CurButton
    CurButton = get_uc(uc_handle, UC_Buttons)
    
    if(CurButton & IN_RELOAD)
    {
        CurButton &= ~IN_RELOAD
        set_uc(uc_handle, UC_Buttons, CurButton)
        new ent = find_ent_by_owner(-1, "weapon_xm1014", id)
        
        if (!ent)
            return
        
        new fInReload = get_pdata_int(ent, m_fInReload, 4)
            
        new Float:flNextAttack ; flNextAttack = get_pdata_float(id, m_flNextAttack, 5)
        
        if (flNextAttack > 0.0)
            return
            
        if (fInReload)
        {
            set_weapon_anim(id, 0)
            return
        }
        if(cs_get_weapon_ammo(ent) >= get_pcvar_num(cvar_default_clip))
        {
            set_weapon_anim(id, 0)
            return
        }
            
        QbReload(ent)
    }
    
    if(CurButton & IN_ATTACK2)
    {
        static Float:CurTime
        CurTime = get_gametime()
        
        if(CurTime - 4.0 > g_last_fire[id])
        {
            static ent, ammo
            ent = find_ent_by_owner(-1, "weapon_xm1014", id)
            ammo = cs_get_weapon_ammo(ent)
            
            if(cs_get_weapon_ammo(ent) <= 0)
                return            
            
            for(new i = 0; i < ammo; i++)
            {
                ExecuteHamB(Ham_Weapon_PrimaryAttack, ent)
            }
            
            emit_sound(id, CHAN_WEAPON, qb_sound[4], 1.0, ATTN_NORM, 0, PITCH_NORM)
            set_weapon_anim(id, random_num(1, 2))
            
            g_last_fire[id] = CurTime
        }
    }
    
    if(CurButton & IN_ATTACK)
    {
        static Float:CurTime
        CurTime = get_gametime()
        
        CurButton &= ~IN_ATTACK
        set_uc(uc_handle, UC_Buttons, CurButton)
        
        static ent
        ent = find_ent_by_owner(-1, "weapon_xm1014", id)
        
        if(cs_get_weapon_ammo(ent) <= 0 || get_pdata_int(ent, m_fInReload, XTRA_OFS_WEAPON))
            return
        
        if(CurTime - get_pcvar_float(cvar_delayattack) > g_last_fire2[id])
        {
            emit_sound(id, CHAN_WEAPON, qb_sound[4], 1.0, ATTN_NORM, 0, PITCH_NORM)
    
            ExecuteHamB(Ham_Weapon_PrimaryAttack, ent)
            set_weapon_anim(id, random_num(1, 2))
            
            g_last_fire2[id] = CurTime
        }
        
    }    
    
    return 
}

public QbReload(iEnt)
{
    new id = pev(iEnt, pev_owner)
    
    if(g_had_qb[id])
    {
        static Cur_BpAmmo
        Cur_BpAmmo = cs_get_user_bpammo(id, CSW_QB)

        if(Cur_BpAmmo > 0)
        {
            set_pdata_int(iEnt, 55, 0, 4)
            set_pdata_float(id, 83, get_pcvar_float(cvar_reloadtime), 4)
            set_pdata_float(iEnt, 48, get_pcvar_float(cvar_reloadtime) + 0.5, 4)
            set_pdata_float(iEnt, 46, get_pcvar_float(cvar_reloadtime) + 0.25, 4)
            set_pdata_float(iEnt, 47, get_pcvar_float(cvar_reloadtime) + 0.25, 4)
            set_pdata_int(iEnt, 54, 1, 4)
            
            set_weapon_anim(id, 3)            
        }
        
        return HAM_HANDLED
    }
    return HAM_IGNORED
    
}

public Qb_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_xm1014.mdl"))
    {
        static weapon
        weapon = find_ent_by_owner(-1, "weapon_xm1014", entity)
        
        if(!is_valid_ent(weapon))
            return FMRES_IGNORED;
        
        if(g_had_qb[iOwner])
        {
            entity_set_int(weapon, EV_INT_impulse, 120)
            g_had_qb[iOwner] = 0
            set_pev(weapon, pev_iuser3, cs_get_weapon_ammo(weapon))
            entity_set_model(entity, w_model)
            
            return FMRES_SUPERCEDE
        }
    }
    
    return FMRES_IGNORED;
}

public QbAddToPlayer(ent, id)
{
    if(!is_valid_ent(ent))
        return HAM_IGNORED
            
    if(entity_get_int(ent, EV_INT_impulse) == 120)
    {
        g_had_qb[id] = 1
        cs_set_weapon_ammo(ent, pev(ent, pev_iuser3))
        
        entity_set_int(id, EV_INT_impulse, 0)
        QbDrawWeapon(id)
        
        return HAM_HANDLED
    }        

    return HAM_HANDLED
}

public QbPriAttack(ent)
{
    static id
    id = pev(ent, pev_owner)
    
    if(g_had_qb[id])
    {
        if(cs_get_weapon_ammo(ent) > 0)
        {
            emit_sound(id, CHAN_WEAPON, qb_sound[4], 1.0, ATTN_NORM, 0, PITCH_NORM)
        }
        
        set_pdata_float(id, 83, 0.3, 4)
    }
}

public QbPostFrame(iEnt)
{
    new id = pev(iEnt, pev_owner)
    
    if(g_had_qb[id])
    {
        static iBpAmmo ; iBpAmmo = get_pdata_int(id, 381, XTRA_OFS_PLAYER)
        static iClip ; iClip = get_pdata_int(iEnt, m_iClip, XTRA_OFS_WEAPON)
        static iMaxClip ; iMaxClip = get_pcvar_num(cvar_default_clip)

        if(get_pdata_int(iEnt, m_fInReload, XTRA_OFS_WEAPON) && get_pdata_float(id, m_flNextAttack, 5) <= 0.0 )
        {
            new j = min(iMaxClip - iClip, iBpAmmo)
            set_pdata_int(iEnt, m_iClip, iClip + j, XTRA_OFS_WEAPON)
            set_pdata_int(id, 381, iBpAmmo-j, XTRA_OFS_PLAYER)
            
            set_pdata_int(iEnt, m_fInReload, 0, XTRA_OFS_WEAPON)
            cs_set_weapon_ammo(iEnt, get_pcvar_num(cvar_default_clip))
        
            return
        }
    }
}

stock set_weapon_anim(id, anim)
{
    set_pev(id, pev_weaponanim, anim)

    message_begin(MSG_ONE_UNRELIABLE, SVC_WEAPONANIM, _, id)
    write_byte(anim)
    write_byte(pev(id,pev_body))
    message_end()
}
4.
Code:
#include <amxmodx>
#include <hamsandwich>
#include <fun>
#include <cstrike>
#include <fakemeta>
#include <engine>

#define PLUGIN "[ZP] Extra Item : K1ASES"
#define VERSION "0.1"

#define ICON_HIDE 0
#define ICON_SHOW 1   
#define fm_create_entity(%1) engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, %1))

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)
const SECONDARY_WEAPONS_BIT_SUM = (1<<CSW_P228)|(1<<CSW_ELITE)|(1<<CSW_FIVESEVEN)|(1<<CSW_USP)|(1<<CSW_GLOCK18)|(1<<CSW_DEAGLE)

new g_k1ase[33],g_k1ases_loaded[33],g_ammo[33],g_lastweap[33];
new cvar_crazynade,cvar_knockback,cvar_trail,cvar_radius,cvar_damage,cvar_reload,cvar_remove;
new gmsgDeathMsg,gMsgID,m_iTrail,xplode;

public plugin_init() {
    register_plugin(PLUGIN, VERSION,"AMDEM")
    
    register_event("DeathMsg","player_die","abd")  
    register_event("CurWeapon","handle_gun","be","1=1")
    RegisterHam(Ham_Killed, "player", "player_die")
    RegisterHam(Ham_Spawn, "player", "player_spawn")
    
    
    register_forward(FM_CmdStart, "forward_CmdStart")
    register_forward(FM_SetModel, "forward_setmodel") 
    
    cvar_crazynade = register_cvar("zp_tmpk1ases_crazynade","0") 
    cvar_knockback = register_cvar("zp_tmpk1ases_conc","10.0")
    cvar_trail     = register_cvar("zp_tmpk1ases_trail","1")
    cvar_radius    = register_cvar("zp_tmpk1ases_rad","50")
    cvar_damage    = register_cvar("zp_tmpk1ases_dmg","5000")
    cvar_reload    = register_cvar("zp_tmpk1ases_reloadtime","0.5")
    cvar_remove    = register_cvar("zp_tmpk1ases_remove","0")
    
    gmsgDeathMsg = get_user_msgid("DeathMsg")
    gMsgID = get_user_msgid("StatusIcon")
    
}
public plugin_precache()           
{
    precache_model("models/k1ases/v_k1ases.mdl")
    precache_model("models/k1ases/p_k1ases.mdl")
    precache_model("models/k1ases/w_k1ases.mdl")
    precache_model("models/k1ases/grenade.mdl")
    precache_sound("k1ases/k1ases_lg_exp.wav")
    precache_sound("k1ases/k1ases_lg_fire.wav")
    
    m_iTrail = precache_model("sprites/k1ases/k1ases.spr")
    xplode = precache_model("sprites/k1ases/k1ases_explode.spr")
}


public client_connect(id)      
{
    g_k1ase[id] = 0
    g_k1ases_loaded[id] = 1
    g_ammo[id] = 0     
}


public player_die(id)        
{
    if(g_k1ase[id])
        ammo_hud(id,0)
    
    g_ammo[id] = 0
    g_k1ase[id] = 0
    return PLUGIN_CONTINUE
}

public give_k1ases(id)
{
    if(is_user_alive(id))
    {    
        drop_weapons(id, 1)
        
        give_item(id, "weapon_tmp")
        g_k1ase[id] = 1;
        g_ammo[id] = 10 // numarul de grenazi de la k1ases
        ammo_hud(id,1)
    }
}

public player_spawn(id)  
{
    if ( get_pcvar_num(cvar_remove) == 1 &&  g_k1ase[id] )
    {
        ammo_hud(id,0)
        g_k1ase[id] = 0
        g_ammo[id] = 0
    }
    
}

public forward_setmodel(entity, model[]) 
{
    if (!is_valid_ent(entity)) 
    {
        return FMRES_IGNORED
    }
    
    if (equal(model, "models/w_tmp.mdl")) 
    {
        new classname[11]
        entity_get_string(entity, EV_SZ_classname, classname, 10)
        
        if (equal(classname, "weaponbox")) 
        {
            entity_set_model(entity, "models/k1ases/w_k1ases.mdl")
            return FMRES_SUPERCEDE
        }
    }
    
    return FMRES_IGNORED
}

public forward_CmdStart(id, uc_handle, seed)
{
    if(is_user_alive(id) && get_user_weapon(id) == CSW_TMP)
    {
        if (entity_get_int(id, EV_INT_button) & IN_ATTACK2)
        {
            launch_nade(id)
            return FMRES_IGNORED
        }
    }
    return FMRES_IGNORED
}


public handle_gun(id)
{
    new clip, ammo
    new weap = get_user_weapon(id,clip,ammo)
    
    if(weap == CSW_TMP && g_lastweap[id] != weap && g_k1ase[id] )
    {
        ammo_hud(id,1)
        entity_set_string(id, EV_SZ_viewmodel, "models/k1ases/v_k1ases.mdl")
        entity_set_string(id, EV_SZ_weaponmodel, "models/k1ases/p_k1ases.mdl")
    }
    else if(!g_k1ase[id] || weap != CSW_TMP )
    {
        ammo_hud(id,0)
    }
    g_lastweap[id] = weap
    
    return PLUGIN_HANDLED
}

public launch_nade(id)
{
    if(g_k1ase[id] == 0 || g_k1ases_loaded[id] == 0 || !(is_user_alive(id)))
        return PLUGIN_CONTINUE
    
    if(g_ammo[id] == 0)
    {
        client_print(id, print_center, "[ Furien ] Nu ai Gloante !")
        return PLUGIN_CONTINUE
    }
    
    entity_set_int(id, EV_INT_weaponanim, 3)
    
    new Float: Origin[3], Float: Velocity[3], Float: vAngle[3], Ent
    
    entity_get_vector(id, EV_VEC_origin , Origin)
    entity_get_vector(id, EV_VEC_v_angle, vAngle)
    
    Origin[2] = Origin[2] + 10
    
    Ent = create_entity("info_target")
    
    if (!Ent) return PLUGIN_HANDLED
    
    entity_set_string(Ent, EV_SZ_classname, "k1ases_nade")
    entity_set_model(Ent, "models/k1ases/grenade.mdl")
    
    new Float:MinBox[3] = {-1.0, -1.0, -1.0}
    new Float:MaxBox[3] = {1.0, 1.0, 1.0}
    entity_set_vector(Ent, EV_VEC_mins, MinBox)
    entity_set_vector(Ent, EV_VEC_maxs, MaxBox)
    
    entity_set_origin(Ent, Origin)
    entity_set_vector(Ent, EV_VEC_angles, vAngle)
    
    entity_set_int(Ent, EV_INT_effects, 2)
    entity_set_int(Ent, EV_INT_solid, 1)
    entity_set_int(Ent, EV_INT_movetype, 10)
    entity_set_edict(Ent, EV_ENT_owner, id)
    
    VelocityByAim(id, 2500 , Velocity)
    entity_set_vector(Ent, EV_VEC_velocity ,Velocity)
    
    emit_sound(id,CHAN_VOICE,"k1ases/k1ases_lg_fire.wav", 1.0, ATTN_NORM, 0, PITCH_NORM) 
    
    g_k1ases_loaded[id] = 0
    
    ammo_hud(id,0)
    g_ammo[id]--
    ammo_hud(id,1)
    
    new parm[1]
    parm[0] = Ent
    
    if(get_pcvar_num(cvar_trail))
        set_task(0.2, "grentrail",id,parm,1)
    
    parm[0] = id
    
    set_task(get_pcvar_float(cvar_reload), "k1ases_reload",id+9910,parm,1)
    
    return PLUGIN_CONTINUE
}

public k1ases_reload(parm[])
{  
    g_k1ases_loaded[parm[0]] = 1
}

public vexd_pfntouch(pToucher, pTouched) 
{
    new szClassName[32]
    
    if ( pToucher > 0) 
    {
        entity_get_string(pToucher, EV_SZ_classname, szClassName, 31)
    }
    if(equal(szClassName, "k1ases_nade")) 
    {
        if(!pTouched && get_pcvar_num(cvar_crazynade))
            return
        
        new damradius = get_pcvar_num(cvar_radius)
        new maxdamage = get_pcvar_num(cvar_damage)
        
        new tkill = 0
        new Float:fl_vExplodeAt[3]
        entity_get_vector(pToucher, EV_VEC_origin, fl_vExplodeAt)
        new vExplodeAt[3]
        vExplodeAt[0] = floatround(fl_vExplodeAt[0])
        vExplodeAt[1] = floatround(fl_vExplodeAt[1])
        vExplodeAt[2] = floatround(fl_vExplodeAt[2])
        new oid = entity_get_edict(pToucher, EV_ENT_owner)
        new origin[3],dist,i,Float:dRatio,damage
        
        for ( i = 0; i < 32; i++) 
        {
            if((is_user_alive(i)))
            {
                get_user_origin(i,origin)
                dist = get_distance(origin,vExplodeAt)
                if (dist <= damradius) 
                {      
                    dRatio = floatdiv(float(dist),float(damradius))
                    damage = maxdamage - floatround(floatmul(float(maxdamage),dRatio))
                    
                    set_velocity_from_origin(i, fl_vExplodeAt, get_pcvar_float(cvar_knockback)*damage) 
                    
                    if(cvar_exists("mp_friendlyfire")) 
                    {
                        if(i == oid)
                            do_victim(i, oid, damage, 2)
                        else if( get_cvar_num("mp_friendlyfire")) 
                        {
                            if(get_user_team(i) == get_user_team(oid)) tkill = 1
                            do_victim(i,oid,damage,tkill)
                        }
                        else 
                        {
                            if(get_user_team(i) != get_user_team(oid)) 
                            {
                                do_victim(i,oid,damage,0)
                            }                          
                        }
                    }
                    else if(i == oid)
                        do_victim(i, oid, damage, 2)
                    else 
                        do_victim(i,oid,damage,0)      
                }
            }
        }
        
        message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
        write_byte(17)
        write_coord(vExplodeAt[0])
        write_coord(vExplodeAt[1])
        write_coord(vExplodeAt[2] + 60)
        write_short(xplode)
        write_byte(20)
        write_byte(200)
        message_end()
        
        emit_sound(pToucher, CHAN_WEAPON, "k1ases/k1ases_lg_exp.wav", VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
        
        remove_entity(pToucher)
    }
}

public do_victim(victim,attacker,damage,tk) 
{
    new namek[32],namev[32],authida[35],authidv[35],teama[32],teamv[32]
    get_user_name(victim,namev,31)
    get_user_name(attacker,namek,31)
    get_user_authid(victim,authidv,34)
    get_user_authid(attacker,authida,34)
    get_user_team(victim,teamv,31)
    get_user_team(attacker,teama,31)
    
    new Float:fl_dmg = float(damage)
    
    if(damage >= get_user_health(victim))
    {
        set_msg_block(gmsgDeathMsg,BLOCK_SET)
        fakedamage(victim, "grenade", fl_dmg, DMG_BLAST)  
        set_msg_block(gmsgDeathMsg,BLOCK_NOT)
        
        if(is_user_alive(victim))
            return
        
        message_begin(MSG_ALL, get_user_msgid("DeathMsg"), {0,0,0}, 0)
        write_byte(attacker)
        write_byte(victim)
        write_byte(0)
        write_string("grenade")
        message_end()
        if(tk == 1)     
        {
            log_message("^"%s<%d><%s><%s>^" killed ^"%s<%d><%s><%s>^" with ^"grenade^"",
            namek,get_user_userid(attacker),authida,teama,namev,get_user_userid(victim),authidv,teamv)
        }
        else if(tk == 2)
        {
            log_message("^"%s<%d><%s><%s>^" killed self with ^"grenade^"",
            namek,get_user_userid(attacker),authida,teama)
        } 
    }
    else 
    {
        fakedamage(victim, "grenade", fl_dmg, DMG_BLAST) 
    }
}


public ammo_hud(id, sw)
{
    new s_sprite[33]
    format(s_sprite,32,"number_%d",g_ammo[id])
    
    if(sw)
    {
        message_begin( MSG_ONE, gMsgID, {0,0,0}, id )
        write_byte( ICON_SHOW ) // status
        write_string( s_sprite ) // sprite name
        write_byte( 0 ) // red
        write_byte( 0 ) // green
        write_byte( 150 ) // blue
        message_end()
    }
    else
    {
        message_begin( MSG_ONE, gMsgID, {0,0,0}, id )
        write_byte( ICON_HIDE ) // status
        write_string( s_sprite ) // sprite name
        write_byte( 0 ) // red
        write_byte( 0 ) // green
        write_byte( 150 ) // blue
        message_end()
    }
}

stock get_velocity_from_origin( ent, Float:fOrigin[3], Float:fSpeed, Float:fVelocity[3] )
{
    new Float:fEntOrigin[3];
    entity_get_vector( ent, EV_VEC_origin, fEntOrigin );
    
    
    new Float:fDistance[3];
    fDistance[0] = fEntOrigin[0] - fOrigin[0];
    fDistance[1] = fEntOrigin[1] - fOrigin[1];
    fDistance[2] = fEntOrigin[2] - fOrigin[2];
    
    new Float:fTime = ( vector_distance( fEntOrigin,fOrigin ) / fSpeed );
    
    fVelocity[0] = fDistance[0] / fTime;
    fVelocity[1] = fDistance[1] / fTime;
    fVelocity[2] = fDistance[2] / fTime;
    
    return ( fVelocity[0] && fVelocity[1] && fVelocity[2] );
}



stock set_velocity_from_origin( ent, Float:fOrigin[3], Float:fSpeed )
{
    new Float:fVelocity[3];
    get_velocity_from_origin( ent, fOrigin, fSpeed, fVelocity )
    
    entity_set_vector( ent, EV_VEC_velocity, fVelocity );
    
    return ( 1 );
} 

public grentrail(parm[])
{
    new gid = parm[0]
    
    if (gid) 
    {
        message_begin( MSG_BROADCAST, SVC_TEMPENTITY )
        write_byte( TE_BEAMFOLLOW )
        write_short(gid) // entity
        write_short(m_iTrail)  // model
        write_byte( 10 )       // life
        write_byte( 5 )        // width
        write_byte( 255 )      // r, g, b
        write_byte( 255 )    // r, g, b
        write_byte( 255 )      // r, g, b
        write_byte( 100 ) // brightness
        
        message_end() // move PHS/PVS data sending into here (SEND_ALL, SEND_PVS, SEND_PHS)
    }
}

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)) || (dropwhat == 2 && ((1<<weaponid) & SECONDARY_WEAPONS_BIT_SUM)))
        {
            static wname[32]
            get_weaponname(weaponid, wname, charsmax(wname))
            
            engclient_cmd(id, "drop", wname)
            cs_set_user_bpammo(id, weaponid, 0)
        }
    }
}
Or, the fisrt Two
Thanks all, and A Happy New Year !!!

Last edited by FaNr; 12-29-2013 at 10:37.
FaNr is offline
 



Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off

Forum Jump


All times are GMT -4. The time now is 20:41.


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