Re: Ultimate VIP Features
Posted: 02 Jul 2019, 11:16
Thanks
Zombie Escape Mod for Counter-Strike 1.6
https://escapers-zone.net/
Code: Select all
#include <zombie_escape>
#include <ze_vip>
#include <amxconst>
#include <fakemeta>
#include <fakemeta_util>
#include <cstrike>
#include <xs>
#include <engine>
#include <fun>
#define PLUGIN "[CSO] Salamander"
#define VERSION "2015"
#define AUTHOR "Dias Pendragon Leon"
#define CSW_SAL CSW_M249
#define weapon_sal "weapon_m249"
#define DAMAGE 38
#define FIRE_SPEED 640.0
#define RECOIL 0.0
#define MODEL_V "models/v_salamander.mdl"
#define MODEL_P "models/p_salamander.mdl"
#define MODEL_W "models/w_salamander.mdl"
#define DEFAULT_W_MODEL "models/w_m249.mdl"
new const WeaponSounds[6][] =
{
"weapons/flamegun-1.wav",
"weapons/flamegun_draw.wav",
"weapons/flamegun_clipin1.wav",
"weapons/flamegun_clipin2.wav",
"weapons/flamegun_clipout1.wav",
"weapons/flamegun_clipout2.wav"
}
new const WeaponResources[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
{
ANIM_IDLE = 0,
ANIM_SHOOT,
ANIM_SHOOT_END,
ANIM_RELOAD,
ANIM_DRAW
}
// Marcros
#define Get_BitVar(%1,%2) (%1 & (1 << (%2 & 31)))
#define Set_BitVar(%1,%2) (%1 |= (1 << (%2 & 31)));
#define UnSet_BitVar(%1,%2) (%1 &= ~(1 << (%2 & 31)));
// Vars
new g_Had_Salamander, g_WeaponEnt, g_SmokePuff_SprID, Float:g_PunchAngles[33]
new g_MsgCurWeapon, g_MsgWeaponList
// Safety
new g_HamBot
new g_IsConnected, g_IsAlive, g_PlayerWeapon[33]
new g_iItemId
public plugin_init()
{
register_plugin(PLUGIN, VERSION, AUTHOR)
// Your highness!
Register_SafetyFunc()
// Forward
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_forward(FM_PrecacheEvent, "fw_PrecacheEvent_Post", 1)
// Engine
register_think("fireinsaigon", "fw_Fire_Think")
register_touch("fireinsaigon", "*", "fw_Fire_Touch")
// Hams
RegisterHam(Ham_Item_Deploy, weapon_sal, "fw_Item_Deploy_Post", 1)
RegisterHam(Ham_Item_AddToPlayer, weapon_sal, "fw_Item_AddToPlayer_Post", 1)
RegisterHam(Ham_TraceAttack, "player", "fw_TraceAttack")
RegisterHam(Ham_TraceAttack, "worldspawn", "fw_TraceAttack")
RegisterHam(Ham_Weapon_PrimaryAttack, weapon_sal, "fw_Weapon_PrimaryAttack")
RegisterHam(Ham_Weapon_PrimaryAttack, weapon_sal, "fw_Weapon_PrimaryAttack_Post", 1)
g_MsgCurWeapon = get_user_msgid("CurWeapon")
g_MsgWeaponList = get_user_msgid("WeaponList")
// register_clcmd("say /get", "Get_Salamander")
register_clcmd("weapon_flamethrower", "Hook_Weapon")
g_iItemId = ze_register_item("CSO Salamander", 100, 0)
ze_set_item_vip(g_iItemId, "VIP_A")
}
public plugin_precache()
{
precache_model(MODEL_V)
precache_model(MODEL_P)
precache_model(MODEL_W)
for(new i = 0; i < sizeof(WeaponSounds); i++)
precache_sound(WeaponSounds[i])
for(new i = 0; i < sizeof(WeaponResources); i++)
{
if(i == 2) precache_generic(WeaponResources[i])
else if(i == 6) g_SmokePuff_SprID = precache_model(WeaponResources[i])
else precache_model(WeaponResources[i])
}
}
public fw_PrecacheEvent_Post(type, const name[])
{
if(equal("events/m249.sc", name))
g_WeaponEnt = get_orig_retval()
}
public client_putinserver(id)
{
Safety_Connected(id)
if(!g_HamBot && is_user_bot(id))
{
g_HamBot = 1
set_task(0.1, "Register_HamBot", id)
}
}
public Register_HamBot(id)
{
Register_SafetyFuncBot(id)
RegisterHamFromEntity(Ham_TraceAttack, id, "fw_TraceAttack")
}
public client_disconnected(id)
{
Safety_Disconnected(id)
}
public Hook_Weapon(id)
{
engclient_cmd(id, weapon_sal)
return PLUGIN_HANDLED
}
public Get_Salamander(id)
{
Set_BitVar(g_Had_Salamander, id)
give_item(id, weapon_sal)
message_begin(MSG_ONE_UNRELIABLE, g_MsgCurWeapon, _, id)
write_byte(1)
write_byte(CSW_SAL)
write_byte(100)
message_end()
cs_set_user_bpammo(id, CSW_SAL, 200)
}
public Remove_Salamander(id)
{
UnSet_BitVar(g_Had_Salamander, id)
}
public fw_UpdateClientData_Post(id, sendweapons, cd_handle)
{
if(!is_alive(id))
return FMRES_IGNORED
if(get_player_weapon(id) != CSW_SAL || !Get_BitVar(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_sal, entity)
if(!pev_valid(weapon))
return FMRES_IGNORED
if(Get_BitVar(g_Had_Salamander, id))
{
set_pev(weapon, pev_impulse, 442015)
engfunc(EngFunc_SetModel, entity, MODEL_W)
UnSet_BitVar(g_Had_Salamander, 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_alive(invoker))
return FMRES_IGNORED
if(get_player_weapon(invoker) != CSW_SAL || !Get_BitVar(g_Had_Salamander, invoker))
return FMRES_IGNORED
if(eventid == g_WeaponEnt)
{
playback_event(flags | FEV_HOSTONLY, invoker, eventid, delay, origin, angles, fparam1, fparam2, iParam1, iParam2, bParam1, bParam2)
if(pev(invoker, pev_weaponanim) != ANIM_SHOOT) Set_WeaponAnim(invoker, ANIM_SHOOT)
return FMRES_SUPERCEDE
}
return FMRES_HANDLED
}
public fw_CmdStart(id, uc_handle, seed)
{
if(!is_alive(id))
return FMRES_IGNORED
if(get_player_weapon(id) != CSW_SAL || !Get_BitVar(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) == ANIM_SHOOT)
{
static weapon; weapon = fm_get_user_weapon_entity(id, CSW_SAL)
if(pev_valid(weapon)) set_pdata_float(weapon, 48, 2.0, 4)
Set_WeaponAnim(id, ANIM_SHOOT_END)
Make_FireSmoke(id)
}
}
return FMRES_HANDLED
}
public Make_FireSmoke(id)
{
static Float:Origin[3]
get_position(id, 40.0, 5.0, -15.0, 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_SprID)
write_byte(5)
write_byte(30)
write_byte(14)
message_end()
}
public fw_Item_Deploy_Post(Ent)
{
if(pev_valid(Ent) != 2)
return
static Id; Id = get_pdata_cbase(Ent, 41, 4)
if(get_pdata_cbase(Id, 373) != Ent)
return
if(!Get_BitVar(g_Had_Salamander, Id))
return
set_pev(Id, pev_viewmodel2, MODEL_V)
set_pev(Id, pev_weaponmodel2, MODEL_P)
}
public fw_Item_AddToPlayer_Post(Ent, id)
{
if(!pev_valid(Ent))
return HAM_IGNORED
if(pev(Ent, pev_impulse) == 442015)
{
Set_BitVar(g_Had_Salamander, id)
set_pev(Ent, pev_impulse, 0)
}
if(Get_BitVar(g_Had_Salamander, id))
{
message_begin(MSG_ONE_UNRELIABLE, g_MsgWeaponList, _, id)
write_string("weapon_flamethrower")
write_byte(3)
write_byte(200)
write_byte(-1)
write_byte(-1)
write_byte(0)
write_byte(4)
write_byte(CSW_SAL)
write_byte(0)
message_end()
}
return HAM_HANDLED
}
public fw_TraceAttack(Ent, Attacker, Float:Damage, Float:Dir[3], ptr, DamageType)
{
if(!is_alive(Attacker))
return HAM_IGNORED
if(get_player_weapon(Attacker) != CSW_SAL || !Get_BitVar(g_Had_Salamander, Attacker))
return HAM_IGNORED
return HAM_SUPERCEDE
}
public CreateFire(id, Float:Speed)
{
new iEnt = create_entity("env_sprite")
if(!pev_valid(iEnt)) return
static Float:vfAngle[3], Float:MyOrigin[3]
static Float:Origin[3], Float:TargetOrigin[3], Float:Velocity[3]
get_position(id, 40.0, 5.0, -5.0, Origin)
get_position(id, 1024.0, 0.0, 0.0, TargetOrigin)
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, 160.0)
set_pev(iEnt, pev_fuser1, get_gametime() + 1.0) // time remove
set_pev(iEnt, pev_scale, 0.25)
set_pev(iEnt, pev_nextthink, get_gametime() + 0.05)
entity_set_string(iEnt, EV_SZ_classname, "fireinsaigon")
engfunc(EngFunc_SetModel, iEnt, WeaponResources[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, WeaponSounds[0], 1.0, ATTN_NORM, 0, PITCH_NORM)
}
public fw_Fire_Think(iEnt)
{
if(!pev_valid(iEnt))
return
static Float:fFrame, Float:fScale
pev(iEnt, pev_frame, fFrame)
pev(iEnt, pev_scale, fScale)
// effect exp
if(pev(iEnt, pev_movetype) == MOVETYPE_NONE)
{
fFrame += 1.0
fScale += 0.1
fScale = floatmin(fScale, 1.75)
if(fFrame > 21.0)
{
engfunc(EngFunc_RemoveEntity, iEnt)
return
}
set_pev(iEnt, pev_nextthink, get_gametime() + 0.025)
} else {
fFrame += 1.25
fFrame = floatmin(21.0, fFrame)
fScale += 0.15
fScale = floatmin(fScale, 1.75)
set_pev(iEnt, pev_nextthink, get_gametime() + 0.05)
}
set_pev(iEnt, pev_frame, fFrame)
set_pev(iEnt, pev_scale, fScale)
// 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, "fireinsaigon")) return
else if(is_alive(id))
{
static EntTeam; EntTeam = pev(ent, pev_iuser2)
if(get_user_team(id) != EntTeam)
{
static Attacker; Attacker = pev(ent, pev_owner)
if(is_connected(Attacker))
{
ExecuteHamB(Ham_TakeDamage, id, 0, Attacker, float(DAMAGE), DMG_BULLET)
}
}
}
}
set_pev(ent, pev_movetype, MOVETYPE_NONE)
set_pev(ent, pev_solid, SOLID_NOT)
}
public ze_select_item_pre(id, itemid)
{
// If it is not the gun the player is willing to buy then just make it available.
// g_iItemId is the handler you made it before.
// You can name itemid whatever you like but just not the same handler name.
if (itemid != g_iItemId)
return ZE_ITEM_AVAILABLE
// In this item we are working on, it will be for humans only so we need to hide it for zombies so they do not get it.
//If you want it to be for zombies, you need to add the not operator "!" before the native so it's gonna be like this:
// if (!ze_is_user_zombie(id))
// If you want an item to be for zombies & humans then just don't add the next code.
if (ze_is_user_zombie(id))
return ZE_ITEM_DONT_SHOW
// Here we need to return a value so you don't get a warning on compiling.
return ZE_ITEM_AVAILABLE
}
public ze_select_item_post(id, itemid)
{
// Here we just block buying the gun if it is not the gun the player is willing to buy so we just add return without values.
if (itemid != g_iItemId)
return
// Here you can give the item & you can even add a message to notice the player what he bought for example like this:
ze_colored_print(id, "You have successfully bought the item.")
// Do you remember in public plugin_init(), we found something like this in it:
// register_clcmd("say /get", "Get_MyWeapon")
// That line is to allow you to get the gun for free when you type that command.
// Well, we don't care about it, we care about:
// Get_MyWeapon
// This is the function we will use to give the weapon to the player
// It's like this:
Get_Salamander(id)
}
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_player_weapon(id) == CSW_SAL && Get_BitVar(g_Had_Salamander, id) && cs_get_weapon_ammo(ent) > 0)
{
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)
CreateFire(id, FIRE_SPEED)
} else {
static Float:push[3]
pev(id, pev_punchangle, push)
xs_vec_sub(push, g_PunchAngles[id], push)
xs_vec_mul_scalar(push, 0.0, push)
xs_vec_add(push, g_PunchAngles[id], push)
set_pev(id, pev_punchangle, push)
}
return HAM_IGNORED
}
stock Set_WeaponIdleTime(id, WeaponId ,Float:TimeIdle)
{
static entwpn; entwpn = fm_get_user_weapon_entity(id, WeaponId)
if(!pev_valid(entwpn))
return
set_pdata_float(entwpn, 46, TimeIdle, 4)
set_pdata_float(entwpn, 47, TimeIdle, 4)
set_pdata_float(entwpn, 48, TimeIdle + 0.5, 4)
}
stock Set_PlayerNextAttack(id, Float:nexttime)
{
set_pdata_float(id, 83, nexttime, 5)
}
stock Set_WeaponAnim(id, anim)
{
set_pev(id, pev_weaponanim, anim)
message_begin(MSG_ONE_UNRELIABLE, SVC_WEAPONANIM, {0, 0, 0}, id)
write_byte(anim)
write_byte(pev(id, pev_body))
message_end()
}
stock 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;
}
stock get_weapon_attachment(id, Float:output[3], Float:fDis = 40.0)
{
static Float:vfEnd[3], viEnd[3]
get_user_origin(id, viEnd, 3)
IVecFVec(viEnd, vfEnd)
static Float:fOrigin[3], Float:fAngle[3]
pev(id, pev_origin, fOrigin)
pev(id, pev_view_ofs, fAngle)
xs_vec_add(fOrigin, fAngle, fOrigin)
static Float:fAttack[3]
xs_vec_sub(vfEnd, fOrigin, fAttack)
xs_vec_sub(vfEnd, fOrigin, fAttack)
static Float:fRate
fRate = fDis / vector_length(fAttack)
xs_vec_mul_scalar(fAttack, fRate, fAttack)
xs_vec_add(fOrigin, fAttack, output)
}
/* ===============================
------------- SAFETY -------------
=================================*/
public Register_SafetyFunc()
{
register_event("CurWeapon", "Safety_CurWeapon", "be", "1=1")
RegisterHam(Ham_Spawn, "player", "fw_Safety_Spawn_Post", 1)
RegisterHam(Ham_Killed, "player", "fw_Safety_Killed_Post", 1)
}
public Register_SafetyFuncBot(id)
{
RegisterHamFromEntity(Ham_Spawn, id, "fw_Safety_Spawn_Post", 1)
RegisterHamFromEntity(Ham_Killed, id, "fw_Safety_Killed_Post", 1)
}
public Safety_Connected(id)
{
Set_BitVar(g_IsConnected, id)
UnSet_BitVar(g_IsAlive, id)
g_PlayerWeapon[id] = 0
}
public Safety_Disconnected(id)
{
UnSet_BitVar(g_IsConnected, id)
UnSet_BitVar(g_IsAlive, id)
g_PlayerWeapon[id] = 0
}
public Safety_CurWeapon(id)
{
if(!is_alive(id))
return
static CSW; CSW = read_data(2)
if(g_PlayerWeapon[id] != CSW) g_PlayerWeapon[id] = CSW
}
public fw_Safety_Spawn_Post(id)
{
if(!is_user_alive(id))
return
Set_BitVar(g_IsAlive, id)
}
public fw_Safety_Killed_Post(id)
{
UnSet_BitVar(g_IsAlive, id)
}
public is_connected(id)
{
if(!(1 <= id <= 32))
return 0
if(!Get_BitVar(g_IsConnected, id))
return 0
return 1
}
public is_alive(id)
{
if(!is_connected(id))
return 0
if(!Get_BitVar(g_IsAlive, id))
return 0
return 1
}
public get_player_weapon(id)
{
if(!is_alive(id))
return 0
return g_PlayerWeapon[id]
}
// ===================== STOCK... =======================
// ======================================================
Code: Select all
/*
* Stun Rifle is a CSO weapon, More information about it: http://cso.wikia.com/wiki/Stun_Rifle
*
* This plugin written by me: Raheem (The basic things for any weapon not written by me)
*
* I tried to simulate it same as in CSO, I think it's nearly same else simple things
* That will be done in next versions.
*
* Version 1.0 creation date: 16-6-2018
* Version 1.0 publication date: 20-6-2018
*
* Last update: 4-8-2018
*
* TODO List: Fix any problem, include good ideas
*/
#include <zombie_escape>
#include <fakemeta_util>
#define CustomItem(%0) (pev(%0, pev_impulse) == WEAPON_KEY)
// CWeaponBox
#define m_rgpPlayerItems_CWeaponBox 34
// CBasePlayerItem
#define m_pPlayer 41
#define m_pNext 42
#define m_iId 43
// CBasePlayerWeapon
#define m_flNextPrimaryAttack 46
#define m_flNextSecondaryAttack 47
#define m_flTimeWeaponIdle 48
#define m_iPrimaryAmmoType 49
#define m_iClip 51
#define m_fInReload 54
#define m_iWeaponState 74
// CBaseMonster
#define m_flNextAttack 83
// CBasePlayer
#define m_iFOV 363
#define m_rpgPlayerItems 367
#define m_pActiveItem 373
#define m_rgAmmo 376
/*-----------------------------------------------------*/
#define WEAPON_KEY 776544229
#define WEAPON_OLD "weapon_ak47"
#define WEAPON_NEW "weapon_stunrifle"
/*-----------------------------------------------------*/
new const WPN_SPRITES[][] =
{
"sprites/weapon_stunrifle.txt",
"sprites/640hud169.spr",
"sprites/640hud7.spr"
}
new const g_szSounds[][] =
{
"weapons/stunrifle-1.wav",
"weapons/stunrifle_drawa.wav",
"weapons/stunrifle_drawb.wav",
"weapons/stunrifle_drawc.wav",
"weapons/stunrifle_reloada.wav",
"weapons/stunrifle_reloadb.wav",
"weapons/stunrifle_reloadc.wav",
"weapons/stunrifle_idlea.wav",
"weapons/stunrifle_idleb.wav",
"weapons/stunrifle_idlec.wav",
"weapons/stunrifle_lowbattery.wav",
"weapons/stunrifle-2.wav"
}
new const iWeaponList[] =
{
2, 30, -1, -1, 0, 1, CSW_AK47, 0
}
#define WEAPON_MODEL_V "models/stunrifle/v_stunrifle.mdl"
#define WEAPON_MODEL_P "models/stunrifle/p_stunrifle.mdl"
#define WEAPON_MODEL_W "models/stunrifle/w_stunrifle.mdl"
#define WEAPON_BODY 0
/*-----------------------------------------------------*/
#define WEAPON_COST 0
#define WEAPON_CLIP 30
#define WEAPON_AMMO 90
#define WEAPON_RATE 0.098
#define WEAPON_RECOIL 0.96
#define WEAPON_DAMAGE 1.0 // AK47 damage multiplied by this factor
#define WEAPON_RATE_EX 0.169
#define WEAPON_RECOIL_EX 0.79
#define WEAPON_DAMAGE_EX 1.3
#define WEAPON_NATIVE "native_give_weapon_stunrifle"
/*-----------------------------------------------------*/
// Animations
#define ANIM_IDLE_A 0
#define ANIM_IDLE_B 1
#define ANIM_IDLE_C 2
#define ANIM_ATTACK_A 3
#define ANIM_ATTACK_B 4
#define ANIM_ATTACK_C 5
#define ANIM_RELOAD_A 6
#define ANIM_RELOAD_B 7
#define ANIM_RELOAD_C 8
#define ANIM_DRAW_A 9
#define ANIM_DRAW_B 10
#define ANIM_DRAW_C 11
// from model: Frames / FPS
#define ANIM_IDLE_TIME_A 90/30.0
#define ANIM_SHOOT_TIME_A 31/30.0
#define ANIM_RELOAD_TIME_A 101/30.0
#define ANIM_DRAW_TIME_A 46/30.0
#define ANIM_IDLE_TIME_B 90/30.0
#define ANIM_SHOOT_TIME_B 31/30.0
#define ANIM_RELOAD_TIME_B 101/30.0
#define ANIM_DRAW_TIME_B 46/30.0
#define ANIM_IDLE_TIME_C 90/30.0
#define ANIM_SHOOT_TIME_C 31/30.0
#define ANIM_RELOAD_TIME_C 101/30.0
#define ANIM_DRAW_TIME_C 46/30.0
new g_AllocString_V,
g_AllocString_P,
g_AllocString_E,
HamHook: g_fw_TraceAttack[4],
g_iMsgID_Weaponlist,
g_iStoredEnergy[33],
bool:g_bHasStunRifle[33],
g_pCvarBarFillTime,
g_pCvarRadius,
g_pCvarElecDmg,
g_iLigSpr,
g_iEffSpr,
g_iEff2Spr,
bool:g_bReloading[33],
g_iAppearTimes[33],
g_iItemID
public plugin_init()
{
register_plugin("[ZE] Stun Rifle", "1.1", "Raheem");
// Register our item
g_iItemID = ze_register_item("Stun Rifle", 300, 0) // It's cost 300 Coins
RegisterHam(Ham_Item_Deploy, WEAPON_OLD, "fw_Item_Deploy_Post", 1);
RegisterHam(Ham_Item_PostFrame, WEAPON_OLD, "fw_Item_PostFrame");
RegisterHam(Ham_Item_AddToPlayer, WEAPON_OLD, "fw_Item_AddToPlayer_Post", 1);
RegisterHam(Ham_Weapon_Reload, WEAPON_OLD, "fw_Weapon_Reload");
RegisterHam(Ham_Weapon_WeaponIdle, WEAPON_OLD, "fw_Weapon_WeaponIdle");
RegisterHam(Ham_Weapon_PrimaryAttack, WEAPON_OLD, "fw_Weapon_PrimaryAttack");
g_fw_TraceAttack[0] = RegisterHam(Ham_TraceAttack, "func_breakable", "fw_TraceAttack");
g_fw_TraceAttack[1] = RegisterHam(Ham_TraceAttack, "info_target", "fw_TraceAttack");
g_fw_TraceAttack[2] = RegisterHam(Ham_TraceAttack, "player", "fw_TraceAttack");
g_fw_TraceAttack[3] = RegisterHam(Ham_TraceAttack, "hostage_entity", "fw_TraceAttack");
fm_ham_hook(false);
register_forward(FM_UpdateClientData, "fw_UpdateClientData_Post", 1);
register_forward(FM_PlaybackEvent, "fw_PlaybackEvent");
register_forward(FM_SetModel, "fw_SetModel");
g_pCvarBarFillTime = register_cvar("stunrifle_barfill_time", "5") // Bar fill time in seconds
g_pCvarRadius = register_cvar("stunrifle_radius", "500") // elec radius
g_pCvarElecDmg = register_cvar("stunrifle_electricity_dmg", "10") // electricity damage - lowest damage for 1 bar only
register_clcmd(WEAPON_NEW, "HookSelect");
g_iMsgID_Weaponlist = get_user_msgid("WeaponList");
}
public plugin_precache()
{
g_AllocString_V = engfunc(EngFunc_AllocString, WEAPON_MODEL_V);
g_AllocString_P = engfunc(EngFunc_AllocString, WEAPON_MODEL_P);
g_AllocString_E = engfunc(EngFunc_AllocString, WEAPON_OLD);
engfunc(EngFunc_PrecacheModel, WEAPON_MODEL_V);
engfunc(EngFunc_PrecacheModel, WEAPON_MODEL_P);
engfunc(EngFunc_PrecacheModel, WEAPON_MODEL_W);
for (new i = 0; i < sizeof g_szSounds; i++) engfunc(EngFunc_PrecacheSound, g_szSounds[i]);
for(new i = 0; i < sizeof WPN_SPRITES;i++) precache_generic(WPN_SPRITES[i]);
g_iLigSpr = precache_model("sprites/lightning.spr");
g_iEffSpr = precache_model("sprites/ef_buffak_hit.spr");
g_iEff2Spr = precache_model("sprites/muzzleflash67.spr");
}
public HookSelect(iPlayer)
{
engclient_cmd(iPlayer, WEAPON_OLD);
}
public give(id)
{
give_weapon_stunrifle(id)
}
public give_weapon_stunrifle(iPlayer)
{
static iEnt; iEnt = engfunc(EngFunc_CreateNamedEntity, g_AllocString_E);
if(iEnt <= 0) return 0;
set_pev(iEnt, pev_spawnflags, SF_NORESPAWN);
set_pev(iEnt, pev_impulse, WEAPON_KEY);
ExecuteHam(Ham_Spawn, iEnt);
UTIL_DropWeapon(iPlayer, 1);
if(!ExecuteHamB(Ham_AddPlayerItem, iPlayer, iEnt)) {
engfunc(EngFunc_RemoveEntity, iEnt);
return 0;
}
ExecuteHamB(Ham_Item_AttachToPlayer, iEnt, iPlayer);
set_pdata_int(iEnt, m_iClip, WEAPON_CLIP, 4);
new iAmmoType = m_rgAmmo +get_pdata_int(iEnt, m_iPrimaryAmmoType, 4);
if(get_pdata_int(iPlayer, m_rgAmmo, 5) < WEAPON_AMMO)
set_pdata_int(iPlayer, iAmmoType, WEAPON_AMMO, 5);
emit_sound(iPlayer, CHAN_ITEM, "items/gunpickup2.wav", VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
g_iStoredEnergy[iPlayer] = 0;
g_bHasStunRifle[iPlayer] = true;
set_task(get_pcvar_float(g_pCvarBarFillTime), "RechargeTask", iPlayer, _, _, "a", 6)
return 1;
}
public plugin_natives()
{
register_native(WEAPON_NATIVE, "give_weapon_stunrifle", 1);
}
public ze_select_item_pre(id, itemid)
{
// Return Available and we will block it in Post, So it dosen't affect other plugins
if (itemid != g_iItemID)
return ZE_ITEM_AVAILABLE
// Available for Humans only, So don't show it for zombies
if (ze_is_user_zombie(id))
return ZE_ITEM_DONT_SHOW
return ZE_ITEM_AVAILABLE
}
public ze_select_item_post(player, itemid)
{
if (itemid != g_iItemID)
return
give_weapon_stunrifle(player)
}
public fw_Item_Deploy_Post(iItem)
{
if(!CustomItem(iItem)) return;
static iPlayer; iPlayer = get_pdata_cbase(iItem, m_pPlayer, 4);
set_pev_string(iPlayer, pev_viewmodel2, g_AllocString_V);
set_pev_string(iPlayer, pev_weaponmodel2, g_AllocString_P);
if (g_iStoredEnergy[iPlayer] == 0)
{
// Draw A
UTIL_SendWeaponAnim(iPlayer, ANIM_DRAW_A);
emit_sound(iPlayer, CHAN_WEAPON, g_szSounds[1], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
set_pdata_float(iPlayer, m_flNextAttack, ANIM_DRAW_TIME_A, 5);
set_pdata_float(iItem, m_flTimeWeaponIdle, ANIM_DRAW_TIME_A, 4);
}
else if (g_iStoredEnergy[iPlayer] > 0 && g_iStoredEnergy[iPlayer] <= 3)
{
// Draw B
UTIL_SendWeaponAnim(iPlayer, ANIM_DRAW_B);
emit_sound(iPlayer, CHAN_WEAPON, g_szSounds[2], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
set_pdata_float(iPlayer, m_flNextAttack, ANIM_DRAW_TIME_B, 5);
set_pdata_float(iItem, m_flTimeWeaponIdle, ANIM_DRAW_TIME_B, 4);
}
else if (g_iStoredEnergy[iPlayer] > 3 && g_iStoredEnergy[iPlayer] <= 6)
{
// Draw C
UTIL_SendWeaponAnim(iPlayer, ANIM_DRAW_C);
emit_sound(iPlayer, CHAN_WEAPON, g_szSounds[3], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
set_pdata_float(iPlayer, m_flNextAttack, ANIM_DRAW_TIME_C, 5);
set_pdata_float(iItem, m_flTimeWeaponIdle, ANIM_DRAW_TIME_C, 4);
}
}
public fw_Item_PostFrame(iItem)
{
if(!CustomItem(iItem)) return HAM_IGNORED;
static iPlayer; iPlayer = get_pdata_cbase(iItem, m_pPlayer, 4);
if(get_pdata_int(iItem, m_fInReload, 4) == 1) {
static iClip; iClip = get_pdata_int(iItem, m_iClip, 4);
static iAmmoType; iAmmoType = m_rgAmmo + get_pdata_int(iItem, m_iPrimaryAmmoType, 4);
static iAmmo; iAmmo = get_pdata_int(iPlayer, iAmmoType, 5);
static j; j = min(WEAPON_CLIP - iClip, iAmmo);
set_pdata_int(iItem, m_iClip, iClip+j, 4);
set_pdata_int(iPlayer, iAmmoType, iAmmo-j, 5);
set_pdata_int(iItem, m_fInReload, 0, 4);
}
else switch(get_pdata_int(iItem, m_iWeaponState, 4) ) {
case 0: {
if(get_pdata_float(iItem, m_flNextSecondaryAttack, 4) <= 0.0)
if(pev(iPlayer, pev_button) & IN_ATTACK2) {
set_pdata_int(iPlayer, m_iFOV, get_pdata_int(iPlayer, m_iFOV, 5) == 90 ? 60 : 90);
set_pdata_float(iItem, m_flNextSecondaryAttack, 0.3, 4);
}
}
}
return HAM_IGNORED;
}
public fw_Item_AddToPlayer_Post(iItem, iPlayer)
{
switch(pev(iItem, pev_impulse)) {
case WEAPON_KEY: {
s_weaponlist(iPlayer, true);
g_bHasStunRifle[iPlayer] = true;
if (g_iStoredEnergy[iPlayer] < 6)
{
set_task(101/30.0, "OnReloadFinished", iPlayer);
}
else if (g_iStoredEnergy[iPlayer] == 6)
{
client_print(iPlayer, print_center, "Your Stun Rifle is fully charged!")
}
}
case 0: s_weaponlist(iPlayer, false);
}
}
public ze_user_infected(infected)
{
if (g_bHasStunRifle[infected])
{
g_bHasStunRifle[infected] = false
g_iStoredEnergy[infected] = 0;
}
}
public ze_user_humanized(id)
{
g_bHasStunRifle[id] = false
g_iStoredEnergy[id] = 0;
}
public fw_Weapon_Reload(iItem)
{
if(!CustomItem(iItem)) return HAM_IGNORED;
static iClip; iClip = get_pdata_int(iItem, m_iClip, 4);
if(iClip >= WEAPON_CLIP) return HAM_SUPERCEDE;
static iPlayer; iPlayer = get_pdata_cbase(iItem, m_pPlayer, 4);
static iAmmoType; iAmmoType = m_rgAmmo + get_pdata_int(iItem, m_iPrimaryAmmoType, 4);
if(get_pdata_int(iPlayer, iAmmoType, 5) <= 0) return HAM_SUPERCEDE
if(get_pdata_int(iPlayer, m_iFOV, 5) != 90) set_pdata_int(iPlayer, m_iFOV, 90, 5);
set_pdata_int(iItem, m_iClip, 0, 4);
ExecuteHam(Ham_Weapon_Reload, iItem);
set_pdata_int(iItem, m_iClip, iClip, 4);
set_pdata_int(iItem, m_fInReload, 1, 4);
g_bReloading[iPlayer] = true;
set_task(3.0, "AttackTask", iPlayer+444)
if (g_iStoredEnergy[iPlayer] == 0)
{
// Reload A
set_pdata_float(iItem, m_flNextPrimaryAttack, ANIM_RELOAD_TIME_A, 4);
set_pdata_float(iItem, m_flNextSecondaryAttack, ANIM_RELOAD_TIME_A, 4);
set_pdata_float(iItem, m_flTimeWeaponIdle, ANIM_RELOAD_TIME_A, 4);
set_pdata_float(iPlayer, m_flNextAttack, ANIM_RELOAD_TIME_A, 5);
UTIL_SendWeaponAnim(iPlayer, ANIM_RELOAD_A);
emit_sound(iPlayer, CHAN_WEAPON, g_szSounds[4], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
emit_sound(iPlayer, CHAN_WEAPON, g_szSounds[10], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
}
else if (g_iStoredEnergy[iPlayer] > 0 && g_iStoredEnergy[iPlayer] <= 3)
{
// Reload B
set_pdata_float(iItem, m_flNextPrimaryAttack, ANIM_RELOAD_TIME_B, 4);
set_pdata_float(iItem, m_flNextSecondaryAttack, ANIM_RELOAD_TIME_B, 4);
set_pdata_float(iItem, m_flTimeWeaponIdle, ANIM_RELOAD_TIME_B, 4);
set_pdata_float(iPlayer, m_flNextAttack, ANIM_RELOAD_TIME_B, 5);
UTIL_SendWeaponAnim(iPlayer, ANIM_RELOAD_B);
emit_sound(iPlayer, CHAN_WEAPON, g_szSounds[5], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
if (notEmpty(iPlayer))
{
emit_sound(iPlayer, CHAN_WEAPON, g_szSounds[11], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
}
}
else if (g_iStoredEnergy[iPlayer] > 3 && g_iStoredEnergy[iPlayer] <= 6)
{
// Reload C
set_pdata_float(iItem, m_flNextPrimaryAttack, ANIM_RELOAD_TIME_C, 4);
set_pdata_float(iItem, m_flNextSecondaryAttack, ANIM_RELOAD_TIME_C, 4);
set_pdata_float(iItem, m_flTimeWeaponIdle, ANIM_RELOAD_TIME_C, 4);
set_pdata_float(iPlayer, m_flNextAttack, ANIM_RELOAD_TIME_C, 5);
UTIL_SendWeaponAnim(iPlayer, ANIM_RELOAD_C);
emit_sound(iPlayer, CHAN_WEAPON, g_szSounds[6], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
if (notEmpty(iPlayer))
{
emit_sound(iPlayer, CHAN_WEAPON, g_szSounds[11], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
}
}
// Set task to recharge the battary
remove_task(iPlayer)
set_task(101/30.0, "OnReloadFinished", iPlayer)
return HAM_SUPERCEDE;
}
public AttackTask(taskid)
{
g_bReloading[taskid - 444] = false;
// After reload reset the stored energy
g_iStoredEnergy[taskid - 444] = 0;
g_iAppearTimes[taskid - 444] = 0;
}
public client_PreThink(id)
{
if (g_bReloading[id] && g_bHasStunRifle[id] && (get_user_weapon(id) == CSW_AK47))
{
if (g_iStoredEnergy[id] == 0)
{
// Reload A
}
else if (g_iStoredEnergy[id] > 0 && g_iStoredEnergy[id] <= 3)
{
// Reload B
static Float:flOrigin[3]
pev(id, pev_origin, flOrigin)
new iVictim = -1;
while ((iVictim = engfunc(EngFunc_FindEntityInSphere, iVictim, flOrigin, get_pcvar_float(g_pCvarRadius))) != 0)
{
if (!is_user_alive(iVictim) || !ze_is_user_zombie(iVictim))
continue
static Float:flVecOrigin[3];
pev(iVictim, pev_origin, flVecOrigin);
ElectricBeam(id, flVecOrigin);
ExecuteHam(Ham_TakeDamage, iVictim, id, id, get_pcvar_float(g_pCvarElecDmg) * g_iStoredEnergy[id], DMG_SLASH);
fm_set_user_rendering(iVictim, kRenderFxGlowShell, 51, 51, 225, kRenderNormal, 10);
set_task(101/30.0, "Delete_Glow", iVictim+4444);
}
}
else if (g_iStoredEnergy[id] > 3 && g_iStoredEnergy[id] <= 6)
{
// Reload C
static Float:flOrigin[3]
pev(id, pev_origin, flOrigin)
new iVictim = -1;
while ((iVictim = engfunc(EngFunc_FindEntityInSphere, iVictim, flOrigin, get_pcvar_float(g_pCvarRadius))) != 0)
{
if (!is_user_alive(iVictim) || !ze_is_user_zombie(iVictim))
continue
static Float:flVecOrigin[3]
pev(iVictim, pev_origin, flVecOrigin)
ElectricBeam(id, flVecOrigin)
ExecuteHam(Ham_TakeDamage, iVictim, id, id, get_pcvar_float(g_pCvarElecDmg) * g_iStoredEnergy[id], DMG_SLASH);
fm_set_user_rendering(iVictim, kRenderFxGlowShell, 51, 51, 225, kRenderNormal, 10);
set_task(101/30.0, "Delete_Glow", iVictim+4444);
}
}
}
}
public Delete_Glow(taskid)
{
new id = taskid - 4444;
fm_set_user_rendering(id);
}
public OnReloadFinished(id)
{
remove_task(id)
set_task(get_pcvar_float(g_pCvarBarFillTime), "RechargeTask", id, _, _, "a", 6)
}
public RechargeTask(id)
{
if (!g_bHasStunRifle[id])
return
// Increase one bar every x time
g_iStoredEnergy[id]++
new szBars[100];
switch(g_iStoredEnergy[id])
{
case 1:
{
szBars = "[ | ]";
}
case 2:
{
szBars = "[ | | ]";
}
case 3:
{
szBars = "[ | | | ]";
}
case 4:
{
szBars = "[ | | | | ]";
}
case 5:
{
szBars = "[ | | | | | ]";
}
case 6:
{
szBars = "[ | | | | | | ]";
}
}
set_dhudmessage(51, 153, 255, -1.0, -0.16, 0, 0.0, get_pcvar_float(g_pCvarBarFillTime) - 0.2)
show_dhudmessage(id, "Stun Rifle Battary: %s", szBars)
if (g_iStoredEnergy[id] == 6)
{
client_print(id, print_center, "Your Stun Rifle is fully charged!")
remove_task(id)
}
}
public fw_Weapon_WeaponIdle(iItem)
{
if(!CustomItem(iItem) || get_pdata_float(iItem, m_flTimeWeaponIdle, 4) > 0.0) return HAM_IGNORED;
static iPlayer; iPlayer = get_pdata_cbase(iItem, m_pPlayer, 4);
if (g_iStoredEnergy[iPlayer] == 0)
{
// Idle A
UTIL_SendWeaponAnim(iPlayer, ANIM_IDLE_A);
set_pdata_float(iItem, m_flTimeWeaponIdle, ANIM_IDLE_TIME_A, 4);
emit_sound(iPlayer, CHAN_WEAPON, g_szSounds[7], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
}
else if (g_iStoredEnergy[iPlayer] > 0 && g_iStoredEnergy[iPlayer] <= 3)
{
// Idle B
UTIL_SendWeaponAnim(iPlayer, ANIM_IDLE_B);
set_pdata_float(iItem, m_flTimeWeaponIdle, ANIM_IDLE_TIME_B, 4);
emit_sound(iPlayer, CHAN_WEAPON, g_szSounds[8], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
}
else if (g_iStoredEnergy[iPlayer] > 3 && g_iStoredEnergy[iPlayer] <= 6)
{
// Idle C
UTIL_SendWeaponAnim(iPlayer, ANIM_IDLE_C);
set_pdata_float(iItem, m_flTimeWeaponIdle, ANIM_IDLE_TIME_C, 4);
emit_sound(iPlayer, CHAN_WEAPON, g_szSounds[9], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
}
return HAM_SUPERCEDE;
}
public fw_Weapon_PrimaryAttack(iItem)
{
if(!CustomItem(iItem)) return HAM_IGNORED;
static iPlayer; iPlayer = get_pdata_cbase(iItem, m_pPlayer, 4);
static iFOV; iFOV = (get_pdata_int(iPlayer, m_iFOV, 5) != 90);
if(get_pdata_int(iItem, m_iClip, 4) == 0) {
ExecuteHam(Ham_Weapon_PlayEmptySound, iItem);
set_pdata_float(iItem, m_flNextPrimaryAttack, 0.2, 4);
return HAM_SUPERCEDE;
}
static fw_TraceLine; fw_TraceLine = register_forward(FM_TraceLine, "fw_TraceLine_Post", 1);
fm_ham_hook(true);
state FireBullets: Enabled;
ExecuteHam(Ham_Weapon_PrimaryAttack, iItem);
state FireBullets: Disabled;
unregister_forward(FM_TraceLine, fw_TraceLine, 1);
fm_ham_hook(false);
static Float:vecPunchangle[3];
pev(iPlayer, pev_punchangle, vecPunchangle);
vecPunchangle[0] *= iFOV ? WEAPON_RECOIL_EX : WEAPON_RECOIL;
vecPunchangle[1] *= iFOV ? WEAPON_RECOIL_EX : WEAPON_RECOIL;
vecPunchangle[2] *= iFOV ? WEAPON_RECOIL_EX : WEAPON_RECOIL;
set_pev(iPlayer, pev_punchangle, vecPunchangle);
emit_sound(iPlayer, CHAN_WEAPON, g_szSounds[0], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
if (g_iStoredEnergy[iPlayer] == 0)
{
// Idle A
UTIL_SendWeaponAnim(iPlayer, ANIM_ATTACK_A);
set_pdata_float(iItem, m_flTimeWeaponIdle, ANIM_SHOOT_TIME_A, 4);
}
else if (g_iStoredEnergy[iPlayer] > 0 && g_iStoredEnergy[iPlayer] <= 3)
{
// Idle B
UTIL_SendWeaponAnim(iPlayer, ANIM_ATTACK_B);
set_pdata_float(iItem, m_flTimeWeaponIdle, ANIM_SHOOT_TIME_B, 4);
}
else if (g_iStoredEnergy[iPlayer] > 3 && g_iStoredEnergy[iPlayer] <= 6)
{
// Idle C
UTIL_SendWeaponAnim(iPlayer, ANIM_ATTACK_C);
set_pdata_float(iItem, m_flTimeWeaponIdle, ANIM_SHOOT_TIME_C, 4);
}
Make_Muzzleflash(iPlayer)
set_pdata_float(iItem, m_flNextPrimaryAttack, iFOV ? WEAPON_RATE_EX : WEAPON_RATE, 4);
return HAM_SUPERCEDE;
}
public fw_PlaybackEvent() <FireBullets: Enabled> { return FMRES_SUPERCEDE; }
public fw_PlaybackEvent() <FireBullets: Disabled> { return FMRES_IGNORED; }
public fw_PlaybackEvent() <> { return FMRES_IGNORED; }
public fw_TraceAttack(iVictim, iAttacker, Float:flDamage) {
if(!is_user_connected(iAttacker)) return;
static iItem; iItem = get_pdata_cbase(iAttacker, m_pActiveItem, 5);
static iFOV; iFOV = (get_pdata_int(iAttacker, m_iFOV, 5) != 90);
static Float: flWeaponDamage; flWeaponDamage = (iFOV ? WEAPON_DAMAGE_EX : WEAPON_DAMAGE);
if(iItem <= 0 || !CustomItem(iItem)) return;
SetHamParamFloat(3, flDamage * flWeaponDamage);
}
public fw_UpdateClientData_Post(iPlayer, SendWeapons, CD_Handle)
{
if(get_cd(CD_Handle, CD_DeadFlag) != DEAD_NO) return;
static iItem; iItem = get_pdata_cbase(iPlayer, m_pActiveItem, 5);
if(iItem <= 0 || !CustomItem(iItem)) return;
set_cd(CD_Handle, CD_flNextAttack, 999999.0);
}
public fw_SetModel(iEnt)
{
static i, szClassname[32], iItem;
pev(iEnt, pev_classname, szClassname, 31);
if(!equal(szClassname, "weaponbox")) return FMRES_IGNORED;
for(i = 0; i < 6; i++) {
iItem = get_pdata_cbase(iEnt, m_rgpPlayerItems_CWeaponBox + i, 4);
if(iItem > 0 && CustomItem(iItem)) {
engfunc(EngFunc_SetModel, iEnt, WEAPON_MODEL_W);
set_pev(iEnt, pev_body, WEAPON_BODY);
new iPlayer = pev(iEnt, pev_owner);
g_bHasStunRifle[iPlayer] = false;
remove_task(iPlayer)
return FMRES_SUPERCEDE;
}
}
return FMRES_IGNORED;
}
public fw_TraceLine_Post(const Float:flOrigin1[3], const Float:flOrigin2[3], iFrag, iIgnore, tr)
{
if(iFrag & IGNORE_MONSTERS) return FMRES_IGNORED;
static pHit; pHit = get_tr2(tr, TR_pHit);
static Float:flvecEndPos[3]; get_tr2(tr, TR_vecEndPos, flvecEndPos);
if(pHit > 0) {
if(pev(pHit, pev_solid) != SOLID_BSP) return FMRES_IGNORED;
}
engfunc(EngFunc_MessageBegin, MSG_PAS, SVC_TEMPENTITY, flvecEndPos, 0);
write_byte(TE_GUNSHOTDECAL);
engfunc(EngFunc_WriteCoord, flvecEndPos[0]);
engfunc(EngFunc_WriteCoord, flvecEndPos[1]);
engfunc(EngFunc_WriteCoord, flvecEndPos[2]);
write_short(pHit > 0 ? pHit : 0);
write_byte(random_num(41, 45));
message_end();
return FMRES_IGNORED;
}
public fm_ham_hook(bool:on) {
if(on) {
EnableHamForward(g_fw_TraceAttack[0]);
EnableHamForward(g_fw_TraceAttack[1]);
EnableHamForward(g_fw_TraceAttack[2]);
EnableHamForward(g_fw_TraceAttack[3]);
}
else {
DisableHamForward(g_fw_TraceAttack[0]);
DisableHamForward(g_fw_TraceAttack[1]);
DisableHamForward(g_fw_TraceAttack[2]);
DisableHamForward(g_fw_TraceAttack[3]);
}
}
stock UTIL_SendWeaponAnim(iPlayer, iAnim)
{
set_pev(iPlayer, pev_weaponanim, iAnim);
message_begin(MSG_ONE, SVC_WEAPONANIM, _, iPlayer);
write_byte(iAnim);
write_byte(0);
message_end();
}
stock UTIL_DropWeapon(iPlayer, iSlot) {
static iEntity, iNext, szWeaponName[32];
iEntity = get_pdata_cbase(iPlayer, m_rpgPlayerItems + iSlot, 5);
if(iEntity > 0) {
do {
iNext = get_pdata_cbase(iEntity, m_pNext, 4)
if(get_weaponname(get_pdata_int(iEntity, m_iId, 4), szWeaponName, 31)) {
engclient_cmd(iPlayer, "drop", szWeaponName);
}
} while(( iEntity = iNext) > 0);
}
}
stock s_weaponlist(iPlayer, bool:on)
{
message_begin(MSG_ONE, g_iMsgID_Weaponlist, {0,0,0}, iPlayer);
write_string(on ? WEAPON_NEW : WEAPON_OLD);
write_byte(iWeaponList[0]);
write_byte(on ? WEAPON_AMMO : iWeaponList[1]);
write_byte(iWeaponList[2]);
write_byte(iWeaponList[3]);
write_byte(iWeaponList[4]);
write_byte(iWeaponList[5]);
write_byte(iWeaponList[6]);
write_byte(iWeaponList[7]);
message_end();
}
stock ElectricBeam(id, Float:flOrigin[3])
{
message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
write_byte(TE_BEAMENTPOINT)
write_short(id | 0x1000)
engfunc(EngFunc_WriteCoord, flOrigin[0])
engfunc(EngFunc_WriteCoord, flOrigin[1])
engfunc(EngFunc_WriteCoord, flOrigin[2])
write_short(g_iLigSpr)
write_byte(1); // framestart
write_byte(100); // framerate - 5
write_byte(1) // life - 30
write_byte(30); // width
write_byte(random_num(0, 10)); // noise
write_byte(51); // r, g, b
write_byte(51); // r, g, b
write_byte(255); // r, g, b
write_byte(200); // brightness
write_byte(200); // speed
message_end()
if (g_iAppearTimes[id] >= 2)
return
message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
write_byte(TE_EXPLOSION);
engfunc(EngFunc_WriteCoord, flOrigin[0]);
engfunc(EngFunc_WriteCoord, flOrigin[1]);
engfunc(EngFunc_WriteCoord, flOrigin[2]);
write_short(g_iEffSpr);
write_byte(10);
write_byte(10);
write_byte(TE_EXPLFLAG_NOSOUND|TE_EXPLFLAG_NOPARTICLES|TE_EXPLFLAG_NODLIGHTS);
message_end();
g_iAppearTimes[id]++
}
stock notEmpty(id)
{
static Float:flOrigin[3]
pev(id, pev_origin, flOrigin)
new iVictim = -1;
while ((iVictim = engfunc(EngFunc_FindEntityInSphere, iVictim, flOrigin, get_pcvar_float(g_pCvarRadius))) != 0)
{
if (!is_user_alive(iVictim) || !ze_is_user_zombie(iVictim))
continue
return true;
}
return false;
}
public Make_Muzzleflash(id)
{
static Float:Origin[3], TE_FLAG
get_position(id, 32.0, 6.0, -15.0, Origin)
TE_FLAG |= TE_EXPLFLAG_NODLIGHTS
TE_FLAG |= TE_EXPLFLAG_NOSOUND
TE_FLAG |= TE_EXPLFLAG_NOPARTICLES
engfunc(EngFunc_MessageBegin, MSG_ONE_UNRELIABLE, SVC_TEMPENTITY, Origin, id)
write_byte(TE_EXPLOSION)
engfunc(EngFunc_WriteCoord, Origin[0])
engfunc(EngFunc_WriteCoord, Origin[1])
engfunc(EngFunc_WriteCoord, Origin[2])
write_short(g_iEff2Spr)
write_byte(2)
write_byte(30)
write_byte(TE_FLAG)
message_end()
}
stock get_position(id,Float:forw, Float:right, Float:up, Float:vStart[])
{
static Float:vOrigin[3], Float:vAngle[3], Float:vForward[3], Float:vRight[3], Float:vUp[3]
pev(id, pev_origin, vOrigin)
pev(id, pev_view_ofs, vUp) //for player
xs_vec_add(vOrigin, vUp, vOrigin)
pev(id, pev_v_angle, vAngle) // if normal entity ,use pev_angles
angle_vector(vAngle,ANGLEVECTOR_FORWARD, vForward) //or use EngFunc_AngleVectors
angle_vector(vAngle,ANGLEVECTOR_RIGHT, vRight)
angle_vector(vAngle,ANGLEVECTOR_UP, vUp)
vStart[0] = vOrigin[0] + vForward[0] * forw + vRight[0] * right + vUp[0] * up
vStart[1] = vOrigin[1] + vForward[1] * forw + vRight[1] * right + vUp[1] * up
vStart[2] = vOrigin[2] + vForward[2] * forw + vRight[2] * right + vUp[2] * up
}
Code: Select all
#include <zombie_escape>
static const plugin[] = "[ZE] Extra Item: Bazooka";
static const mrocket[] = "models/zombie_escape/zm_bazooka_missile.mdl";
static const mrpg_w[] = "models/zombie_escape/w_zm_bazooka.mdl";
static const mrpg_v[] = "models/zombie_escape/v_zm_bazooka.mdl";
static const mrpg_p[] = "models/zombie_escape/p_zm_bazooka.mdl";
static const sfire[] = "weapons/rocketfire1.wav";
static const sfly[] = "weapons/nuke_fly.wav";
static const shit[] = "weapons/mortarhit.wav";
static const spickup[] = "items/gunpickup2.wav";
new g_itemid;
new gmsg_screenshake, gmsg_death, gmsg_damage, pcvar_delay, pcvar_maxdmg, pcvar_radius, pcvar_map;
new rocketsmoke, explosion, bazsmoke, white;
new bool:has_baz[33], bool:CanShoot[33];
new dmgcount[33], pcvar_dmgforpacks, pcvar_award;
public plugin_init()
{
register_plugin(plugin, "0.6", "Random1");
pcvar_delay = register_cvar("zp_baz_delay", "10.0");
pcvar_maxdmg = register_cvar("zp_baz_dmg", "720");
pcvar_radius = register_cvar("zp_baz_radius", "750");
pcvar_map = register_cvar("zp_baz_map", "0");
pcvar_dmgforpacks = get_cvar_pointer("zp_human_damage_reward");
pcvar_award = register_cvar("zp_baz_awardpacks", "1");
if ( pcvar_dmgforpacks == 0 ) {
set_pcvar_num(pcvar_award, 0); //if we couldn't read the dmg cvar from zp then set a stop state on dmg reward
log_amx("[%s] error reading zp_human_damage_reward cvar from zombie plague, turning award for damage off", plugin);
}
g_itemid = ze_register_item("Bazooka", 65, 0);
register_concmd("zp_bazooka", "give_bazooka", ADMIN_KICK, "<name/@all> gives a bazooka to the spcified target");
register_event("CurWeapon","switch_to_knife","be","1=1","2=29");
register_event("HLTV", "event_HLTV", "a", "1=0", "2=0") // New Round
register_clcmd("drop", "drop_call");
//supports 2 methods of firing, attacking while holding knife and a bind
register_clcmd("baz_fire", "fire_call");
register_forward(FM_PlayerPreThink, "fw_prethink");
register_forward(FM_Touch, "fw_touch");
gmsg_screenshake = get_user_msgid("ScreenShake");
gmsg_death = get_user_msgid("DeathMsg");
gmsg_damage = get_user_msgid("Damage");
}
public event_HLTV()
{
//remove entities regardless of cvar
new rpg_temp = engfunc(EngFunc_FindEntityByString, -1, "classname", "rpg_temp");
while( rpg_temp > 0) {
engfunc(EngFunc_RemoveEntity, rpg_temp);
rpg_temp = engfunc(EngFunc_FindEntityByString, -1, "classname", "rpg_temp");
}
if ( get_pcvar_num(pcvar_map) ) return;
for( new id = 1; id <= 32; id++ )
has_baz[id] = false;
}
public ze_select_item_pre(id, itemid)
{
// This not our item?
if (itemid != g_itemid)
return ZE_ITEM_AVAILABLE
// Available for Humans only, So don't show it for zombies
if (ze_is_user_zombie(id))
return ZE_ITEM_DONT_SHOW
// Finally return that it's available
return ZE_ITEM_AVAILABLE
}
public ze_select_item_post(id, itemid)
{
// This is not our item, Block it here and don't execute the blew code
if (itemid != g_itemid)
return
has_baz[id] = true;
CanShoot[id] = true;
}
public give_bazooka(id,level,cid)
{
if (!cmd_access(id,level,cid,1)) {
console_print(id,"You have no access to that command");
return;
}
if (read_argc() > 2) {
console_print(id,"Too many arguments supplied.");
return;
}
new arg1[32];
read_argv(1, arg1, sizeof(arg1) - 1);
new player = cmd_target(id, arg1, 10);
if ( !player ) {
if ( arg1[0] == '@' ) {
for ( new i = 1; i <= 32; i++ ) {
if ( is_user_connected(i) && !has_baz[i] && !ze_is_user_zombie(i) ) {
has_baz[i] = true;
CanShoot[i] = true;
client_print(i, print_chat, "[ZP BAZ] You now have a bazooka, attack while holding knife(will take %2.1f seconds to reload", get_pcvar_float(pcvar_delay));
}
}
} else {
client_print(id, print_chat, "No Such Player/Team");
return;
}
} else if ( !has_baz[player] && !ze_is_user_zombie(player) ) {
has_baz[player] = true;
CanShoot[player] = true;
client_print(player, print_chat, "[ZP BAZ] You now have a bazooka, attack while holding knife(will take %2.1f seconds to reload", get_pcvar_float(pcvar_delay));
}
}
public ze_user_infected(id, infector)
if ( has_baz[id] )
drop_rpg_temp(id);
public plugin_precache()
{
precache_model(mrocket);
precache_model(mrpg_w);
precache_model(mrpg_v);
precache_model(mrpg_p);
precache_sound(sfire);
precache_sound(sfly);
precache_sound(shit);
precache_sound(spickup);
rocketsmoke = precache_model("sprites/smoke.spr");
explosion = precache_model("sprites/fexplo.spr");
bazsmoke = precache_model("sprites/steam1.spr");
white = precache_model("sprites/white.spr");
}
public switch_to_knife(id)
{
if ( !is_user_alive(id) ) return;
if ( has_baz[id] && CanShoot[id] )
{
set_pev(id, pev_viewmodel2, mrpg_v);
set_pev(id, pev_weaponmodel2, mrpg_p);
}
}
public fw_prethink(id)
{
static button;
button = pev(id, pev_button);
if ( button & IN_ATTACK )
fire_call(id);
}
public fire_call(id)
{
if ( !is_user_alive(id) || !has_baz[id] || !CanShoot[id] ) return;
new weapon = get_user_weapon(id);
if ( weapon == CSW_KNIFE ) fire_rocket(id);
}
fire_rocket(id) {
if ( !CanShoot[id] ) return;
CanShoot[id] = false;
set_task(get_pcvar_float(pcvar_delay), "rpg_reload", id);
engclient_cmd(id, "weapon_knife"); //attempt to force model to reset
new Float:StartOrigin[3], Float:Angle[3];
pev(id, pev_origin, StartOrigin);
pev(id, pev_angles, Angle);
new ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
set_pev(ent, pev_classname, "rpgrocket");
engfunc(EngFunc_SetModel, ent, mrocket);
set_pev(ent, pev_mins, {-1.0, -1.0, -1.0});
set_pev(ent, pev_maxs, {1.0, 1.0, 1.0});
engfunc(EngFunc_SetOrigin, ent, StartOrigin);
set_pev(ent, pev_angles, Angle);
set_pev(ent, pev_solid, 2);
set_pev(ent, pev_movetype, 5);
set_pev(ent, pev_owner, id);
new Float:nVelocity[3];
velocity_by_aim(id, 1500, nVelocity);
set_pev(ent, pev_velocity, nVelocity);
emit_sound(ent, CHAN_WEAPON, sfire, VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
emit_sound(ent, CHAN_VOICE, sfly, VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
write_byte(22);
write_short(ent);
write_short(rocketsmoke);
write_byte(30);
write_byte(3);
write_byte(255);
write_byte(255);
write_byte(255);
write_byte(255);
message_end();
}
//---------------------------------------------------------------------------------------
public rpg_reload(id)
{
CanShoot[id] = true;
if ( get_user_weapon(id) == CSW_KNIFE ) switch_to_knife(id); //sets our model
}
//---------------------------------------------------------------------------------------
public fw_touch(ent, touched)
{
if ( !pev_valid(ent) ) return FMRES_IGNORED;
static entclass[32];
pev(ent, pev_classname, entclass, 31);
if ( equali(entclass, "rpg_temp") )
{
static touchclass[32];
pev(touched, pev_classname, touchclass, 31);
if ( !equali(touchclass, "player") ) return FMRES_IGNORED;
if( !is_user_alive(touched) || ze_is_user_zombie(touched) ) return FMRES_IGNORED;
emit_sound(touched, CHAN_VOICE, spickup, 1.0, ATTN_NORM, 0, PITCH_NORM);
has_baz[touched] = true;
engfunc(EngFunc_RemoveEntity, ent);
return FMRES_HANDLED;
}
else if ( equali(entclass, "rpgrocket") )
{
new Float:EndOrigin[3];
pev(ent, pev_origin, EndOrigin);
new NonFloatEndOrigin[3];
NonFloatEndOrigin[0] = floatround(EndOrigin[0]);
NonFloatEndOrigin[1] = floatround(EndOrigin[1]);
NonFloatEndOrigin[2] = floatround(EndOrigin[2]);
emit_sound(ent, CHAN_WEAPON, shit, VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
emit_sound(ent, CHAN_VOICE, shit, VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
write_byte(17);
write_coord(NonFloatEndOrigin[0]);
write_coord(NonFloatEndOrigin[1]);
write_coord(NonFloatEndOrigin[2] + 128);
write_short(explosion);
write_byte(60);
write_byte(255);
message_end();
message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
write_byte(5);
write_coord(NonFloatEndOrigin[0]);
write_coord(NonFloatEndOrigin[1]);
write_coord(NonFloatEndOrigin[2] + 256);
write_short(bazsmoke);
write_byte(125);
write_byte(5);
message_end();
new maxdamage = get_pcvar_num(pcvar_maxdmg);
new damageradius = get_pcvar_num(pcvar_radius);
new PlayerPos[3], distance, damage;
for (new i = 1; i <= 32; i++) {
if ( is_user_alive(i))
{
new id = pev(ent, pev_owner)
if ((ze_is_user_zombie(id)))
continue;
get_user_origin(i, PlayerPos);
distance = get_distance(PlayerPos, NonFloatEndOrigin);
if (distance <= damageradius) {
message_begin(MSG_ONE, gmsg_screenshake, {0,0,0}, i);
write_short(1<<14);
write_short(1<<14);
write_short(1<<14);
message_end();
damage = maxdamage - floatround(floatmul(float(maxdamage), floatdiv(float(distance), float(damageradius))));
new attacker = pev(ent, pev_owner);
baz_damage(i, attacker, damage, "bazooka");
}
}
}
message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
write_byte(21);
write_coord(NonFloatEndOrigin[0]);
write_coord(NonFloatEndOrigin[1]);
write_coord(NonFloatEndOrigin[2]);
write_coord(NonFloatEndOrigin[0]);
write_coord(NonFloatEndOrigin[1]);
write_coord(NonFloatEndOrigin[2] + 320);
write_short(white);
write_byte(0);
write_byte(0);
write_byte(16);
write_byte(128);
write_byte(0);
write_byte(255);
write_byte(255);
write_byte(192);
write_byte(128);
write_byte(0);
message_end();
engfunc(EngFunc_RemoveEntity, ent);
return FMRES_HANDLED;
}
return FMRES_IGNORED;
}
//---------------------------------------------------------------------------------------
public drop_call(id)
{
if ( has_baz[id] && get_user_weapon(id) == CSW_KNIFE )
{
drop_rpg_temp(id);
return PLUGIN_HANDLED; //attempt to block can't drop knife message
}
return PLUGIN_CONTINUE;
}
drop_rpg_temp(id) {
new Float:fAim[3] , Float:fOrigin[3];
velocity_by_aim(id , 64 , fAim);
pev(id , pev_origin , fOrigin);
fOrigin[0] += fAim[0];
fOrigin[1] += fAim[1];
new rpg = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
set_pev(rpg, pev_classname, "rpg_temp");
engfunc(EngFunc_SetModel, rpg, mrpg_w);
set_pev(rpg, pev_mins, { -16.0, -16.0, -16.0 } );
set_pev(rpg, pev_maxs, { 16.0, 16.0, 16.0 } );
set_pev(rpg , pev_solid , 1);
set_pev(rpg , pev_movetype , 6);
engfunc(EngFunc_SetOrigin, rpg, fOrigin);
has_baz[id] = false;
}
//---------------------------------------------------------------------------------------
baz_damage(id, attacker, damage, weaponDescription[])
{
if ( pev(id, pev_takedamage) == DAMAGE_NO ) return;
if ( damage <= 0 ) return;
new userHealth = get_user_health(id);
if (userHealth - damage <= 0 ) {
dmgcount[attacker] += userHealth - damage;
set_msg_block(gmsg_death, BLOCK_SET);
ExecuteHamB(Ham_Killed, id, attacker, 2);
set_msg_block(gmsg_death, BLOCK_NOT);
message_begin(MSG_BROADCAST, gmsg_death);
write_byte(attacker);
write_byte(id);
write_byte(0);
write_string(weaponDescription);
message_end();
set_pev(attacker, pev_frags, float(get_user_frags(attacker) + 1));
new kname[32], vname[32], kauthid[32], vauthid[32], kteam[10], vteam[10];
get_user_name(attacker, kname, 31);
get_user_team(attacker, kteam, 9);
get_user_authid(attacker, kauthid, 31);
get_user_name(id, vname, 31);
get_user_team(id, vteam, 9);
get_user_authid(id, vauthid, 31);
log_message("^"%s<%d><%s><%s>^" killed ^"%s<%d><%s><%s>^" with ^"%s^"",
kname, get_user_userid(attacker), kauthid, kteam,
vname, get_user_userid(id), vauthid, vteam, weaponDescription);
}
else {
dmgcount[attacker] += damage;
new origin[3];
get_user_origin(id, origin);
message_begin(MSG_ONE,gmsg_damage,{0,0,0},id);
write_byte(21);
write_byte(20);
write_long(DMG_BLAST);
write_coord(origin[0]);
write_coord(origin[1]);
write_coord(origin[2]);
message_end();
set_pev(id, pev_health, pev(id, pev_health) - float(damage));
}
if ( !get_pcvar_num(pcvar_award) ) return;
new breaker = get_pcvar_num(pcvar_dmgforpacks);
if ( dmgcount[attacker] > breaker )
{
new temp = dmgcount[attacker] / breaker
if ( temp * breaker > dmgcount[attacker] ) return; //should never be possible
dmgcount[attacker] -= temp * breaker;
ze_set_escape_coins( attacker, ze_get_escape_coins(attacker) + temp );
}
}
Code: Select all
include <ze_vip>
#include <fakemeta_util>
#define PLUGIN "[ZE] CSO Laser Minigun"
#define VERSION "1.1"
#define AUTHOR "Asep Khairul Anam"
/**** Changelog 1.1 ****
-> Fixed Bug Laserminigun Charge Mode
-> Fixed Some Crash And Bug
-> Rewrite Code
-> Add To Mode Zombie Escape (Add Extra Items)
*************************/
#define weapon_name "weapon_m249"
#define weapon_new "weapon_laserminigun"
#define VIP_ACCESS ADMIN_LEVEL_H
#define ANIM_IDLE 0
#define ANIM_SHOOT_1 7
#define ANIM_SHOOT_2 8
#define ANIM_RELOAD 5
#define ANIM_DRAW 6
#define IDLE_TIME 1.7
#define DRAW_TIME 2.53
#define RELOAD_TIME 5.23
#define WEAPON_KEY 38591238491
#define Is_CustomItem(%0) (pev(%0,pev_impulse) == WEAPON_KEY)
#define MODEL_V "models/zombie_escape/v_laserminigun.mdl"
#define MODEL_W "models/zombie_escape/w_laserminigun.mdl"
#define MODEL_P "models/zombie_escape/p_laserminiguna.mdl"
#define MODEL_P_CHARGE "models/zombie_escape/p_laserminigunb.mdl"
/******* CONFIGURATION LASERMINIGUN ********/
#define RECOIL 0.4
#define DAMAGE_LOW 0.8
#define DAMAGE_HIGH 1.5
#define DAMAGE_EXTREME 2.0
#define WEAPON_SPEED 0.07
#define DAMAGE_BALL_1 330.0
#define DAMAGE_BALL_2 550.0
#define DAMAGE_BALL_3 770.0
#define EXPLODE_RADIUS 250.0
#define WEAPON_CLIP 125
#define WEAPON_BPAMMO 250
#define SHOOTS_FOR_HIGH 20
#define SHOOTS_FOR_EXTRREME SHOOTS_FOR_HIGH + 20
/**** END OF CONFIGURATION LASERMINIGUN ****/
#define classname_ball "laserminigun_ball"
#define Get_BitVar(%1,%2) (%1&(1<<(%2&31)))
#define Set_BitVar(%1,%2) %1|=(1<<(%2&31))
#define UnSet_BitVar(%1,%2) %1&=~(1<<(%2&31))
#define MUZZLEFLASH_1 "sprites/muzzleflash37.spr"
#define MUZZLEFLASH_2 "sprites/muzzleflash38.spr"
#define MUZZLEFLASH_3 "sprites/muzzleflash39.spr"
#define SPRITE_BALL_1 "sprites/laserminigun_charge_1.spr"
#define SPRITE_BALL_2 "sprites/laserminigun_charge_2.spr"
#define SPRITE_BALL_3 "sprites/laserminigun_charge_3.spr"
new gMaxPlayers, Msg_WeaponList, g_AllocString_V, g_iItemID
new g_ChargeState[512],g_ChargeShots[512], g_AllocString_P, g_AllocString_P_charge
new Float:g_VecEndTrace[3], g_ChargeBall[33], g_ChargeForEntity[33]
new g_ChargeBall1_Explosion, g_ChargeBall2_Explosion, g_ChargeBall3_Explosion
new g_Muzzleflash_Ent1,g_Muzzleflash1
new g_Muzzleflash_Ent2,g_Muzzleflash2
new g_Muzzleflash_Ent3,g_Muzzleflash3
new g_MuzzleflashBall_Ent1,g_MuzzleflashBall1
new g_MuzzleflashBall_Ent2,g_MuzzleflashBall2
new g_MuzzleflashBall_Ent3,g_MuzzleflashBall3
new const Weapon_Sounds[15][] =
{
"weapons/laserminigun-1.wav", // 0
"weapons/laserminigun-charge_start.wav", // 1
"weapons/laserminigun-charge_loop.wav", // 2
"weapons/laserminigun-charge_origin.wav", // 3
"weapons/laserminigun-charge_shoot.wav", // 4
"weapons/laserminigun_idle.wav", // 5
"weapons/laserminigun_draw.wav", // 6
"weapons/laserminigun_clipout2.wav", // 7
"weapons/laserminigun_clipout1.wav", // 8
"weapons/laserminigun_clipin2.wav", // 9
"weapons/laserminigun_clipin1.wav", // 10
"weapons/laserminigun_charge_end.wav", // 11
"weapons/laserminigun_exp1.wav", // 12
"weapons/laserminigun_exp2.wav", // 13
"weapons/laserminigun_exp3.wav" // 14
}
enum
{
STATE_LOW = 0,
STATE_HIGH,
STATE_EXTREME,
STATE_CHARGE
}
public plugin_init()
{
register_plugin(PLUGIN, VERSION, AUTHOR)
RegisterHam(Ham_Item_Deploy,weapon_name,"HookHam_Weapon_Deploy",1)
RegisterHam(Ham_Item_AddToPlayer,weapon_name,"HookHam_Weapon_Add",1)
RegisterHam(Ham_Item_PostFrame,weapon_name,"HookHam_Weapon_Frame",0)
g_iItemID = ze_register_item("Laser MiniGun \r(V.I.P)", 70, 0)
RegisterHam(Ham_Weapon_Reload,weapon_name,"HookHam_Weapon_Reload",0)
RegisterHam(Ham_Weapon_WeaponIdle,weapon_name,"HookHam_Weapon_Idle",0)
RegisterHam(Ham_Weapon_PrimaryAttack,weapon_name,"HookHam_Weapon_PrimaryAttack",0)
RegisterHam(Ham_TakeDamage,"player","HookHam_TakeDamage")
register_forward(FM_SetModel,"HookFm_SetModel")
register_forward(FM_AddToFullPack,"fw_AddToFullPack_post",1)
register_forward(FM_CheckVisibility,"fw_CheckVisibility")
register_forward(FM_UpdateClientData,"HookFm_UpdateClientData",1)
register_touch("*", classname_ball, "BallTouch")
gMaxPlayers = get_maxplayers()
Msg_WeaponList = get_user_msgid("WeaponList");
register_clcmd(weapon_new,"hook_item")
}
public plugin_precache()
{
engfunc(EngFunc_PrecacheModel, MODEL_W)
engfunc(EngFunc_PrecacheModel, MODEL_V)
engfunc(EngFunc_PrecacheModel, MODEL_P)
engfunc(EngFunc_PrecacheModel, MODEL_P_CHARGE)
engfunc(EngFunc_PrecacheModel, SPRITE_BALL_1)
engfunc(EngFunc_PrecacheModel, SPRITE_BALL_2)
engfunc(EngFunc_PrecacheModel, SPRITE_BALL_3)
g_AllocString_V = engfunc(EngFunc_AllocString, MODEL_V)
g_AllocString_P = engfunc(EngFunc_AllocString, MODEL_P)
g_AllocString_P_charge = engfunc(EngFunc_AllocString, MODEL_P_CHARGE)
for(new i = 0; i < sizeof(Weapon_Sounds); i++)
engfunc(EngFunc_PrecacheSound,Weapon_Sounds[i])
g_ChargeBall1_Explosion = engfunc(EngFunc_PrecacheModel,"sprites/laserminigun_explode_1.spr")
g_ChargeBall2_Explosion = engfunc(EngFunc_PrecacheModel,"sprites/laserminigun_explode_2.spr")
g_ChargeBall3_Explosion = engfunc(EngFunc_PrecacheModel,"sprites/laserminigun_explode_3.spr")
g_Muzzleflash_Ent1 = engfunc(EngFunc_CreateNamedEntity,engfunc(EngFunc_AllocString,"info_target"))
precache_model(MUZZLEFLASH_1)
engfunc(EngFunc_SetModel,g_Muzzleflash_Ent1,MUZZLEFLASH_1)
set_pev(g_Muzzleflash_Ent1,pev_scale,0.1)
set_pev(g_Muzzleflash_Ent1,pev_rendermode,kRenderTransTexture)
set_pev(g_Muzzleflash_Ent1,pev_renderamt,0.0)
g_Muzzleflash_Ent2 = engfunc(EngFunc_CreateNamedEntity,engfunc(EngFunc_AllocString,"info_target"))
precache_model(MUZZLEFLASH_2)
engfunc(EngFunc_SetModel,g_Muzzleflash_Ent2,MUZZLEFLASH_2)
set_pev(g_Muzzleflash_Ent2,pev_scale,0.1)
set_pev(g_Muzzleflash_Ent2,pev_rendermode,kRenderTransTexture)
set_pev(g_Muzzleflash_Ent2,pev_renderamt,0.0)
g_Muzzleflash_Ent3 = engfunc(EngFunc_CreateNamedEntity,engfunc(EngFunc_AllocString,"info_target"))
precache_model(MUZZLEFLASH_3)
engfunc(EngFunc_SetModel,g_Muzzleflash_Ent3,MUZZLEFLASH_3)
set_pev(g_Muzzleflash_Ent3,pev_scale,0.1)
set_pev(g_Muzzleflash_Ent3,pev_rendermode,kRenderTransTexture)
set_pev(g_Muzzleflash_Ent3,pev_renderamt,0.0)
g_MuzzleflashBall_Ent1 = engfunc(EngFunc_CreateNamedEntity,engfunc(EngFunc_AllocString,"info_target"))
engfunc(EngFunc_SetModel,g_MuzzleflashBall_Ent1,SPRITE_BALL_1)
set_pev(g_MuzzleflashBall_Ent1,pev_scale,0.1)
set_pev(g_MuzzleflashBall_Ent1,pev_rendermode,kRenderTransTexture)
set_pev(g_MuzzleflashBall_Ent1,pev_renderamt,0.0)
set_pev(g_MuzzleflashBall_Ent1,pev_fuser1, 0.1)
g_MuzzleflashBall_Ent2 = engfunc(EngFunc_CreateNamedEntity,engfunc(EngFunc_AllocString,"info_target"))
engfunc(EngFunc_SetModel,g_MuzzleflashBall_Ent2,SPRITE_BALL_2)
set_pev(g_MuzzleflashBall_Ent2,pev_scale,0.2)
set_pev(g_MuzzleflashBall_Ent2,pev_rendermode,kRenderTransTexture)
set_pev(g_MuzzleflashBall_Ent2,pev_renderamt,0.0)
set_pev(g_MuzzleflashBall_Ent2,pev_fuser1, 0.2)
g_MuzzleflashBall_Ent3 = engfunc(EngFunc_CreateNamedEntity,engfunc(EngFunc_AllocString,"info_target"))
engfunc(EngFunc_SetModel,g_MuzzleflashBall_Ent3,SPRITE_BALL_3)
set_pev(g_MuzzleflashBall_Ent3,pev_scale,0.25)
set_pev(g_MuzzleflashBall_Ent3,pev_rendermode,kRenderTransTexture)
set_pev(g_MuzzleflashBall_Ent3,pev_renderamt,0.0)
set_pev(g_MuzzleflashBall_Ent3,pev_fuser1, 0.25)
engfunc(EngFunc_PrecacheGeneric,MUZZLEFLASH_1)
engfunc(EngFunc_PrecacheGeneric,MUZZLEFLASH_2)
engfunc(EngFunc_PrecacheGeneric,MUZZLEFLASH_3)
engfunc(EngFunc_PrecacheGeneric,"sprites/640hud133.spr")
engfunc(EngFunc_PrecacheGeneric,"sprites/640hud14.spr")
engfunc(EngFunc_PrecacheGeneric,"sprites/weapon_laserminigun.txt")
register_forward(FM_Spawn,"HookFm_Spawn",0)
}
public plugin_natives()
{
register_native("give_laserminigun","get_item", 1)
}
public ze_user_infected(id)
{
remove_laserminigun(id)
}
public ze_user_humanized(id)
{
remove_laserminigun(id)
}
public remove_laserminigun(id)
{
g_ChargeBall[id] = 0
g_ChargeForEntity[id] = 0
UnSet_BitVar(g_MuzzleflashBall1,id)
UnSet_BitVar(g_MuzzleflashBall2,id)
UnSet_BitVar(g_MuzzleflashBall3,id)
}
public ze_select_item_pre(id, itemid)
{
// This not our item?
if (itemid != g_iItemID)
return ZE_ITEM_AVAILABLE
// Available for Humans only, So don't show it for zombies
if (ze_is_user_zombie(id))
return ZE_ITEM_DONT_SHOW
// Player Not VIP?
if (!(ze_get_vip_flags(id) & VIP_A))
return ZE_ITEM_DONT_SHOW
// Finally return that it's available
return ZE_ITEM_AVAILABLE
}
public ze_select_item_post(id, itemid)
{
// This is not our item, Block it here and don't execute the blew code
if (itemid != g_iItemID)
return
get_item(id)
}
public client_command(id)
{
new Command[32];read_argv(0,Command,charsmax(Command));
new ent = fm_find_ent_by_owner(-1,weapon_name,id)
if(equali(Command,"weapon_",7) && g_ChargeBall[id] && Is_CustomItem(ent) || equali(Command,"lastinv") && g_ChargeBall[id] && Is_CustomItem(ent))
{
client_print(id,print_center,"Saat Ini Senjata Tidak Bisa Di Ganti")
return PLUGIN_HANDLED;
}
else if(equali(Command,"drop") && g_ChargeBall[id] && Is_CustomItem(ent))
{
client_print(id,print_center,"Saat Ini Senjata Tidak Bisa Di Drop")
return PLUGIN_HANDLED;
}
return PLUGIN_CONTINUE;
}
public get_item(id)
{
UTIL_DropWeapon(id,1)
new weapon = make_weapon()
if(weapon <= 0)
return
if(!ExecuteHamB(Ham_AddPlayerItem,id,weapon))
{
engfunc(EngFunc_RemoveEntity,weapon)
return
}
ExecuteHam(Ham_Item_AttachToPlayer,weapon,id)
new ammotype = 376 + get_pdata_int(weapon,49,4)
new ammo = get_pdata_int(id,ammotype,5)
if(ammo < WEAPON_BPAMMO)
set_pdata_int(id, ammotype, WEAPON_BPAMMO, 5)
set_pdata_int(weapon, 51, WEAPON_CLIP, 4)
emit_sound(id,CHAN_ITEM,"items/gunpickup2.wav",VOL_NORM,ATTN_NORM,0,PITCH_NORM)
g_ChargeState[weapon] = STATE_LOW
g_ChargeShots[weapon] = 0
g_ChargeBall[id] = 0
g_ChargeForEntity[id] = 0
UnSet_BitVar(g_MuzzleflashBall1,id)
UnSet_BitVar(g_MuzzleflashBall2,id)
UnSet_BitVar(g_MuzzleflashBall3,id)
}
public hook_item(id)
{
engclient_cmd(id,weapon_name)
return PLUGIN_HANDLED
}
public fw_AddToFullPack_post(esState,iE,ent,iHost,iHostFlags,iPlayer,pSet)
{
if(ent == g_Muzzleflash_Ent1)
{
if(Get_BitVar(g_Muzzleflash1,iHost))
{
set_es(esState,ES_Frame,float(random_num(0,2)))
set_es(esState,ES_RenderMode,kRenderTransAdd)
set_es(esState,ES_RenderAmt,255.0)
UnSet_BitVar(g_Muzzleflash1,iHost)
}
set_es(esState,ES_Skin,iHost)
set_es(esState,ES_Body,1)
set_es(esState,ES_AimEnt,iHost)
set_es(esState,ES_MoveType,MOVETYPE_FOLLOW)
}
if(ent == g_Muzzleflash_Ent2)
{
if(Get_BitVar(g_Muzzleflash2,iHost))
{
set_es(esState,ES_Frame,float(random_num(0,2)))
set_es(esState,ES_RenderMode,kRenderTransAdd)
set_es(esState,ES_RenderAmt,255.0)
UnSet_BitVar(g_Muzzleflash2,iHost)
}
set_es(esState,ES_Skin,iHost)
set_es(esState,ES_Body,1)
set_es(esState,ES_AimEnt,iHost)
set_es(esState,ES_MoveType,MOVETYPE_FOLLOW)
}
if(ent == g_Muzzleflash_Ent3)
{
if(Get_BitVar(g_Muzzleflash3,iHost))
{
set_es(esState,ES_Frame,float(random_num(0,2)))
set_es(esState,ES_RenderMode,kRenderTransAdd)
set_es(esState,ES_RenderAmt,255.0)
UnSet_BitVar(g_Muzzleflash3,iHost)
}
set_es(esState,ES_Skin,iHost)
set_es(esState,ES_Body,1)
set_es(esState,ES_AimEnt,iHost)
set_es(esState,ES_MoveType,MOVETYPE_FOLLOW)
}
if(ent == g_MuzzleflashBall_Ent1)
{
if(Get_BitVar(g_MuzzleflashBall1,iHost))
{
set_es(esState,ES_Frame,float(random_num(0,8)))
set_es(esState,ES_RenderMode,kRenderTransAdd)
set_es(esState,ES_RenderAmt,240.0)
}
set_es(esState,ES_Skin,iHost)
set_es(esState,ES_Body,1)
set_es(esState,ES_AimEnt,iHost)
set_es(esState,ES_MoveType,MOVETYPE_FOLLOW)
}
if(ent == g_MuzzleflashBall_Ent2)
{
if(Get_BitVar(g_MuzzleflashBall2,iHost))
{
set_es(esState,ES_Frame,float(random_num(0,8)))
set_es(esState,ES_RenderMode,kRenderTransAdd)
set_es(esState,ES_RenderAmt,240.0)
}
set_es(esState,ES_Skin,iHost)
set_es(esState,ES_Body,1)
set_es(esState,ES_AimEnt,iHost)
set_es(esState,ES_MoveType,MOVETYPE_FOLLOW)
}
if(ent == g_MuzzleflashBall_Ent3)
{
if(Get_BitVar(g_MuzzleflashBall3,iHost))
{
set_es(esState,ES_Frame,float(random_num(0,8)))
set_es(esState,ES_RenderMode,kRenderTransAdd)
set_es(esState,ES_RenderAmt,240.0)
}
set_es(esState,ES_Skin,iHost)
set_es(esState,ES_Body,1)
set_es(esState,ES_AimEnt,iHost)
set_es(esState,ES_MoveType,MOVETYPE_FOLLOW)
}
}
public fw_CheckVisibility(entity,pSet)
{
if(entity == g_Muzzleflash_Ent1 || entity == g_Muzzleflash_Ent2 || entity == g_Muzzleflash_Ent3)
{
forward_return(FMV_CELL,1)
return FMRES_SUPERCEDE
}
else if(entity == g_MuzzleflashBall_Ent1 || entity == g_MuzzleflashBall_Ent2 || entity == g_MuzzleflashBall_Ent3)
{
forward_return(FMV_CELL,1)
return FMRES_SUPERCEDE
}
return FMRES_IGNORED
}
public HookHam_Weapon_Deploy(ent)
{
if(!Is_CustomItem(ent))
return HAM_IGNORED
static id
id = get_pdata_cbase(ent,41,4)
set_pev_string(id,pev_viewmodel2, g_AllocString_V)
set_pev_string(id,pev_weaponmodel2, g_AllocString_P)
set_pdata_float(ent,46,DRAW_TIME,4)
set_pdata_float(ent,47,DRAW_TIME,4)
set_pdata_float(ent,48,DRAW_TIME,4)
Play_WeaponAnim(id,ANIM_DRAW)
set_pdata_string(id,1968,"m249",-1,20)
Weaponlist(id, true)
return HAM_IGNORED
}
public HookHam_Weapon_Add(ent,id)
{
switch(pev(ent,pev_impulse))
{
case WEAPON_KEY: Weaponlist(id,true)
case 0: Weaponlist(id,false)
}
return HAM_IGNORED
}
public MakeBall(id)
{
new ent = create_entity("env_sprite"),Float:f_origin[3],Float:f_vec[3]
set_pev(ent,pev_classname,classname_ball)
pev(id,pev_origin,f_origin)
velocity_by_aim(id,35,f_vec)
for(new i=0;i<3;i++){ f_origin[i]+=f_vec[i];f_vec[i]*=40.0;}
f_origin[2] += (pev(id,pev_flags)&FL_DUCKING)?2.0:10.0;
set_pev(ent,pev_origin,f_origin)
set_pev(ent,pev_velocity,f_vec)
set_pev(ent,pev_solid,SOLID_BBOX)
set_pev(ent,pev_movetype,MOVETYPE_FLY)
if(g_ChargeForEntity[id] == 1)
{
set_pev(ent, pev_scale, 0.2)
entity_set_model(ent,SPRITE_BALL_1)
}
else if(g_ChargeForEntity[id] == 2)
{
set_pev(ent, pev_scale, 0.25)
entity_set_model(ent,SPRITE_BALL_1)
}
else if(g_ChargeForEntity[id] == 3)
{
set_pev(ent, pev_scale, 0.27)
entity_set_model(ent,SPRITE_BALL_2)
}
else if(g_ChargeForEntity[id] == 4)
{
set_pev(ent, pev_scale, 0.32)
entity_set_model(ent,SPRITE_BALL_3)
}
set_pev(ent,pev_mins,Float:{-4.0,-4.0,-4.0})
set_pev(ent,pev_maxs,Float:{4.0,4.0,4.0})
set_pev(ent,pev_owner,id)
set_pev(ent,pev_rendermode,kRenderTransAdd)
set_pev(ent,pev_renderamt,255.0)
pev(id,pev_v_angle,f_vec)
set_pev(ent,pev_v_angle,f_vec)
}
public BallTouch(id, ent)
{
new Float:origin[3],Float:f_vec[3]
pev(ent, pev_origin, origin)
velocity_by_aim(ent,-15,f_vec)
for(new i = 0; i < 3; i++)
origin[i] += f_vec[i]
static classnameptd[32]
pev(id, pev_classname, classnameptd, 31)
if(equali(classnameptd, "func_breakable"))
ExecuteHamB(Ham_TakeDamage, id, 0, 0, 100.0, DMG_GENERIC)
BallSprites(ent, origin)
BallDamage(ent)
}
public BallSprites(ent, Float:origin[3])
{
static owner
owner = pev(ent, pev_owner)
if(g_ChargeForEntity[owner] == 1)
{
message_begin(MSG_BROADCAST,SVC_TEMPENTITY)
write_byte(TE_SPRITE);
write_coord(floatround(origin[0]))
write_coord(floatround(origin[1]))
write_coord(floatround(origin[2] + 40.0))
write_short(g_ChargeBall1_Explosion)
write_byte(30)
write_byte(225)
message_end()
emit_sound(ent, CHAN_ITEM, Weapon_Sounds[13], 1.0, ATTN_NORM, 0, PITCH_NORM)
}
else if(g_ChargeForEntity[owner] == 2)
{
message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
write_byte(TE_SPRITE);
write_coord(floatround(origin[0]))
write_coord(floatround(origin[1]))
write_coord(floatround(origin[2] + 40.0))
write_short(g_ChargeBall1_Explosion)
write_byte(30)
write_byte(225)
message_end()
emit_sound(ent, CHAN_ITEM, Weapon_Sounds[12], 1.0, ATTN_NORM, 0, PITCH_NORM)
}
else if(g_ChargeForEntity[owner] == 3)
{
message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
write_byte(TE_SPRITE);
write_coord(floatround(origin[0]))
write_coord(floatround(origin[1]))
write_coord(floatround(origin[2] + 40.0))
write_short(g_ChargeBall2_Explosion)
write_byte(30)
write_byte(225)
message_end()
emit_sound(ent, CHAN_ITEM, Weapon_Sounds[13], 1.0, ATTN_NORM, 0, PITCH_NORM)
}
else if(g_ChargeForEntity[owner] == 4)
{
message_begin(MSG_BROADCAST,SVC_TEMPENTITY)
write_byte(TE_SPRITE)
write_coord(floatround(origin[0]))
write_coord(floatround(origin[1]))
write_coord(floatround(origin[2] + 40.0))
write_short(g_ChargeBall3_Explosion)
write_byte(30)
write_byte(225)
message_end()
emit_sound(ent, CHAN_ITEM, Weapon_Sounds[14], 1.0, ATTN_NORM, 0, PITCH_NORM)
}
}
public BallDamage(ent)
{
static owner, attacker
owner = pev(ent, pev_owner)
if(!is_user_alive(owner) || ze_is_user_zombie(owner))
{
attacker = 0;
return
}
else attacker = owner
for(new i = 0; i < gMaxPlayers; i++)
{
if(i == attacker)
continue
if(!is_user_alive(i))
continue
if(!ze_is_user_zombie(i))
continue
if(entity_range(i, ent) > EXPLODE_RADIUS)
continue
if(g_ChargeForEntity[attacker] == 1) ExecuteHamB(Ham_TakeDamage,i,0,attacker,DAMAGE_BALL_1,DMG_BULLET)
else if(g_ChargeForEntity[attacker] == 2) ExecuteHamB(Ham_TakeDamage,i,0,attacker,DAMAGE_BALL_1,DMG_BULLET)
else if(g_ChargeForEntity[attacker] == 3) ExecuteHamB(Ham_TakeDamage,i,0,attacker,DAMAGE_BALL_2,DMG_BULLET)
else if(g_ChargeForEntity[attacker] == 4) ExecuteHamB(Ham_TakeDamage,i,0,attacker,DAMAGE_BALL_3,DMG_BULLET)
}
remove_entity(ent)
}
public HookHam_Weapon_Frame(ent)
{
if(!Is_CustomItem(ent))
return HAM_IGNORED
static id
id = get_pdata_cbase(ent,41,4)
if(get_pdata_int(ent,54,4))
{
if(get_pdata_float(ent,46,4) >= 0.0)
return HAM_IGNORED
static clip,ammotype,ammo,j
clip = get_pdata_int(ent,51,4)
ammotype = 376 + get_pdata_int(ent,49,4)
ammo = get_pdata_int(id,ammotype,5)
j = min(WEAPON_CLIP-clip,ammo)
set_pdata_int(ent, 51, clip+j, 4)
set_pdata_int(id, ammotype, ammo-j, 5)
set_pdata_int(ent, 54, 0, 4)
}
if(g_ChargeShots[ent] < SHOOTS_FOR_HIGH) g_ChargeState[ent] = STATE_LOW
else if(g_ChargeShots[ent] >= SHOOTS_FOR_HIGH && g_ChargeShots[ent] < SHOOTS_FOR_EXTRREME) g_ChargeState[ent] = STATE_HIGH
else if(g_ChargeShots[ent] >= SHOOTS_FOR_EXTRREME) g_ChargeState[ent] = STATE_EXTREME
if(g_ChargeBall[id]) g_ChargeState[ent] = STATE_CHARGE
if(g_ChargeShots[ent] > 0 && !(pev(id,pev_button) & IN_ATTACK) &&!g_ChargeBall[id])
g_ChargeShots[ent]--
static iButton;iButton = pev(id,pev_button)
g_ChargeBall[id] = pev(ent, pev_iuser1)
new Float:fFinshTime, Float:ScaleNew, Float:ScaleDelay[33]
pev(ent,pev_fuser1,fFinshTime)
static ammo
ammo = get_pdata_int(ent,51,4)
if(iButton & IN_ATTACK2)
{
if(get_pdata_float(ent, 46, 4) >= 0.0)
return HAM_IGNORED
if(ammo == 0)
return HAM_IGNORED
g_ChargeState[ent] = STATE_CHARGE
set_pev_string(id,pev_weaponmodel2,g_AllocString_P_charge)
if(!g_ChargeBall[id])
{
g_ChargeBall[id] = 1
fFinshTime = get_gametime()+1.0
Play_WeaponAnim(id, 1)
emit_sound(ent, CHAN_ITEM, Weapon_Sounds[3], 1.0, ATTN_NORM, 0, PITCH_NORM)
set_pdata_float(ent, 48, 1.0, 4)
set_pdata_float(ent, 46, 1.0, 4)
set_pev(ent,pev_iuser1,g_ChargeBall[id])
if(get_gametime() - 0.01 > ScaleDelay[id])
{
pev(g_MuzzleflashBall_Ent1, pev_scale, ScaleNew)
ScaleNew += 0.01
set_pev(g_MuzzleflashBall_Ent1, pev_scale, ScaleNew)
ScaleDelay[id] = get_gametime()
}
set_pev(ent, pev_fuser1, fFinshTime)
Set_BitVar(g_MuzzleflashBall1,id)
UnSet_BitVar(g_MuzzleflashBall2,id)
UnSet_BitVar(g_MuzzleflashBall3,id)
}
else if(get_gametime() > fFinshTime && g_ChargeBall[id] == 1)
{
g_ChargeBall[id] = 2;
fFinshTime = get_gametime()+3.0
Play_WeaponAnim(id,2)
emit_sound(ent, CHAN_ITEM, Weapon_Sounds[1], 1.0, ATTN_NORM, 0, PITCH_NORM)
set_pdata_float(ent, 48, 1.25, 4)
set_pdata_float(ent, 46, 1.25, 4)
set_pev(ent,pev_iuser1,g_ChargeBall[id])
if(get_gametime() - 0.01 > ScaleDelay[id])
{
pev(g_MuzzleflashBall_Ent1, pev_scale, ScaleNew)
ScaleNew += 0.02
set_pev(g_MuzzleflashBall_Ent1, pev_scale, ScaleNew)
ScaleDelay[id] = get_gametime()
}
Set_BitVar(g_MuzzleflashBall1,id)
UnSet_BitVar(g_MuzzleflashBall2,id)
UnSet_BitVar(g_MuzzleflashBall3,id)
}
else if(get_gametime() > fFinshTime && g_ChargeBall[id] == 2)
{
g_ChargeBall[id] = 3
fFinshTime = get_gametime()+3.0
set_pdata_float(ent, 48, 1.5, 4)
set_pdata_float(ent, 46, 1.5, 4)
set_pev(ent,pev_iuser1,g_ChargeBall[id])
if(get_gametime() - 0.01 > ScaleDelay[id])
{
pev(g_MuzzleflashBall_Ent1, pev_scale, ScaleNew)
ScaleNew += 0.05
set_pev(g_MuzzleflashBall_Ent1, pev_scale, ScaleNew)
ScaleDelay[id] = get_gametime()
}
UnSet_BitVar(g_MuzzleflashBall1,id)
Set_BitVar(g_MuzzleflashBall2,id)
UnSet_BitVar(g_MuzzleflashBall3,id)
}
else if(get_gametime() > fFinshTime && g_ChargeBall[id] == 3)
{
g_ChargeBall[id] = 4
fFinshTime = get_gametime() + 200.0
Play_WeaponAnim(id, 3)
emit_sound(ent, CHAN_ITEM, Weapon_Sounds[2], 1.0, ATTN_NORM, 0, PITCH_NORM)
set_pdata_float(ent, 48, 250.0, 4)
set_pdata_float(ent, 46, 250.0, 4)
set_pev(ent,pev_iuser1,g_ChargeBall[id])
if(get_gametime() - 0.01 > ScaleDelay[id])
{
pev(g_MuzzleflashBall_Ent1, pev_scale, ScaleNew)
ScaleNew += 0.08
set_pev(g_MuzzleflashBall_Ent1, pev_scale, ScaleNew)
ScaleDelay[id] = get_gametime()
}
set_pev(ent, pev_fuser1, fFinshTime)
UnSet_BitVar(g_MuzzleflashBall1,id)
UnSet_BitVar(g_MuzzleflashBall2,id)
Set_BitVar(g_MuzzleflashBall3,id)
}
iButton &= ~IN_ATTACK2;
set_pev(id,pev_button,iButton)
}
else
{
switch(g_ChargeBall[id])
{
case 1:
{
Play_WeaponAnim(id,4)
emit_sound(ent, CHAN_ITEM, Weapon_Sounds[4], 1.0, ATTN_NORM, 0, PITCH_NORM)
set_pdata_float(ent,48,1.63,4)
set_pdata_float(ent,46,1.0,4)
UnSet_BitVar(g_MuzzleflashBall1,id)
UnSet_BitVar(g_MuzzleflashBall2,id)
UnSet_BitVar(g_MuzzleflashBall3,id)
g_ChargeState[ent] = STATE_LOW
g_ChargeShots[ent] = 0
g_ChargeForEntity[id] = g_ChargeBall[id]
set_pev_string(id,pev_weaponmodel2,g_AllocString_P)
MakeBall(id)
if(ammo > 19) set_pdata_int(ent, 51, ammo - 20, 4)
else set_pdata_int(ent,51, 0, 4)
}
case 2:
{
Play_WeaponAnim(id,4);
emit_sound(ent, CHAN_ITEM, Weapon_Sounds[4], 1.0, ATTN_NORM, 0, PITCH_NORM)
set_pdata_float(ent,48,1.63,4)
set_pdata_float(ent,46,1.0,4)
UnSet_BitVar(g_MuzzleflashBall1,id)
UnSet_BitVar(g_MuzzleflashBall2,id)
UnSet_BitVar(g_MuzzleflashBall3,id)
g_ChargeState[ent] = STATE_LOW
g_ChargeShots[ent] = 0
g_ChargeForEntity[id] = g_ChargeBall[id]
set_pev_string(id,pev_weaponmodel2,g_AllocString_P)
MakeBall(id)
if(ammo > 19) set_pdata_int(ent, 51, ammo - 20, 4)
else set_pdata_int(ent,51, 0, 4)
}
case 3:
{
Play_WeaponAnim(id,4)
emit_sound(ent, CHAN_ITEM, Weapon_Sounds[4], 1.0, ATTN_NORM, 0, PITCH_NORM)
set_pdata_float(ent,48,1.63,4)
set_pdata_float(ent,46,1.0,4)
UnSet_BitVar(g_MuzzleflashBall1,id)
UnSet_BitVar(g_MuzzleflashBall2,id)
UnSet_BitVar(g_MuzzleflashBall3,id)
g_ChargeState[ent] = STATE_LOW
g_ChargeShots[ent] = 0
g_ChargeForEntity[id] = g_ChargeBall[id]
set_pev_string(id,pev_weaponmodel2,g_AllocString_P)
MakeBall(id)
if(ammo > 19) set_pdata_int(ent, 51, ammo - 20, 4)
else set_pdata_int(ent,51, 0, 4)
}
case 4:
{
Play_WeaponAnim(id,4)
emit_sound(ent, CHAN_ITEM, Weapon_Sounds[4], 1.0, ATTN_NORM, 0, PITCH_NORM)
set_pdata_float(ent,48,1.63,4)
set_pdata_float(ent,46,1.0,4)
UnSet_BitVar(g_MuzzleflashBall1,id)
UnSet_BitVar(g_MuzzleflashBall2,id)
UnSet_BitVar(g_MuzzleflashBall3,id)
g_ChargeState[ent] = STATE_LOW
g_ChargeShots[ent] = 0
g_ChargeForEntity[id] = g_ChargeBall[id]
set_pev_string(id,pev_weaponmodel2,g_AllocString_P)
MakeBall(id)
if(ammo > 19) set_pdata_int(ent, 51, ammo - 20, 4)
else set_pdata_int(ent,51, 0, 4)
}
}
g_ChargeBall[id] = 0
new Float:ResetScale[3]
pev(g_MuzzleflashBall_Ent1, pev_fuser1, ResetScale[0])
set_pev(g_MuzzleflashBall_Ent1, pev_scale, ResetScale[0])
pev(g_MuzzleflashBall_Ent2, pev_fuser1, ResetScale[1])
set_pev(g_MuzzleflashBall_Ent2, pev_scale, ResetScale[1])
pev(g_MuzzleflashBall_Ent3, pev_fuser1, ResetScale[2])
set_pev(g_MuzzleflashBall_Ent3, pev_scale, ResetScale[2])
set_pev_string(id,pev_weaponmodel2,g_AllocString_P)
set_pev(ent,pev_iuser1,g_ChargeBall[id])
}
return HAM_IGNORED
}
public HookHam_Weapon_Reload(ent)
{
if(!Is_CustomItem(ent))
return HAM_IGNORED
static clip
clip = get_pdata_int(ent,51,4)
if(clip >= WEAPON_CLIP)
return HAM_SUPERCEDE
static id
id = get_pdata_cbase(ent,41,4)
if(get_pdata_int(id, 376 + get_pdata_int(ent,49,4), 5) <= 0)
return HAM_SUPERCEDE
set_pdata_int(ent, 51, 0,4)
ExecuteHam(Ham_Weapon_Reload, ent)
set_pdata_int(ent,51, clip, 4)
set_pdata_int(ent,54, 1,4)
set_pdata_float(ent, 46,RELOAD_TIME,4)
set_pdata_float(ent, 47,RELOAD_TIME,4)
set_pdata_float(ent, 48,RELOAD_TIME,4)
set_pdata_float(id, 83, RELOAD_TIME,5)
Play_WeaponAnim(id, ANIM_RELOAD)
return HAM_SUPERCEDE;
}
public HookHam_Weapon_Idle(ent)
{
if(!Is_CustomItem(ent))
return HAM_IGNORED
if(get_pdata_float(ent, 48, 4) > 0.0)
return HAM_IGNORED
set_pdata_float(ent,48,IDLE_TIME,4)
Play_WeaponAnim(get_pdata_cbase(ent, 41, 4), ANIM_IDLE)
return HAM_SUPERCEDE
}
public HookHam_Weapon_PrimaryAttack(ent)
{
if(!Is_CustomItem(ent))
return HAM_IGNORED
static ammo
ammo = get_pdata_int(ent,51,4)
if(ammo <= 0)
{
ExecuteHam(Ham_Weapon_PlayEmptySound,ent);
set_pdata_float(ent,46,WEAPON_SPEED,4)
return HAM_SUPERCEDE
}
static id; id = get_pdata_cbase(ent,41,4)
static Float:user_punchangle[3];pev(id,pev_punchangle,user_punchangle)
static fm_hooktrace;fm_hooktrace=register_forward(FM_TraceLine,"HookFm_TraceLine",true)
static fm_playbackevent;fm_playbackevent=register_forward(FM_PlaybackEvent,"HookFm_PlayBackEvent",false)
state FireBullets: Enabled;
ExecuteHam(Ham_Weapon_PrimaryAttack,ent)
state FireBullets: Disabled;
unregister_forward(FM_TraceLine,fm_hooktrace,true)
unregister_forward(FM_PlaybackEvent,fm_playbackevent,false)
Play_WeaponAnim(id,random_num(ANIM_SHOOT_1,ANIM_SHOOT_2))
set_pdata_int(ent,51,ammo-1,4)
set_pdata_float(ent,48,2.0,4)
static Float:user_newpunch[3];pev(id,pev_punchangle,user_newpunch)
user_newpunch[0]=user_punchangle[0]+(user_newpunch[0]-user_punchangle[0])*RECOIL
user_newpunch[1]=user_punchangle[1]+(user_newpunch[1]-user_punchangle[1])*RECOIL
user_newpunch[2]=user_punchangle[2]+(user_newpunch[2]-user_punchangle[2])*RECOIL
set_pev(id,pev_punchangle,user_newpunch)
emit_sound(ent, CHAN_ITEM, Weapon_Sounds[0], 1.0, ATTN_NORM, 0, PITCH_NORM)
set_pdata_float(ent,46,WEAPON_SPEED,4)
new Float:Origin[3]
get_weapon_position(id,Origin,.add_forward=10.0,.add_right=7.0,.add_up=-10.5)
new Float:Velo[3]
Velo[0]=g_VecEndTrace[0]-Origin[0]
Velo[1]=g_VecEndTrace[1]-Origin[1]
Velo[2]=g_VecEndTrace[2]-Origin[2]
vec_normalize(Velo,Velo)
vec_mul_scalar(Velo,4096.0,Velo)
if(g_ChargeState[ent] == STATE_LOW)
{
message_begin(MSG_BROADCAST,SVC_TEMPENTITY)
write_byte(TE_USERTRACER)
engfunc(EngFunc_WriteCoord,Origin[0])
engfunc(EngFunc_WriteCoord,Origin[1])
engfunc(EngFunc_WriteCoord,Origin[2])
engfunc(EngFunc_WriteCoord,Velo[0])
engfunc(EngFunc_WriteCoord,Velo[1])
engfunc(EngFunc_WriteCoord,Velo[2])
write_byte(20)
write_byte(4)
write_byte(5)
message_end()
Set_BitVar(g_Muzzleflash1,id)
}
else if(g_ChargeState[ent] == STATE_HIGH)
{
message_begin(MSG_BROADCAST,SVC_TEMPENTITY)
write_byte(TE_USERTRACER)
engfunc(EngFunc_WriteCoord,Origin[0])
engfunc(EngFunc_WriteCoord,Origin[1])
engfunc(EngFunc_WriteCoord,Origin[2])
engfunc(EngFunc_WriteCoord,Velo[0])
engfunc(EngFunc_WriteCoord,Velo[1])
engfunc(EngFunc_WriteCoord,Velo[2])
write_byte(20)
write_byte(5)
write_byte(5)
message_end()
Set_BitVar(g_Muzzleflash2,id)
}
else if(g_ChargeState[ent] == STATE_EXTREME)
{
message_begin(MSG_BROADCAST,SVC_TEMPENTITY)
write_byte(TE_USERTRACER)
engfunc(EngFunc_WriteCoord,Origin[0])
engfunc(EngFunc_WriteCoord,Origin[1])
engfunc(EngFunc_WriteCoord,Origin[2])
engfunc(EngFunc_WriteCoord,Velo[0])
engfunc(EngFunc_WriteCoord,Velo[1])
engfunc(EngFunc_WriteCoord,Velo[2])
write_byte(20)
write_byte(1)
write_byte(5)
message_end()
Set_BitVar(g_Muzzleflash3,id)
}
g_ChargeShots[ent]++
return HAM_SUPERCEDE
}
public HookHam_TakeDamage(victim,inflictor,attacker,Float:damage)<FireBullets: Enabled>
{
new ent = fm_find_ent_by_owner(-1,weapon_name,attacker)
if(g_ChargeState[ent] == STATE_LOW)
SetHamParamFloat(4,damage*DAMAGE_LOW)
else if(g_ChargeState[ent] == STATE_HIGH)
SetHamParamFloat(4,damage*DAMAGE_HIGH)
else if(g_ChargeState[ent] == STATE_EXTREME)
SetHamParamFloat(4,damage*DAMAGE_EXTREME)
return HAM_OVERRIDE;
}
public HookHam_TakeDamage()<FireBullets: Disabled>
{
return HAM_IGNORED;
}
public HookHam_TakeDamage()<>
{
return HAM_IGNORED;
}
public HookFm_SetModel(ent)
{
static i,classname[32],item;pev(ent,pev_classname,classname,31);
if(!equal(classname,"weaponbox"))
return FMRES_IGNORED
for(i=0; i < 6; i++)
{
item = get_pdata_cbase(ent,34+i,4)
static id
id = pev(ent,pev_owner)
if(item > 0 && Is_CustomItem(item))
{
engfunc(EngFunc_SetModel,ent,MODEL_W)
g_ChargeState[ent] = STATE_LOW
g_ChargeShots[ent] = 0
UnSet_BitVar(g_MuzzleflashBall1,id)
UnSet_BitVar(g_MuzzleflashBall2,id)
UnSet_BitVar(g_MuzzleflashBall3,id)
g_ChargeBall[id] = 0
return FMRES_SUPERCEDE
}
}
return FMRES_IGNORED;
}
public HookFm_PlayBackEvent()
{
return FMRES_SUPERCEDE
}
public HookFm_TraceLine(Float:tr_start[3],Float:tr_end[3],tr_flag,tr_ignore,tr)
{
if(tr_flag&IGNORE_MONSTERS)
return FMRES_IGNORED
static hit
hit=get_tr2(tr,TR_pHit)
static Decal, glassdecal
if(!glassdecal)
glassdecal = engfunc(EngFunc_DecalIndex,"{bproof1")
hit = get_tr2(tr,TR_pHit)
if(hit > 0 && pev_valid(hit))
{
if(pev(hit,pev_solid) != SOLID_BSP)
return FMRES_IGNORED
else if(pev(hit,pev_rendermode) != 0) Decal=glassdecal
else Decal = random_num(41,45)
}
else Decal = random_num(41,45)
static Float:vecEnd[3]
get_tr2(tr,TR_vecEndPos,vecEnd)
g_VecEndTrace = vecEnd
engfunc(EngFunc_MessageBegin,MSG_PAS,SVC_TEMPENTITY,vecEnd,0)
write_byte(TE_GUNSHOTDECAL)
engfunc(EngFunc_WriteCoord,vecEnd[0])
engfunc(EngFunc_WriteCoord,vecEnd[1])
engfunc(EngFunc_WriteCoord,vecEnd[2])
write_short(hit>0?hit:0)
write_byte(Decal)
message_end()
static Float:WallVector[3];get_tr2(tr,TR_vecPlaneNormal,WallVector)
engfunc(EngFunc_MessageBegin,MSG_PVS,SVC_TEMPENTITY,vecEnd,0);
write_byte(TE_STREAK_SPLASH)
engfunc(EngFunc_WriteCoord,vecEnd[0]);
engfunc(EngFunc_WriteCoord,vecEnd[1]);
engfunc(EngFunc_WriteCoord,vecEnd[2]);
engfunc(EngFunc_WriteCoord,WallVector[0]*random_float(25.0,30.0));
engfunc(EngFunc_WriteCoord,WallVector[1]*random_float(25.0,30.0));
engfunc(EngFunc_WriteCoord,WallVector[2]*random_float(25.0,30.0));
write_byte(111)
write_short(12)
write_short(3)
write_short(75)
message_end()
return FMRES_IGNORED
}
public HookFm_UpdateClientData(id,SendWeapons,CD_Handle)
{
static item
item = get_pdata_cbase(id,373,5)
if(item <= 0 || !Is_CustomItem(item))
return FMRES_IGNORED
set_cd(CD_Handle,CD_flNextAttack,99999.0)
return FMRES_HANDLED
}
public HookFm_Spawn(id)
{
if(pev_valid(id) != 2)
return FMRES_IGNORED
static ClName[32]
pev(id,pev_classname,ClName,31)
if(strlen(ClName) < 5)
return FMRES_IGNORED
static Trie:ClBuffer
if(!ClBuffer) ClBuffer = TrieCreate()
if(!TrieKeyExists(ClBuffer,ClName))
{
TrieSetCell(ClBuffer, ClName, 1)
RegisterHamFromEntity(Ham_TakeDamage, id, "HookHam_TakeDamage", 0)
}
return FMRES_IGNORED
}
stock make_weapon()
{
static ent, g_AllocString_E
if(g_AllocString_E || (g_AllocString_E = engfunc(EngFunc_AllocString,weapon_name)))
ent = engfunc(EngFunc_CreateNamedEntity,g_AllocString_E)
else
return 0
if(ent <= 0)
return 0
set_pev(ent,pev_spawnflags,SF_NORESPAWN)
set_pev(ent,pev_impulse,WEAPON_KEY)
ExecuteHam(Ham_Spawn,ent)
return ent
}
stock UTIL_DropWeapon(id,slot)
{
static iEntity
iEntity = get_pdata_cbase(id,(367 + slot),5)
if(iEntity > 0)
{
static iNext,szWeaponName[32]
do
{
iNext = get_pdata_cbase(iEntity,42,4);
if(get_weaponname(get_pdata_int(iEntity, 43, 4), szWeaponName, 31))
engclient_cmd(id,"drop",szWeaponName)
}
while((iEntity=iNext)>0)
}
}
stock Play_WeaponAnim(id,anim)
{
set_pev(id,pev_weaponanim,anim)
message_begin(MSG_ONE_UNRELIABLE,SVC_WEAPONANIM,_,id)
write_byte(anim)
write_byte(0)
message_end()
}
stock Weaponlist(id,bool:set)
{
if(!is_user_connected(id))
return
message_begin(MSG_ONE,Msg_WeaponList,_,id);
write_string(set == false ? weapon_name:weapon_new);
write_byte(3);
write_byte(WEAPON_BPAMMO);
write_byte(-1);
write_byte(-1);
write_byte(0);
write_byte(4);
write_byte(20);
write_byte(0);
message_end();
}
stock get_weapon_position(id,Float:fOrigin[3],Float:add_forward=0.0,Float:add_right=0.0,Float:add_up=0.0)
{
static Float:Angles[3],Float:ViewOfs[3],Float:vAngles[3]
static Float:Forward[3],Float:Right[3],Float:Up[3]
pev(id,pev_v_angle,vAngles)
pev(id,pev_origin,fOrigin)
pev(id,pev_view_ofs,ViewOfs)
vec_add(fOrigin,ViewOfs,fOrigin)
pev(id,pev_v_angle,Angles)
engfunc(EngFunc_MakeVectors,Angles)
global_get(glb_v_forward,Forward)
global_get(glb_v_right,Right)
global_get(glb_v_up,Up)
vec_mul_scalar(Forward,add_forward,Forward)
vec_mul_scalar(Right,add_right,Right)
vec_mul_scalar(Up,add_up,Up)
fOrigin[0]=fOrigin[0]+Forward[0]+Right[0]+Up[0]
fOrigin[1]=fOrigin[1]+Forward[1]+Right[1]+Up[1]
fOrigin[2]=fOrigin[2]+Forward[2]+Right[2]+Up[2]
}
vec_add(const Float:in1[],const Float:in2[],Float:out[])
{
out[0]=in1[0]+in2[0];
out[1]=in1[1]+in2[1];
out[2]=in1[2]+in2[2];
}
vec_mul_scalar(const Float:vec[],Float:scalar,Float:out[])
{
out[0]=vec[0]*scalar;
out[1]=vec[1]*scalar;
out[2]=vec[2]*scalar;
}
vec_normalize(const Float:vec[],Float:out[])
{
new Float:invlen=rsqrt(vec[0]*vec[0]+vec[1]*vec[1]+vec[2]*vec[2]);
out[0]=vec[0]*invlen;
out[1]=vec[1]*invlen;
out[2]=vec[2]*invlen;
}
Float:rsqrt(Float:x)
{
new Float:xhalf=x*0.5;
new i=_:x;
i=0x5f375a84 - (i>>1);
x=Float:i;
x=x*(1.5-xhalf*x*x);
x=x*(1.5-xhalf*x*x);
x=x*(1.5-xhalf*x*x);
return x;
}
Code: Select all
#include <zombie_escape>
#include <fakemeta_util>
#include <xs>
#define PLUGIN "[MW2] Auto Minigun"
#define VERSION "1.0"
#define AUTHOR "Dias"
new g_player_main[33], g_remoting[33], g_player_main2[33], g_firing[33],
g_preparing[33], g_ending[33], g_reloading[500]
new Float:g_last_firesound[33]
new const base_model[] = "models/mw2_auto/base.mdl"
new const main_model[] = "models/mw2_auto/main.mdl"
new const muzzleflash_spr[] = "sprites/muzzleflash3_auto.spr"
new muzzleflash_spr_id, Float:g_last_shoot[33]
new g_blood, g_bloodspray, g_dead[500], g_exp_id, g_owner[500], Float:g_check_heat[33]
new const minigun_sound[3][] = {
"mw2_auto/minigun-starting.wav",
"mw2_auto/minigun-shooting.wav",
"mw2_auto/minigun-stoping.wav"
}
new g_minigun, g_had_minigun[33], g_reg, g_heat[500], g_sync_hud1
new cvar_minigun_health, cvar_minigun_dmgrand_start, cvar_minigun_dmgrand_end,
cvar_delay_attack, cvar_reload_time
// Weapon entity names
new const WEAPONENTNAMES[][] = { "", "weapon_p228", "", "weapon_scout", "weapon_hegrenade", "weapon_xm1014", "weapon_c4", "weapon_mac10",
"weapon_aug", "weapon_smokegrenade", "weapon_elite", "weapon_fiveseven", "weapon_ump45", "weapon_sg550",
"weapon_galil", "weapon_famas", "weapon_usp", "weapon_glock18", "weapon_awp", "weapon_mp5navy", "weapon_m249",
"weapon_m3", "weapon_m4a1", "weapon_tmp", "weapon_g3sg1", "weapon_flashbang", "weapon_deagle", "weapon_sg552",
"weapon_ak47", "weapon_knife", "weapon_p90" }
public plugin_init()
{
register_plugin(PLUGIN, VERSION, AUTHOR)
register_event("HLTV", "event_newround", "a", "1=0", "2=0")
register_event("DeathMsg", "event_death", "a")
register_think("mw2_mingun_main", "fw_main_think")
register_forward(FM_CmdStart, "fw_CmdStart")
for (new i = 1; i < sizeof WEAPONENTNAMES; i++)
if (WEAPONENTNAMES[i][0]) RegisterHam(Ham_Item_Deploy, WEAPONENTNAMES[i], "fw_Item_Deploy_Post", 1)
g_minigun = ze_register_item("[MW2] Auto-Minigun (Remote)", 35, 0)
g_sync_hud1 = CreateHudSyncObj(645)
// Cvars
cvar_minigun_health = register_cvar("zp_minigun_health", "500")
cvar_minigun_dmgrand_start = register_cvar("zp_minigun_dmgrand_start", "10")
cvar_minigun_dmgrand_end = register_cvar("zp_minigun_dmgrand_end", "30")
cvar_delay_attack = register_cvar("zp_minigun_delay_attack", "0.1")
cvar_reload_time = register_cvar("zp_minigun_reload_time", "30.0")
//register_clcmd("say /make", "create_minigun")
//register_clcmd("say /remote", "remote_minigun")
}
public plugin_precache()
{
precache_model(base_model)
precache_model(main_model)
for(new i = 0; i < sizeof(minigun_sound); i++)
engfunc(EngFunc_PrecacheSound, minigun_sound[i])
muzzleflash_spr_id = precache_model(muzzleflash_spr)
g_blood = precache_model("sprites/blood.spr")
g_bloodspray = precache_model("sprites/bloodspray.spr")
g_exp_id = precache_model("sprites/zerogxplode.spr")
}
public event_newround()
{
remove_entity_name("mw2_mingun_base")
remove_entity_name("mw2_mingun_main")
remove_entity_name("mw2_mingun_view")
for(new i = 0; i < get_maxplayers(); i++)
{
if(is_user_alive(i) && is_user_connected(i))
{
reset_minigun(i)
}
}
}
public event_death()
{
static victim
victim = read_data(2)
reset_minigun(victim)
}
public reset_minigun(id)
{
attach_view(id, id)
g_had_minigun[id] = 0
g_player_main[id] = 0
g_player_main2[id] = 0
g_remoting[id] = 0
g_preparing[id] = 0
g_firing[id] = 0
g_ending[id] = 0
remove_task(id+2479)
message_begin(MSG_ONE_UNRELIABLE, 108, {0,0,0}, id)
write_short(0)
message_end()
}
public ze_select_item_pre(id, itemid)
{
// Return Available and we will block it in Post, So it dosen't affect other plugins
if (itemid != g_minigun)
return ZE_ITEM_AVAILABLE
// Available for Humans only, So don't show it for zombies
if (ze_is_user_zombie(id))
return ZE_ITEM_DONT_SHOW
return ZE_ITEM_AVAILABLE
}
public ze_select_item_post(id, itemid)
{
if (itemid != g_minigun)
return
g_had_minigun[id] = 1
create_minigun(id)
client_printcolor(id, "!g[ZE]!y Hold !t(E)!y for 3 seconds to put MW2 Auto-Minigun !!!")
}
public create_minigun(id)
{
if(!g_had_minigun[id])
return
g_had_minigun[id] = 0
new Float:Origin[3], Float:Angles[3]
get_position(id, 40.0, 0.0, 0.0, Origin)
pev(id, pev_angles, Angles)
// Make the Base
new ent = create_entity("info_target")
entity_set_origin(ent, Origin);
Angles[0] = 0.0
entity_set_vector(ent, EV_VEC_angles, Angles)
entity_set_string(ent,EV_SZ_classname, "mw2_mingun_base")
entity_set_model(ent, base_model);
entity_set_int(ent,EV_INT_solid, SOLID_NOT)
entity_set_float(ent,EV_FL_takedamage,1.0)
entity_set_float(ent,EV_FL_health, get_pcvar_float(cvar_minigun_health) + 1000.0)
new Float:maxs[3] = {10.0,10.0,1.0}
new Float:mins[3] = {-10.0,-10.0,-1.0}
entity_set_size(ent,mins,maxs)
set_entity_anim(ent, 0)
g_dead[ent] = 0
g_owner[ent] = id
entity_set_float(ent,EV_FL_nextthink, halflife_time() + 0.01)
drop_to_floor(ent)
// Create Main
ent = create_entity("info_target")
Origin[2] -= 35.0
entity_set_origin(ent, Origin);
entity_set_vector(ent, EV_VEC_angles, Angles)
entity_set_string(ent,EV_SZ_classname, "mw2_mingun_main")
entity_set_model(ent, main_model);
entity_set_int(ent,EV_INT_solid, SOLID_BBOX)
entity_set_float(ent,EV_FL_takedamage,1.0)
entity_set_float(ent,EV_FL_health, get_pcvar_float(cvar_minigun_health) + 1000.0)
new Float:maxs2[3] = {10.0,10.0,20.0}
new Float:mins2[3] = {-10.0,-10.0,-20.0}
entity_set_size(ent,mins2,maxs2)
set_entity_anim(ent, 0)
g_heat[ent] = 0
entity_set_float(ent,EV_FL_nextthink, halflife_time() + 0.01)
g_player_main[id] = ent
g_dead[ent] = 0
g_owner[ent] = id
g_reloading[ent] = 0
drop_to_floor(ent)
if(!g_reg)
{
g_reg = 1
RegisterHamFromEntity(Ham_TakeDamage, ent, "fw_main_takedamage")
}
// Create View Ent
ent = create_entity("info_target")
get_position(id, 40.0, 0.0, 10.0, Origin)
entity_set_origin(ent, Origin);
entity_set_vector(ent, EV_VEC_angles, Angles)
entity_set_string(ent,EV_SZ_classname, "mw2_mingun_view")
entity_set_model(ent, main_model);
fm_set_rendering(ent, kRenderFxGlowShell, 0, 0, 0, kRenderTransAlpha, 0)
g_player_main2[id] = ent
}
public ze_user_infected(id)
{
reset_minigun(id)
}
public do_remote(id)
{
id -= 2479
remote_minigun(id)
}
public remote_minigun(id)
{
if(!g_player_main[id])
return
attach_view(id, g_player_main2[id])
engclient_cmd(id, "weapon_knife")
set_task(1.0, "task_delay", id)
client_printcolor(id, "!g[ZE]!y Press !t(E)!y to turn of the MW2-Auto Minigun !!!")
}
public task_delay(id)
{
g_remoting[id] = 1
}
public client_PostThink(id)
{
if(!g_remoting[id])
return
if(!g_player_main[id])
return
if(!pev_valid(g_player_main[id]))
{
reset_minigun(id)
return
}
if(!g_firing[id] && !g_reloading[g_player_main[id]])
{
if(g_heat[g_player_main[id]] > 0)
{
static Float:CurTime
CurTime = get_gametime()
if(CurTime - get_pcvar_float(cvar_delay_attack) * 2 > g_check_heat[id])
{
g_heat[g_player_main[id]]--
g_check_heat[id] = CurTime
}
}
}
static Message[64]
if(g_heat[g_player_main[id]] <= 0)
{
set_hudmessage(0, 255, 0, -1.0, 0.90, 0, 1.0, 1.0)
formatex(Message, sizeof(Message), "Status: Good")
} else if(g_heat[g_player_main[id]] > 0 && g_heat[g_player_main[id]] < 100) {
set_hudmessage(255, 255, 0, -1.0, 0.90, 0, 1.0, 1.0)
formatex(Message, sizeof(Message), "Status: Heat %i%%", g_heat[g_player_main[id]])
} else if(g_heat[g_player_main[id]] >= 100) {
set_hudmessage(255, 0, 0, -1.0, 0.90, 0, 1.0, 1.0)
formatex(Message, sizeof(Message), "Status: OverHeat")
}
ShowSyncHudMsg(id, g_sync_hud1, Message)
static Float:NewAngles[3], Float:OldAngles[3], Float:Origin[3]
pev(id, pev_angles, NewAngles)
pev(g_player_main[id], pev_angles, OldAngles)
NewAngles[2] = OldAngles[2]
pev(g_player_main2[id], pev_origin, Origin)
//get_position(g_player_main2[id], -10.0, 0.0, 0.0, Origin)
set_pev(g_player_main[id], pev_v_angle, NewAngles)
set_pev(g_player_main2[id], pev_angles, NewAngles)
NewAngles[0] -= NewAngles[0] * 2
set_pev(g_player_main[id], pev_angles, NewAngles)
if(get_user_weapon(id) != CSW_KNIFE)
engclient_cmd(id, "weapon_knife")
}
public fw_main_think(ent)
{
if(!pev_valid(ent))
return
if(pev(ent, pev_health) - 1000.0 < 0)
{
if(!g_dead[ent])
minigun_dead(ent)
return
}
if(!g_dead[ent])
entity_set_float(ent,EV_FL_nextthink, halflife_time() + 0.01)
}
public fw_main_takedamage(victim, inflictor, attacker, Float:Damage, damagebits)
{
if(!is_user_alive(attacker) || !is_user_connected(attacker))
return HAM_IGNORED
static Health
Health = pev(victim, pev_health) - 1000
client_print(attacker, print_center, "MW2 Auto-Minigun Health: %i", Health)
return HAM_HANDLED
}
public minigun_dead(ent)
{
g_dead[ent] = 1
static Float:Origin[3]
pev(ent, 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_exp_id) // sprite index
write_byte(30) // scale in 0.1's
write_byte(30) // framerate
write_byte(0) // flags
message_end()
static id
id = g_owner[ent]
if(is_user_connected(id))
{
reset_minigun(id)
client_printcolor(id, "!g[ZE]!y Your MW2 Auto-Minigun has been !tDestroyed!y !!!")
}
Origin[0] = 9999.0
Origin[1] = 9999.0
Origin[2] = 9999.0
set_pev(ent, pev_origin, Origin)
}
public fw_CmdStart(id, uc_handle, seed)
{
if(!is_user_alive(id) || !is_user_connected(id))
return FMRES_IGNORED
if(!g_player_main[id])
return FMRES_IGNORED
static PressButton
PressButton = get_uc(uc_handle, UC_Buttons)
if(g_remoting[id])
{
if(PressButton & IN_ATTACK)
{
static Float:CurTime
CurTime = get_gametime()
if(CurTime - get_pcvar_float(cvar_delay_attack) > g_last_shoot[id])
{
if(!g_preparing[id] && !g_firing[id] && !g_ending[id])
{
g_preparing[id] = 1
g_firing[id] = 0
set_entity_anim(g_player_main[id], 1)
set_task(1.5, "start_attack", id)
emit_sound(g_player_main[id], CHAN_WEAPON, minigun_sound[0], 1.0, ATTN_NORM, 0, PITCH_NORM)
}
if(!g_preparing[id] && g_firing[id] && !g_ending[id] && g_heat[g_player_main[id]] < 100)
{
minigun_shoot(id)
if(CurTime - get_pcvar_float(cvar_delay_attack) > g_check_heat[id])
{
if(g_heat[g_player_main[id]] < 100)
{
g_heat[g_player_main[id]]++
}
g_check_heat[id] = CurTime
}
} else if(g_heat[g_player_main[id]] >= 100) {
if(!g_preparing[id] && g_firing[id] && !g_ending[id] && !g_reloading[g_player_main[id]])
{
g_firing[id] = 0
g_preparing[id] = 0
g_ending[id] = 1
set_entity_anim(g_player_main[id], 3)
emit_sound(g_player_main[id], CHAN_WEAPON, minigun_sound[2], 1.0, ATTN_NORM, 0, PITCH_NORM)
set_task(2.0, "stop_attack", id)
static Message[128]
formatex(Message, sizeof(Message), "!g[ZE]!y System is overheat. Please wait !t%i!y seconds !!!", get_pcvar_float(cvar_reload_time))
client_printcolor(id, Message)
g_reloading[g_player_main[id]] = 1
set_task(get_pcvar_float(cvar_reload_time), "reload_heat", id)
}
}
g_last_shoot[id] = CurTime
}
PressButton &= ~IN_ATTACK
set_uc(uc_handle, UC_Buttons, PressButton)
} else {
if(pev(id, pev_oldbuttons) & IN_ATTACK)
{
if(g_preparing[id] || g_firing[id])
{
g_firing[id] = 0
g_preparing[id] = 0
g_ending[id] = 1
set_entity_anim(g_player_main[id], 3)
emit_sound(g_player_main[id], CHAN_WEAPON, minigun_sound[2], 1.0, ATTN_NORM, 0, PITCH_NORM)
set_task(2.0, "stop_attack", id)
}
}
}
}
if(PressButton & IN_USE)
{
if(g_remoting[id])
{
set_task(1.0, "task_delay2", id)
attach_view(id, id)
g_preparing[id] = 0
g_firing[id] = 0
PressButton &= ~IN_USE
set_uc(uc_handle, UC_Buttons, PressButton)
} else {
if(!task_exists(id+2479))
{
set_task(3.0, "do_remote", id+2479)
message_begin(MSG_ONE_UNRELIABLE, 108, {0,0,0}, id)
write_short(3)
message_end()
}
}
} else {
if(pev(id, pev_oldbuttons) & IN_USE)
{
remove_task(id+2479)
message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("BarTime"), {0,0,0}, id)
write_short(0)
message_end()
}
}
return FMRES_HANDLED
}
public reload_heat(id)
{
if(!pev_valid(g_player_main[id]))
return
g_heat[g_player_main[id]] = 0
g_reloading[g_player_main[id]] = 0
}
public task_delay2(id)
{
g_remoting[id] = 0
}
public start_attack(id)
{
g_preparing[id] = 0
g_firing[id] = 1
}
public stop_attack(id)
{
g_preparing[id] = 0
g_firing[id] = 0
g_ending[id] = 0
}
public minigun_shoot(id)
{
if(!g_remoting[id])
{
return PLUGIN_HANDLED
}
static Float:CurTime
CurTime = get_gametime()
if(CurTime - 0.1 > g_last_firesound[id])
{
PlaySound(id, minigun_sound[1])
emit_sound(g_player_main[id], CHAN_BODY, minigun_sound[1], 1.0, ATTN_NORM, 0, PITCH_NORM)
g_last_firesound[id] = CurTime
}
set_entity_anim(g_player_main[id], 2)
static Float:Origin[3], Float:AimOrigin[3]
get_position(g_player_main[id], 50.0, 0.0, 0.0, Origin)
Origin[2] += 20.0
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(muzzleflash_spr_id) // sprite index
write_byte(5) // scale in 0.1's
write_byte(10) // framerate
write_byte(4) // flags
message_end()
static Float:Punch[3]
Punch[0] = random_float(1.0, 5.0)
Punch[1] = random_float(1.0, 5.0)
Punch[2] = random_float(1.0, 10.0)
set_pev(id, pev_punchangle, Punch)
get_position(g_player_main[id], 70.0, 0.0, 30.0, Origin)
get_position(g_player_main[id], 4000.0, 0.0, 30.0, AimOrigin)
create_tracer(id, Origin, AimOrigin)
get_position(g_player_main[id], 4000.0, -30.0, 50.0, AimOrigin)
create_tracer(id, Origin, AimOrigin)
get_position(g_player_main[id], 4000.0, 30.0, -50.0, AimOrigin)
create_tracer(id, Origin, AimOrigin)
get_position(g_player_main[id], 4000.0, -60.0, -70.0, AimOrigin)
create_tracer(id, Origin, AimOrigin)
get_position(g_player_main[id], 4000.0, 60.0, 70.0, AimOrigin)
create_tracer(id, Origin, AimOrigin)
return PLUGIN_HANDLED
}
// Ham Weapon Deploy Forward
public fw_Item_Deploy_Post(weapon_ent)
{
if(pev_valid(weapon_ent))
return HAM_IGNORED
static id
id = pev(weapon_ent, pev_owner)
if(g_remoting[id])
engclient_cmd(id, "weapon_knife")
return HAM_HANDLED
}
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
vAngle[0] = 0.0
angle_vector(vAngle,ANGLEVECTOR_FORWARD,vForward) //or use EngFunc_AngleVectors
angle_vector(vAngle,ANGLEVECTOR_RIGHT,vRight)
angle_vector(vAngle,ANGLEVECTOR_UP,vUp)
vStart[0] = vOrigin[0] + vForward[0] * forw + vRight[0] * right + vUp[0] * up
vStart[1] = vOrigin[1] + vForward[1] * forw + vRight[1] * right + vUp[1] * up
vStart[2] = vOrigin[2] + vForward[2] * forw + vRight[2] * right + vUp[2] * up
}
stock create_tracer(id, Float:start[3], Float:end[3])
{
new start_[3], end_[3]
FVecIVec(start, start_)
FVecIVec(end, end_)
message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
write_byte(TE_TRACER)
write_coord(start_[0])
write_coord(start_[1])
write_coord(start_[2])
write_coord(end_[0])
write_coord(end_[1])
write_coord(end_[2])
message_end()
static tr, Float:End_Origin[3], Target
engfunc(EngFunc_TraceLine, start, end, DONT_IGNORE_MONSTERS, -1, tr)
get_tr2(tr, TR_vecEndPos, End_Origin)
Target = get_tr2(tr, TR_pHit)
if(is_user_alive(Target) && ze_is_user_zombie(Target))
{
static Float:Origin[3]
pev(Target, pev_origin, Origin)
// Show some blood :)
message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
write_byte(TE_BLOODSPRITE)
write_coord(floatround(Origin[0]))
write_coord(floatround(Origin[1]))
write_coord(floatround(Origin[2]))
write_short(g_bloodspray)
write_short(g_blood)
write_byte(70)
write_byte(random_num(1,2))
message_end()
ExecuteHamB(Ham_TakeDamage, Target, 0, id, random_float(get_pcvar_float(cvar_minigun_dmgrand_start), get_pcvar_float(cvar_minigun_dmgrand_end)), DMG_BULLET)
}
make_bullet(id, End_Origin)
}
stock 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(g_bloodspray)
write_short(g_blood)
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()
}
}
stock set_entity_anim(ent, anim)
{
entity_set_float(ent, EV_FL_animtime, get_gametime())
entity_set_float(ent, EV_FL_framerate, 1.0)
entity_set_int(ent, EV_INT_sequence, anim)
}
stock client_printcolor(const id, const input[], any:...)
{
new iCount = 1, iPlayers[32]
static szMsg[191]
vformat(szMsg, charsmax(szMsg), input, 3)
replace_all(szMsg, 190, "!g", "^4")
replace_all(szMsg, 190, "!y", "^1")
replace_all(szMsg, 190, "!t", "^3")
if(id) iPlayers[0] = id
else get_players(iPlayers, iCount, "ch")
for (new i = 0; i < iCount; i++)
{
if(is_user_connected(iPlayers[i]))
{
message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("SayText"), _, iPlayers[i])
write_byte(iPlayers[i])
write_string(szMsg)
message_end()
}
}
}
Menu: