Upload 2 files

Ham_TakeDamage.txt

@@ -0,0 +1,88 @@
+HamSandWich function:
+PHP Code:
+Ham_TakeDamage 
+Description:
+This function gives us info about the moment a player takes damage, when we use it as a forward. The return of the forward is a boolean, if it is set to 1 then the damage will be done if set to 0 then it will not be done!
+It also can be used to give damage.
+Here I will present how to correctly use this function!
+You should use this function when you want to simulate an attack by a entity!
+
+
+Usage:
+PHP Code:
+#define OFFSET_LAST_HIT_GROUP      75
+#define EXTRAOFFSET_PL_LINUX        5
+
+// plugin_init()
+RegisterHam(Ham_TakeDamage, "player", "fw_takedamage")
+
+public fw_takedamage(victim, inflictor, attacker, Float:damage, bits)
+{
+    // Victim is the entity that has been taken damage
+    // Inflictor is the entity that directly gived damage
+    // Attacker is the owner of the inflictor
+    // If Attacker == Inflictor that means that the damage was inflicted by a player (such as gun shot/knife stab)
+    // Damage the damage
+    // Bits the type of damage represented in Bitsums
+    
+    // For grenade damage (In CS) the bits is equal to (1<<24)
+    // Basically for hooking the he grenade damage is to put this condition
+    // if (bits & (1<<24))
+    
+    // For bullet/knife damage (In CS) the bits are equal to (DMG_BULLET | DMG_NEVERGIB)
+    // Basically for hooking the shot damage is to put this condition
+    // if (bits & (DMG_BULLET | DMG_NEVERGIB))
+
+    // Now the most subtile element is that we can get the last hitgroup where the damage was dealt
+
+    new hitgroup = get_pdata_int(victim, OFFSET_LAST_HIT_GROUP, EXTRAOFFSET_PL_LINUX)
+} 
+How to properly execute damage? This is the way to do it!
+PHP Code:
+#define OFFSET_LAST_HIT_GROUP      75
+#define EXTRAOFFSET_PL_LINUX        5
+
+new const Float:hitgroup_multi[] =
+{
+    1.0,  // HIT_GENERIC
+    4.0,  // HIT_HEAD
+    1.0,  // HIT_CHEST
+    1.25, // HIT_STOMACH
+    1.0,  // HIT_LEFTARM
+    1.0,  // HIT_RIGHTARM
+    0.75, // HIT_LEFTLEG
+    0.75  // HIT_RIGHTLEG
+    0.0   // HIT_SHIELD
+}
+
+stock Ham_ExecDamage(victim, inflictor, attacker, damage, hitgroup, bits)
+{
+    set_pdata_int(victim, OFFSET_LAST_HIT_GROUP, hitgroup, EXTRAOFFSET_PL_LINUX)
+    ExecuteHam(Ham_TakeDamage, victim, inflictor, attacker, damage*hitgroup_multi[hitgroup], bits)
+}
+
+stock Ham_ExecDamageB(victim, inflictor, attacker, damage, hitgroup, bits)
+{
+    set_pdata_int(victim, OFFSET_LAST_HIT_GROUP, hitgroup, EXTRAOFFSET_PL_LINUX)
+    ExecuteHamB(Ham_TakeDamage, victim, inflictor, attacker, damage*hitgroup_multi[hitgroup], bits)
+}
+
+stock HamRadiusDamage(ent, Float:radius, Float:damage, bits)
+{
+    new target = -1, Float:origin[3]
+    pev(ent, pev_origin, origin)
+    
+    while(( target = find_ent_in_sphere(target, origin, radius) ))
+    {
+        static Float:o[3]
+        pev(target, pev_origin, o)
+        
+        xs_vec_sub(origin, o, o)
+        
+        // Recheck if the entity is in radius
+        if (xs_vec_len(o) > radius)
+            continue
+        
+        Ham_ExecDamageB(target, ent, pev(ent, pev_owner), damage * (xs_vec_len(o) / radius), HIT_GENERIC, bits)
+    }
+} 

Ham_TraceAttack.txt

