amxmodx/dlls/engine/amxmod_compat.cpp

454 lines
13 KiB
C++
Raw Normal View History

#include "engine.h"
#include <cbase.h>
static cvar_t *sv_knockback1 = NULL;
static cvar_t *sv_knockback2 = NULL;
static cvar_t *sv_friendlyfire = NULL;
static bool g_ff_check = false;
static bool g_kb1_check = false;
static bool g_kb2_check = false;
static int gmsgDamage = 0;
static int gmsgDeathMsg = 0;
static int gmsgScoreInfo = 0;
//From VexdUM (AMX Mod 2006.2)
//This is not exposed, and is only provided as a compatibility helper.
BOOL is_breakable(edict_t* pBreak)
{
if (FStrEq("func_breakable", STRING(pBreak->v.classname))
|| FStrEq("func_pushable", STRING(pBreak->v.classname))
&& pBreak->v.spawnflags & SF_PUSH_BREAKABLE)
{
return true;
}
return false;
}
//From VexdUM (AMX Mod 2006.2)
//This is not exposed, and is only provided as a compatibility helper.
BOOL is_monster(edict_t* pMonster)
{
if(pMonster->v.flags & FL_MONSTER)
{
return true;
}
return false;
}
//From VexdUM (AMX Mod 2006.2)
// Damage Monsters
void hurt_monster(edict_t* pMonster, float dmg, int bit, const float *origin)
{
int mdmg = (int)pMonster->v.health;
pMonster->v.health -= dmg;
// No need to create a trigger_hurt unless we are going to kill the monster ;)
if((int)pMonster->v.health < 1)
{
int hurt = MAKE_STRING("trigger_hurt");
char hbit[16];
char horigin[16];
snprintf(hbit, 15, "%i", bit);
snprintf(horigin, 15, "%f %f %f", origin[0], origin[1], origin[2]);
edict_t* pEntity = CREATE_NAMED_ENTITY(hurt);
KeyValueData pkvd1;
pkvd1.szClassName = "trigger_hurt";
pkvd1.szKeyName = "dmg";
pkvd1.szValue = "1.0";
pkvd1.fHandled = FALSE;
MDLL_KeyValue(pEntity, &pkvd1);
KeyValueData pkvd2;
pkvd2.szClassName = "trigger_hurt";
pkvd2.szKeyName = "damagetype";
pkvd2.szValue = hbit;
pkvd2.fHandled = FALSE;
MDLL_KeyValue(pEntity, &pkvd2);
KeyValueData pkvd3;
pkvd3.szClassName = "trigger_hurt";
pkvd3.szKeyName = "origin";
pkvd3.szValue = horigin;
pkvd3.fHandled = FALSE;
MDLL_KeyValue(pEntity, &pkvd3);
MDLL_Spawn(pEntity);
MDLL_Touch(pEntity, pMonster);
REMOVE_ENTITY(pEntity);
}
mdmg -= (int)pMonster->v.health;
//~dvander - Note, not porting the forward until this function is known to be truly wrapped
//g_forwards.executeForward(FF_MonsterHurt, ENTINDEX(pMonster), ENTINDEX(pMonster->v.dmg_inflictor), mdmg);
}
//From VexdUM (AMX Mod 2006.2)
//This appears to be from the HLSDK CBasePlayer::TakeDamage() function.
//This is not exposed, and is only provided as a compatibility helper.
float ArmorDamage(edict_t* pVictim, float dmg, int bit)
{
float flRatio = 0.2;
float flBonus = 0.5;
if(bit & DMG_BLAST)
{
// blasts damage armor more.
flBonus *= 2;
}
if(pVictim->v.armorvalue && !(bit & (DMG_FALL | DMG_DROWN)))
{
// armor doesn't protect against fall or drown damage!
float flNew = dmg * flRatio;
float flArmor = (dmg - flNew) * flBonus;
// Does this use more armor than we have?
if(flArmor > pVictim->v.armorvalue)
{
flArmor = pVictim->v.armorvalue;
flArmor *= (1/flBonus);
flNew = dmg - flArmor;
pVictim->v.armorvalue = 0;
} else {
pVictim->v.armorvalue -= flArmor;
}
dmg = flNew;
}
// Lets knock the view about abit
pVictim->v.punchangle.x = -4;
return dmg;
}
// Death emulation
//This is not exposed, and is only provided as a compatibility helper.
void Death(edict_t* pVictim, edict_t* pKiller, const char* weapon, int hs)
{
if (!gmsgDeathMsg)
{
gmsgDeathMsg = GET_USER_MSG_ID(PLID, "DeathMsg", NULL);
}
if (!gmsgScoreInfo)
{
gmsgScoreInfo = GET_USER_MSG_ID(PLID, "ScoreInfo", NULL);
}
// Make sure an entity is allowed to take damage
if(pVictim->v.takedamage > DAMAGE_NO)
{
// Breakable Check
if(is_breakable(pVictim))
{
MDLL_Use(pVictim, pKiller);
}
// Monster Check
if (is_monster(pVictim))
{
pVictim->v.dmg_inflictor = pKiller;
float dmg = pVictim->v.health;
int bit = DMG_BULLET;
const float *origin = pVictim->v.origin;
hurt_monster(pVictim, dmg, bit, origin);
}
// Player Check
if (pVictim->v.flags & (FL_CLIENT | FL_FAKECLIENT))
{
pVictim->v.dmg_inflictor = pKiller;
edict_t* inflictor = pKiller->v.owner;
int inflictorId = FNullEnt(inflictor) ? ENTINDEX(inflictor) : 0;
// See if it is a player attacking with a default weapon
if (pKiller->v.flags & (FL_CLIENT | FL_FAKECLIENT))
{
// We only modify the weapon if it = 0, otherwise its been specified
if(strcmp(weapon, "") == 0)
{
char view_weapon[64];
// Get the name from the view model
weapon = STRING(pKiller->v.viewmodel);
// Strip out the beginning of the viewmodel (models/v_)
if(strncmp(weapon, "models/v_", 9) == 0)
{
strcpy(view_weapon, weapon + 9);
}
// Strip out the end of viewmodel (.mdl)
view_weapon[strlen(view_weapon) - 4] = '\0';
weapon = view_weapon;
}
// See if its an entity attacking, if so lets find its owner
} else if (inflictorId >= 1 && inflictorId <= gpGlobals->maxClients) {
// We only modify the weapon if it = 0, otherwise its been specified
if(strcmp(weapon, "") == 0)
{
weapon = STRING(pKiller->v.classname);
// Strip out the default part of weapon name (HLSDK)
if(strncmp(weapon, "weapon_", 7) == 0)
{
weapon += 7;
} else if(strncmp(weapon, "monster_", 8) == 0) {
weapon += 8;
} else if(strncmp(weapon, "func_", 5) == 0) {
weapon += 5;
}
}
// Check to see if the victim is the owner
if(inflictor == pVictim)
{
pKiller = pVictim;
} else {
pKiller = inflictor;
}
}
// Send the Death Event
int killerId = ENTINDEX(pKiller);
int victimId = ENTINDEX(pVictim);
MESSAGE_BEGIN( MSG_ALL, gmsgDeathMsg );
WRITE_BYTE( killerId > gpGlobals->maxClients ? 0 : killerId );
WRITE_BYTE( victimId );
WRITE_BYTE( hs );
WRITE_STRING( weapon );
MESSAGE_END();
// Log this kill
if(pVictim == pKiller)
{
// killed self
UTIL_LogPrintf("\"%s<%i><%s><%s>\" killed self with \"%s\"\n",
STRING( pVictim->v.netname ),
GETPLAYERUSERID( pVictim ),
GETPLAYERAUTHID( pVictim ),
MF_GetPlayerTeam(victimId),
weapon );
// Killed by another player
} else if(pKiller->v.flags & (FL_CLIENT | FL_FAKECLIENT)) {
UTIL_LogPrintf("\"%s<%i><%s><%s>\" killed \"%s<%i><%s><%s>\" with \"%s\"\n",
STRING( pKiller->v.netname ),
GETPLAYERUSERID( pKiller ),
GETPLAYERAUTHID( pKiller ),
MF_GetPlayerTeam(killerId),
STRING( pVictim->v.netname ),
GETPLAYERUSERID( pVictim ),
GETPLAYERAUTHID( pVictim ),
MF_GetPlayerTeam(victimId),
weapon);
int killerTeam = MF_GetPlayerTeamID(killerId);
int victimTeam = MF_GetPlayerTeamID(victimId);
if (killerTeam != victimTeam)
{
// Give Killer credit for this kill
pKiller->v.frags += 1;
} else {
pKiller->v.frags -= 1;
}
// Update the scoreboard for the killer
if (gmsgScoreInfo)
{
MESSAGE_BEGIN(MSG_ALL, gmsgScoreInfo);
WRITE_BYTE( killerId );
WRITE_SHORT( (int)pKiller->v.frags );
WRITE_SHORT( MF_GetPlayerDeaths(killerId) );
WRITE_SHORT( 0 );
WRITE_SHORT( MF_GetPlayerTeamID(killerId) );
MESSAGE_END();
}
// Give Victim back 1 point since they didn't kill themselves
pVictim->v.frags += 1;
}
// Killed by something else?
else {
UTIL_LogPrintf( "\"%s<%i><%s><%s>\" killed by \"%s\"\n",
STRING( pVictim->v.netname ),
GETPLAYERUSERID( pVictim ),
GETPLAYERAUTHID( pVictim ),
MF_GetPlayerTeam(victimId),
weapon );
// Give Victim back 1 point since they didn't commit suicide
pVictim->v.frags += 1;
}
#if 0
//still a todo on this one
gInfo.logBlock = true;
#endif
int opt = BLOCK_ONCE;
MF_MessageBlock(MSGBLOCK_SET, gmsgDeathMsg, &opt);
// Kill the client, since the relevent logging blocks are in place
MDLL_ClientKill(pVictim);
// Restore the old message type
MF_MessageBlock(MSGBLOCK_SET, gmsgDeathMsg, &opt);
// Show the Victim the killing location
pVictim->v.iuser3 = (killerId > gpGlobals->maxClients) ? 0 : killerId;
}
}
}
// Damage emulation
// From VexdUM (AMX Mod 2006.2)
//This is not exposed, and is only provided as a compatibility helper.
void Damage(edict_t *pVictim,
edict_t *pAttacker,
const float *origin,
float dmg,
int bit,
const char *weapon,
int hs)
{
if (!g_ff_check && !sv_friendlyfire)
{
sv_friendlyfire = CVAR_GET_POINTER("sv_friendlyfire");
g_ff_check = true;
}
if (!gmsgDamage)
{
gmsgDamage = GET_USER_MSG_ID(PLID, "Damage", NULL);
}
// Make sure an entity is allowed to take damage
if(pVictim->v.takedamage > DAMAGE_NO)
{
// Breakable Check
if(is_breakable(pVictim) && (int)dmg > 0)
{
MDLL_Use(pVictim, pAttacker);
}
// Monster Check
if(is_monster(pVictim) && (int)dmg > 0)
{
pVictim->v.dmg_inflictor = pAttacker;
hurt_monster(pVictim, dmg, bit, origin);
}
// Player Check
if(pVictim->v.flags & (FL_CLIENT | FL_FAKECLIENT))
{
int AttackerId = ENTINDEX(pAttacker);
int AttackerOwnerId = ENTINDEX(pAttacker->v.owner);
int VictimId = ENTINDEX(pVictim);
int vTeam = MF_GetPlayerTeamID(VictimId);
int aTeam = 0;
if (AttackerId >= 1 && AttackerId <= gpGlobals->maxClients)
{
aTeam = MF_GetPlayerTeamID(AttackerId);
} else if (AttackerOwnerId >= 1 && AttackerOwnerId <= gpGlobals->maxClients) {
aTeam = MF_GetPlayerTeamID(AttackerOwnerId);
}
if((sv_friendlyfire && (int)sv_friendlyfire->value) || (vTeam != aTeam))
{
// Recalculate the damage since we might have armor
dmg = ArmorDamage(pVictim, dmg, bit);
// Only allow damage to process if more than 0.5
if((int)dmg > 0)
{
// Setting to externally flag who last attacked the Victim, pretty neat huh?
pVictim->v.dmg_inflictor = pAttacker;
pVictim->v.dmg_take += dmg;
// Register the Damage Event
MESSAGE_BEGIN( MSG_ONE, gmsgDamage, NULL, pVictim );
WRITE_BYTE( (int)pVictim->v.dmg_save );
WRITE_BYTE( (int)pVictim->v.dmg_take );
WRITE_LONG( bit );
WRITE_COORD( origin[0] );
WRITE_COORD( origin[1] );
WRITE_COORD( origin[2] );
MESSAGE_END();
if((int)dmg >= (int)pVictim->v.health)
{
// Kill the victim
pVictim->v.health = 0.0;
// Send info to Death system
Death(pVictim, pAttacker, weapon, hs);
}else {
// Take health away from victim
pVictim->v.health -= dmg;
}
}
}
}
}
}
// Radius Damage emulation -
// From VexdUM (AMX Mod 2006.2)
//This is not exposed, and is only provided as a compatibility helper.
void RadiusDamage_AMXMod_Base(edict_t *pAttacker,
float dmg,
Vector vecSrc,
float rad,
int bit,
const char *weapon,
int hs)
{
edict_t *pTarget = NULL;
TraceResult tr;
float falloff;
Vector vecSpot;
Vector vecSee;
if (!g_kb1_check && !sv_knockback1)
{
sv_knockback1 = CVAR_GET_POINTER("sv_knockback1");
g_kb1_check = true;
}
if (!g_kb2_check && !sv_knockback2)
{
sv_knockback2 = CVAR_GET_POINTER("sv_knockback2");
g_kb2_check = true;
}
if(rad > 0.0)
{
falloff = dmg / rad;
} else {
falloff = 1.0;
}
vecSrc.z += 1; // In case grenade is lying on the ground
int hitId;
int targetId;
while ((pTarget = UTIL_FindEntityInSphere(pTarget, vecSrc, rad)) != NULL)
{
// Make sure an entity is allowed to take damage
if (pTarget->v.takedamage > DAMAGE_NO)
{
//none of this code was working so I simplified it
//damage doesn't check for visibility now (it probably shouldn't anyway)
//for this to work it seems like an exception needs to be made for world OR
// the spot/see things aren't being calculated right.
#if 0
vecSpot = (pTarget->v.absmin + pTarget->v.absmax) * 0.5;
vecSee = (pAttacker->v.absmin + pAttacker->v.absmax) * 0.5;
TRACE_LINE(vecSee, vecSpot, FALSE, pAttacker, &tr);
// Explosion can 'see' this entity, so hurt them!
#endif
TRACE_LINE(vecSrc, pTarget->v.origin, FALSE, pAttacker, &tr);
hitId = ENTINDEX(tr.pHit);
targetId = ENTINDEX(pTarget);
if(tr.flFraction < 1.0 || (hitId == targetId))
{
// Work out the distance between impact and entity
float dist = (tr.vecEndPos - vecSrc).Length() * falloff;
// Damage algorithm, its just that easy :)
dmg -= dist;
// Knockback Effect
if(pTarget->v.flags & (FL_CLIENT | FL_FAKECLIENT) && (bit & (DMG_BLAST | DMG_CLUB | DMG_SHOCK | DMG_SONIC | DMG_ENERGYBEAM | DMG_MORTAR)))
{
Vector vecPush = (pTarget->v.origin - (pAttacker->v.absmin + pAttacker->v.absmax) * 0.5).Normalize();
if(dmg < 60.0)
{
pTarget->v.velocity = pTarget->v.velocity + vecPush * dmg * (sv_knockback1 ? sv_knockback1->value : 1.0f);
} else {
pTarget->v.velocity = pTarget->v.velocity + vecPush * dmg * (sv_knockback2 ? sv_knockback2->value : 1.0f);
}
}
// Send info to Damage system
Damage(pTarget, pAttacker, vecSrc, dmg, bit, weapon, hs);
}
}
}
pTarget = NULL;
}