|
Senior Member
|
07-18-2018
, 22:43
Re: Add an exception to Weapon Physics plugin
|
#2
|
Quote:
Originally Posted by sekac
Can someone make it so if you shoot the C4, nothing happens? Also if something explodes near the C4 it shouldn't get affected by it either.
PHP Code:
#include <amxmodx>
#include <amxmisc>
#include <fakemeta>
#include <xs>
#if AMXX_VERSION_NUM < 180
#define HAM_IGNORED 1
#define HAM_HANDLED 2
#define Ham_Spawn Ham:0
#define Ham_TraceAttack Ham:8
#define Ham_TakeDamage Ham:9
#define Ham_Touch Ham:42
native HamHook:RegisterHam(Ham:function, const EntityClass[], const Callback[], Post=0)
native SetHamParamFloat(which, Float:value)
native DisableHamForward(HamHook:fwd)
native EnableHamForward(HamHook:fwd)
#else
#include <hamsandwich>
#endif
#define PLUGIN "Weapon Physics"
#define VERSION "2.1"
#define AUTHOR "Nomexous"
/*
Version 1.0
- Initial release.
Version 2.0
- Added. Ability to compile on amxmodx.org's online compiler.
- Added. Menu for enabling/disabling the plugin.
- Added. Ability for weapons to be moved when shot.
- Added. Sparks when weapon hits a wall while moving above a certain speed.
- Added. Hooking of custom classes.
- Fixed. Looping bounce sound when touching dead bodies in DoD.
Version 2.1
- Fixed. Custom item spawn debug message removed.
- Fixed. Non-visible entities no longer react to explosions (e.g. armoury_entities that have been picked up).
- Changed. Shooting of weapons now off by default.
- Added. Menu option for weapon clatter.
*/
#define BOUNCE "items/weapondrop1.wav"
#define RIC "debris/metal6.wav"
// Persistant items that don't disappear when picked up.
new const persistant[][] = { "armoury_entity" }
// Dropped items.
new const classes[][] = { "weaponbox", "item_thighpack", "weapon_shield" }
// The base is what the entity is created as, e.g. ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target")).
// Put all of them here. Make sure that this custom entity can take damage, otherwise it won't work!
new const custom_base[][] = { "info_target" }
// What the entity's classname is changed to after it's created, e.g. set_pev(ent, pev_classname, "fakeweapon")
new const custom_classname[][] = { "fakeweapon" }
#define HOOK_COUNT 4 * (sizeof persistant + sizeof classes + sizeof custom_base)
new HamHook:hamhooks[HOOK_COUNT]
new traceline_fid = 0
new custom_count, shootweapons_pcvar, physics_pcvar, clatter_sound_pcvar
new Float:multiplier = 15.0
public plugin_precache()
{
custom_count = sizeof custom_classname
precache_sound(BOUNCE)
precache_sound(RIC)
physics_pcvar = register_cvar("weapon_physics_enabled", "1")
shootweapons_pcvar = register_cvar("weapon_physics_shoot_weapons", "0")
clatter_sound_pcvar = register_cvar("weapon_physics_weapons_clatter", "1")
do_ham_hooks()
}
public do_ham_hooks()
{
new count = 0
for (new i; i < sizeof persistant; i++)
{
hamhooks[count++] = RegisterHam(Ham_Spawn, persistant[i], "spawn_persistant_item", 1)
hamhooks[count++] = RegisterHam(Ham_Touch, persistant[i], "touch_item")
hamhooks[count++] = RegisterHam(Ham_TakeDamage, persistant[i], "damage_item")
hamhooks[count++] = RegisterHam(Ham_TraceAttack, persistant[i], "shoot_item")
}
for (new x; x < sizeof classes; x++)
{
hamhooks[count++] = RegisterHam(Ham_Spawn, classes[x], "spawn_item", 1)
hamhooks[count++] = RegisterHam(Ham_Touch, classes[x], "touch_item")
hamhooks[count++] = RegisterHam(Ham_TakeDamage, classes[x], "damage_item")
hamhooks[count++] = RegisterHam(Ham_TraceAttack, classes[x], "shoot_item")
}
for (new n; n < sizeof custom_base; n++)
{
hamhooks[count++] = RegisterHam(Ham_Spawn, custom_base[n], "spawn_custom_item", 1)
hamhooks[count++] = RegisterHam(Ham_Touch, custom_base[n], "touch_custom_item")
hamhooks[count++] = RegisterHam(Ham_TakeDamage, custom_base[n], "damage_custom_item")
hamhooks[count++] = RegisterHam(Ham_TraceAttack, custom_base[n], "shoot_item")
}
}
public update_hooks_and_forwards()
{
if (get_pcvar_num(physics_pcvar))
{
for (new i; i < sizeof hamhooks; i++)
{
EnableHamForward(hamhooks[i])
}
}
else
{
for (new i; i < sizeof hamhooks; i++)
{
DisableHamForward(hamhooks[i])
}
}
if (get_pcvar_num(shootweapons_pcvar) && get_pcvar_num(physics_pcvar) && !traceline_fid)
{
traceline_fid = register_forward(FM_TraceLine, "fw_traceline")
}
if ((!get_pcvar_num(shootweapons_pcvar) || !get_pcvar_num(physics_pcvar)) && traceline_fid)
{
unregister_forward(FM_TraceLine, traceline_fid)
traceline_fid = 0
}
}
public plugin_init()
{
register_plugin(PLUGIN, VERSION, AUTHOR)
register_event("HLTV", "restart", "a", "1=0", "2=0")
update_hooks_and_forwards()
register_clcmd("amx_weapon_physics_menu", "conjure_menu", ADMIN_SLAY, "Shows weapon physics menu.")
// This multiplier controls how fast the grenade will propel items. Originally, I wanted it to just be proportional to
// the damage, but CZ and CS has different grenade strengths. Add your own here.
new mods[][] = { "cstrike", "czero" }
new Float:mult[] = { 22.0, 17.0 }
new modname[10]
get_modname(modname, 9)
for (new i; i < sizeof mods; i++)
{
if (equal(modname, mods[i]))
{
multiplier = mult[i]
}
}
}
public conjure_menu(id, level, cid)
{
if (cmd_access(id, level, cid, 1))
{
wpm(id)
}
return PLUGIN_HANDLED
}
public wpm(id)
{
static wpmenu
wpmenu = menu_create("Weapon Physics", "menu_h")
get_pcvar_num(physics_pcvar) ? menu_additem(wpmenu, "Weapon physics: \yEnabled", "1") : menu_additem(wpmenu, "Weapon phyics: \rDisabled", "1")
get_pcvar_num(shootweapons_pcvar) ? menu_additem(wpmenu, "Shoot weapons: \yEnabled", "2") : menu_additem(wpmenu, "Shoot weapons: \rDisabled", "2")
get_pcvar_num(clatter_sound_pcvar) ? menu_additem(wpmenu, "Weapons clatter: \yEnabled", "3") : menu_additem(wpmenu, "Weapons clatter: \rDisabled", "3")
menu_display(id, wpmenu, 0)
return PLUGIN_HANDLED
}
public menu_h(id, menu, item)
{
switch (item)
{
case 0:
{
set_pcvar_num(physics_pcvar, !get_pcvar_num(physics_pcvar))
}
case 1:
{
set_pcvar_num(shootweapons_pcvar, !get_pcvar_num(shootweapons_pcvar))
}
case 2:
{
set_pcvar_num(clatter_sound_pcvar, !get_pcvar_num(clatter_sound_pcvar))
}
default:
{
update_hooks_and_forwards()
menu_destroy(menu)
return PLUGIN_HANDLED
}
}
menu_destroy(menu)
wpm(id)
return PLUGIN_HANDLED
}
public restart()
{
for (new i; i < sizeof persistant; i++)
{
new o
while ((o = engfunc(EngFunc_FindEntityByString, o, "classname", persistant[i])))
{
static Float:origin[3], Float:angles[3]
pev(o, pev_vuser1, origin)
pev(o, pev_vuser2, angles)
set_pev(o, pev_angles, angles)
set_pev(o, pev_avelocity, Float:{0.0, 0.0, 0.0})
engfunc(EngFunc_SetOrigin, o, origin)
engfunc(EngFunc_DropToFloor, o)
}
}
}
public spawn_item(ent)
{
set_pev(ent, pev_movetype, MOVETYPE_BOUNCE)
set_pev(ent, pev_takedamage, DAMAGE_YES)
set_pev(ent, pev_health, 100.0)
return HAM_IGNORED
}
public spawn_persistant_item(ent)
{
set_pev(ent, pev_movetype, MOVETYPE_BOUNCE)
set_pev(ent, pev_takedamage, DAMAGE_YES)
set_pev(ent, pev_health, 100.0)
new Float:origin[3], Float:angles[3]
pev(ent, pev_origin, origin)
pev(ent, pev_angles, angles)
set_pev(ent, pev_vuser1, origin)
set_pev(ent, pev_vuser2, angles)
return HAM_IGNORED
}
public spawn_custom_item(ent)
{
if (is_custom_ent(ent))
{
return spawn_item(ent)
}
return HAM_IGNORED
}
public damage_item(ent, inflictor, attacker, Float:damage, damagebits)
{
if (pev(ent, pev_effects) & EF_NODRAW) return HAM_IGNORED
static Float:ent_v[3], Float:ent_o[3], Float:inflictor_o[3], Float:temp[3]
pev(ent, pev_velocity, ent_v)
pev(ent, pev_origin, ent_o)
pev(inflictor, pev_origin, inflictor_o)
xs_vec_sub(ent_o, inflictor_o, temp)
xs_vec_normalize(temp, temp)
xs_vec_mul_scalar(temp, damage, temp)
xs_vec_mul_scalar(temp, multiplier, temp)
xs_vec_add(ent_v, temp, ent_v)
set_pev(ent, pev_velocity, ent_v)
// Set a random yaw. I would've set random pitch and roll, but then the weapons don't land flat, even with my Lie Flat plugin.
static Float:av[3]
//av[0] = random_float(-1000.0, 1000.0)
av[1] = random_float(-1000.0, 1000.0)
//av[2] = random_float(-1000.0, 1000.0)
set_pev(ent, pev_avelocity, av)
SetHamParamFloat(4, 0.0)
return HAM_HANDLED
}
public damage_custom_item(ent, inflictor, attacker, Float:damage, damagebits)
{
if (is_custom_ent(ent))
{
static Float:ent_v[3], Float:ent_o[3], Float:inflictor_o[3], Float:temp[3]
pev(ent, pev_velocity, ent_v)
pev(ent, pev_origin, ent_o)
pev(inflictor, pev_origin, inflictor_o)
xs_vec_sub(ent_o, inflictor_o, temp)
xs_vec_normalize(temp, temp)
xs_vec_mul_scalar(temp, damage, temp)
xs_vec_mul_scalar(temp, multiplier, temp)
xs_vec_add(ent_v, temp, ent_v)
set_pev(ent, pev_velocity, ent_v)
// Set a random yaw. I would've set random pitch and roll, but then the weapons don't land flat, even with my Lie Flat plugin.
static Float:av[3]
av[1] = random_float(-1000.0, 1000.0)
set_pev(ent, pev_avelocity, av)
SetHamParamFloat(4, 0.0)
return HAM_HANDLED
}
return HAM_IGNORED
}
public touch_item(ent, touched)
{
if (pev(touched, pev_solid) < SOLID_BBOX) return HAM_IGNORED
if (1 <= touched <= 32) return HAM_IGNORED // Prevents bugginess when someone drops a gun (or in DoD, when a gun gets stuck inside a dead body).
static Float:v[3]
pev(ent, pev_velocity, v)
if (xs_vec_len(v) > 700.0)
{
static Float:origin[3]
pev(ent, pev_origin, origin)
origin[0] += random_float(-10.0, 10.0)
origin[1] += random_float(-10.0, 10.0)
origin[2] += random_float(-10.0, 10.0)
draw_spark(origin)
}
xs_vec_mul_scalar(v, 0.4, v)
set_pev(ent, pev_velocity, v)
if (get_pcvar_num(clatter_sound_pcvar))
{
engfunc(EngFunc_EmitSound, ent, CHAN_WEAPON, BOUNCE, 0.25, ATTN_STATIC, 0, PITCH_NORM)
}
return HAM_IGNORED
}
public touch_custom_item(ent, touched)
{
if (is_custom_ent(ent))
{
return touch_item(ent, touched)
}
return HAM_IGNORED
}
public shoot_item(ent, attacker, Float:damage, Float:direction[3], trace, damagebits)
{
static Float:endpoint[3]
get_tr2(trace, TR_vecEndPos, endpoint)
draw_spark(endpoint)
static Float:velocity[3]
pev(ent, pev_velocity, velocity)
xs_vec_mul_scalar(direction, damage, direction)
xs_vec_mul_scalar(direction, multiplier, direction)
xs_vec_add(direction, velocity, velocity)
set_pev(ent, pev_velocity, velocity)
engfunc(EngFunc_EmitSound, ent, CHAN_ITEM, RIC, 0.5, ATTN_STATIC, 0, PITCH_NORM)
return HAM_IGNORED
}
public fw_traceline(Float:start[3], Float:end[3], conditions, id, trace)
{
// Spectators don't need to run this.
if (!is_user_alive(id)) return FMRES_IGNORED
// If we hit a player, don't bother searching for an item nearby.
if (is_user_alive(get_tr2(trace, TR_pHit))) return FMRES_IGNORED
static Float:endpt[3], tr = 0, i
get_tr2(trace, TR_vecEndPos, endpt)
i = 0
while ((i = engfunc(EngFunc_FindEntityInSphere, i, endpt, 20.0)))
{
if (is_shootable_ent(i))
{
engfunc(EngFunc_TraceModel, start, end, HULL_POINT, i, tr)
if (pev_valid(get_tr2(tr, TR_pHit)))
{
get_tr2(tr, TR_vecEndPos, endpt)
set_tr2(trace, TR_vecEndPos, endpt)
set_tr2(trace, TR_pHit, i)
return FMRES_IGNORED
}
}
}
return FMRES_IGNORED
}
public is_shootable_ent(ent)
{
static classname[32]
pev(ent, pev_classname, classname, 31)
for (new i; i < sizeof classes; i++)
{
if (equal(classname, classes[i]))
{
return true
}
}
for (new i; i < sizeof persistant; i++)
{
if (equal(classname, persistant[i]))
{
return true
}
}
for (new i; i < sizeof custom_classname; i++)
{
if (equal(classname, custom_classname[i]))
{
return true
}
}
return false
}
public is_custom_ent(ent)
{
static classname[40]
pev(ent, pev_classname, classname, 39)
for (new i; i < custom_count; i++)
{
if (equal(classname, custom_classname[i]))
{
return true
}
}
return false
}
stock draw_spark(Float:origin[3])
{
message_begin(MSG_ALL, SVC_TEMPENTITY)
write_byte(TE_SPARKS)
engfunc(EngFunc_WriteCoord, origin[0])
engfunc(EngFunc_WriteCoord, origin[1])
engfunc(EngFunc_WriteCoord, origin[2])
message_end()
}
|
EDIT AND TEST 
PHP Code:
public shoot_item(ent, attacker, Float:damage, Float:direction[3], trace, damagebits)
{
new Model[ 32 ];
pev( ent, pev_model, Model, 31 );
if( containi( Model, "w_backpack" ) != -1)
return HAM_SUPERCEDE
static Float:endpoint[3]
get_tr2(trace, TR_vecEndPos, endpoint)
draw_spark(endpoint)
static Float:velocity[3]
pev(ent, pev_velocity, velocity)
xs_vec_mul_scalar(direction, damage, direction)
xs_vec_mul_scalar(direction, multiplier, direction)
xs_vec_add(direction, velocity, velocity)
set_pev(ent, pev_velocity, velocity)
engfunc(EngFunc_EmitSound, ent, CHAN_ITEM, RIC, 0.5, ATTN_STATIC, 0, PITCH_NORM)
return HAM_IGNORED
}
|
|
Linear Mode