@@ -0,0 +1,129 @@
+HamSandWich function:
+PHP Code:
+Ham_TraceAttack 
+Description:
+Forward: This function is called when an entity is shot by another player (weapon, not grenade.)
+Function: This function simulates a weapon attack on an entity.
+You should use this function when you want to simulate an attack by a weapon from a player (like a gunshot!)
+
+Parameters:
+(ent, attacker, float:damage, Float:direction[3], trace, bits)
+- ent is the entity that has been shot
+- attacker is the entity that shoot the victim
+- damage - this is the damage done by the shot but it does not have the hitgroup multiplication done (that is done before TakeDamage Call)
+- direction - this parameter has a very important roll, it is a normalized vector that shows the direction of the bullets path
+- trace - the trace handle that offers lots of useful information
+- bits - the damage bits
+
+Forward usage:
+PHP Code:
+#define SHOT_DISTANCE_POSSIBLE 2048.0
+
+// plugin_init()
+Register_Ham(Ham_TraceAttack, "func_breakable", "fw_traceatt_break")
+
+public fw_traceatt_break(ent, attacker, float:damage, Float:direction[3], trace, bits)
+{
+    new Float:start[3], end[3], fraction, multi
+    get_tr2(trace, TR_vecEndPos, end)
+    get_tr2(trace, TR_flFraction, fraction)
+    
+    multi = fraction * SHOT_DISTANCE_POSSIBLE
+    
+    xs_vec_mul_scalar(direction, multi, start)
+    
+    // This is how to correctly get the start origin!
+    xs_vec_add(start, end, start)
+    
+} 
+Function true usage:
+PHP Code:
+#define SHOT_DISTANCE_POSSIBLE 2048.0
+
+public Ham_Shoot(attacker, damage, bits, bool:can_penetrate)
+{
+    new Float:angles[3], Float:start[3], Float:end[3], Float:direction[3], Float:fakeend[3]
+    
+    // Turn the angles in a true vector
+    pev(attacker, pev_angles, angles)
+    angle_vector(angles, ANGLEVECTOR_FORWARD, direction)
+    
+    // We make this as a normal shot!
+    xs_vec_mul_scalar(direction, SHOT_DISTANCE_POSSIBLE, fakeend)
+    
+    // Start origin
+    pev(attacker, pev_origin, start)
+    pev(attacker, pev_view_ofs, end)
+    xs_vec_add(end, start, start)
+    
+    // Obtain the end shot origin
+    xs_vec_add(start, fakeend, end)
+    
+    // From now this is how these variables will be used
+    // origin - start place (will remain constant!)
+    // end - end place (will remain constant!)
+    // angles - no use
+    // fakeend - dynamic start origin
+    // direction - will be used in the forwards (will remain constant!)
+    
+    new ptr = create_tr2()
+    
+    // Trace to the first entity
+    engfunc(EngFunc_TraceLine, start, end, DONT_IGNORE_MONSTERS, attacker, ptr)
+    
+    new Float:fraction, hit = get_tr2(ptr, TR_pHit)
+    get_tr2(ptr, TR_flFraction, fraction)
+    
+    // Update the fake start origin
+    get_tr2(ptr, TR_vecEndPos, fakeend)
+    
+    // This means that we hited sky!
+    if (fraction != 1.0 && engfunc(EngFunc_PointContents, fakeend) == CONTENTS_SKY && hit == -1)
+    {
+        // Prepare the trace handle
+        set_tr2(ptr, TR_pHit, 0)
+        
+        // Bullet trace!
+        ExecuteHamB(Ham_TraceAttack, 0, attacker, damage, direction, ptr, DMG_NEVERGIB | DMG_BULLET)
+        
+        free_tr2(ptr)
+        return -1
+    }
+    
+    if (hit == -1)
+    {
+        hit = 0
+        set_tr2(ptr, TR_pHit, hit)
+    }
+    
+    ExecuteHamB(Ham_TraceAttack, hit, attacker, damage, direction, ptr, DMG_NEVERGIB | DMG_BULLET)
+    
+    if (!can_penetrate)
+    {
+        free_tr2(ptr)
+        return 1
+    }
+    
+    // Trace to the next entity
+    engfunc(EngFunc_TraceLine, fakeend, end, DONT_IGNORE_MONSTERS, hit, ptr)
+    
+    hit = get_tr2(ptr, TR_pHit)
+    get_tr2(ptr, TR_flFraction, fraction)
+    
+    // Update the fake start origin
+    get_tr2(ptr, TR_vecEndPos, fakeend)
+    
+    if (hit == -1)
+    {
+        hit = 0
+        set_tr2(ptr, TR_pHit, hit)
+    }
+    
+    set_tr2(ptr, TR_flFraction, get_distance_f(start, fakeend) / SHOT_DISTANCE_POSSIBLE)
+    
+    ExecuteHamB(Ham_TraceAttack, hit, attacker, damage, direction, ptr, DMG_NEVERGIB | DMG_BULLET)
+    
+        
+    free_tr2(ptr)
+    return 1
+}