AlliedModders

AlliedModders (https://forums.alliedmods.net/index.php)
-   Suggestions / Requests (https://forums.alliedmods.net/forumdisplay.php?f=12)
-   -   [ Combine ] 4 Plugins -> (https://forums.alliedmods.net/showthread.php?t=232352)

FaNr 12-29-2013 10:31

[ Combine ] 4 Plugins ->
 
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 :D
Thanks all, and A Happy New Year !!!

wickedd 12-29-2013 10:38

Re: [ Combine ] 4 Plugins ->
 
Why combine them?

FaNr 12-29-2013 10:39

Re: [ Combine ] 4 Plugins ->
 
Quote:

Originally Posted by wickedd (Post 2077988)
Why combine them?

Because I don't want too more plugins on server . :D

wickedd 12-29-2013 10:45

Re: [ Combine ] 4 Plugins ->
 
Combining them is useless, it will still use the same amount of CPUs.

FaNr 12-29-2013 10:48

Re: [ Combine ] 4 Plugins ->
 
Quote:

Originally Posted by wickedd (Post 2077993)
Combining them is useless, it will still use the same amount of CPUs.

Who can combine hiim, made it.
I Try, and if don't working I will added it separated on server.




Sorry For my Bad English .
If you're need I can give you a plugin ... at example, but his don' working.

Kia 12-29-2013 12:28

Re: [ Combine ] 4 Plugins ->
 
It's useless to combine them, it won't increase your performance (lot).

FaNr 12-29-2013 12:51

Re: [ Combine ] 4 Plugins ->
 
Quote:

Originally Posted by Kia (Post 2078028)
It's useless to combine them, it won't increase your performance (lot).

If you can, made it. !

BLacking98 12-29-2013 12:53

Re: [ Combine ] 4 Plugins ->
 
Use Spoilers next time o.o

Kia 12-29-2013 13:15

Re: [ Combine ] 4 Plugins ->
 
Quote:

Originally Posted by FaNr (Post 2078041)
If you can, made it. !

Not intrested, maybe someone else.


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

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