void CDataManager::AddKillInfo(const CTakeDamageInfo& info, CDAPlayer* pVictim)
{
d->m_apKillInfos.AddToTail(new da::protobuf::KillInfo());
da::protobuf::KillInfo* pbKillInfo = d->m_apKillInfos.Tail();
CBaseEntity* pAttacker = info.GetAttacker();
da::protobuf::PlayerInfo* pbVictimInfo = pbKillInfo->mutable_victim();
FillPlayerInfo(pbVictimInfo, pVictim);
unsigned long long flags = pbVictimInfo->flags();
if (dynamic_cast<CBaseGrenadeProjectile*>(info.GetInflictor()))
{
flags |= 1<<da::protobuf::KILL_BY_GRENADE;
FillProtoBufVector(pbKillInfo->mutable_grenade_position(), info.GetInflictor()->GetAbsOrigin());
}
if (info.GetDamageType() == DMG_CLUB)
flags |= 1<<da::protobuf::KILL_BY_BRAWL;
if (pAttacker == pVictim)
flags |= 1<<da::protobuf::KILL_IS_SUICIDE;
pbVictimInfo->set_flags(flags);
CDAPlayer* pPlayerAttacker = ToDAPlayer(pAttacker);
if (pPlayerAttacker && pPlayerAttacker != pVictim)
FillPlayerInfo(pbKillInfo->mutable_killer(), pPlayerAttacker);
}
DETOUR_DECL_MEMBER(int, CBaseEntity_TakeDamage, const CTakeDamageInfo& info)
{
auto ent = reinterpret_cast<CBaseEntity *>(this);
if (ent->IsBaseObject() && info.GetDamageType() == DMG_BLAST && info.GetDamageCustom() == TF_DMG_CUSTOM_NONE) {
if (rc_CTFBotMainAction_OnContact > 0 && bot_contact != nullptr && info.GetInflictor() == bot_contact && info.GetAttacker() == bot_contact) {
if (cvar_contact_addknown.GetBool()) {
AddKnownToBot(bot_contact, ent);
}
if (cvar_contact_nodamage.GetBool()) {
DevMsg("Preventing damage due to giant-robot-vs-building instant stomp from CTFBotMainAction::OnContact\n");
return 0;
}
}
if (rc_CTFBotMainAction_OnStuck > 0 && bot_stuck != nullptr && info.GetInflictor() == bot_stuck && info.GetAttacker() == bot_stuck) {
if (cvar_stuck_addknown.GetBool()) {
AddKnownToBot(bot_stuck, ent);
}
if (cvar_stuck_nodamage.GetBool()) {
DevMsg("Preventing damage due to robot-vs-building delayed stomp from CTFBotMainAction::OnStuck\n");
return 0;
}
}
}
return DETOUR_MEMBER_CALL(CBaseEntity_TakeDamage)(info);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
int CTDP_NPC_CombineS::TakeDamage( const CTakeDamageInfo &info )
{
if( info.GetInflictor() && info.GetInflictor()->VPhysicsGetObject() )
{
// Hit by a physics object! Was I blocking?
if( m_fIsBlocking )
{
IPhysicsObject *pPhysObject;
pPhysObject = info.GetInflictor()->VPhysicsGetObject();
if( pPhysObject )
{
// Only deflect objects of relatively low mass
//DevMsg( "MASS: %f\n", pPhysObject->GetMass() );
if( pPhysObject->GetMass() <= 30.0 )
{
// No damage from light objects (tuned for melons)
return 0;
}
}
}
}
BaseClass::TakeDamage( info );
return 0;
}
int CHL2MP_Player::OnTakeDamage( const CTakeDamageInfo &inputInfo )
{
#ifndef GE_DLL
//return here if the player is in the respawn grace period vs. slams.
if ( gpGlobals->curtime < m_flSlamProtectTime && (inputInfo.GetDamageType() == DMG_BLAST ) )
return 0;
m_vecTotalBulletForce += inputInfo.GetDamageForce();
gamestats->Event_PlayerDamage( this, inputInfo );
#else
CBaseEntity *attacker = inputInfo.GetAttacker();
Vector force = inputInfo.GetDamageForce();
if ( force == vec3_origin && attacker )
{
Vector vecDir = vec3_origin;
if ( inputInfo.GetInflictor() && GetMoveType() == MOVETYPE_WALK && !attacker->IsSolidFlagSet(FSOLID_TRIGGER) )
{
vecDir = inputInfo.GetInflictor()->WorldSpaceCenter() - Vector ( 0, 0, 10 ) - WorldSpaceCenter();
VectorNormalize( vecDir );
force = vecDir * -DamageForce( WorldAlignSize(), inputInfo.GetBaseDamage() );
}
}
m_vecTotalBulletForce += force;
#endif
return BaseClass::OnTakeDamage( inputInfo );
}
void CASW_Simple_Alien::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr )
{
if ( m_takedamage == DAMAGE_NO )
return;
CTakeDamageInfo subInfo = info;
m_nForceBone = ptr->physicsbone; // save this bone for physics forces
Assert( m_nForceBone > -255 && m_nForceBone < 256 );
if ( subInfo.GetDamage() >= 1.0 && !(subInfo.GetDamageType() & DMG_SHOCK )
&& !(subInfo.GetDamageType() & DMG_BURN ))
{
// NPC's always bleed. Players only bleed in multiplayer.
//SpawnBlood( ptr->endpos, vecDir, BloodColor(), subInfo.GetDamage() );// a little surface blood.
UTIL_ASW_DroneBleed( ptr->endpos, vecDir, 4 ); // + m_LagCompensation.GetLagCompensationOffset()
ASWTraceBleed( subInfo.GetDamage(), vecDir, ptr, subInfo.GetDamageType() );
}
if( info.GetInflictor() )
{
subInfo.SetInflictor( info.GetInflictor() );
}
else
{
subInfo.SetInflictor( info.GetAttacker() );
}
AddMultiDamage( subInfo, this );
}
void QUA_helicopter::Event_Killed( const CTakeDamageInfo &info )
{
//m_lifeState=LIFE_DYING;
// Calculate death force
m_vecTotalBulletForce = CalcDamageForceVector( info );
CBasePlayer *pPlayer = m_hPlayer;
if ( pPlayer )
{
pPlayer->LeaveVehicle(); // Force exit vehicle
CBaseEntity *pAPC=this->GetBaseEntity();
CTakeDamageInfo playerinfo;
if (info.GetAttacker()==pAPC && info.GetInflictor()==pAPC) {
playerinfo.SetAttacker(pPlayer);
playerinfo.SetInflictor(pPlayer);
playerinfo.SetDamage(10000);
playerinfo.SetDamageType(DMG_BLAST);
} else {
playerinfo.SetAttacker(info.GetAttacker());
playerinfo.SetInflictor(info.GetInflictor());
playerinfo.SetDamage(10000);
playerinfo.SetDamageType(DMG_BLAST);
}
playerinfo.SetDamagePosition( pPlayer->WorldSpaceCenter() );
playerinfo.SetDamageForce( Vector(0,0,-1) );
pPlayer->TakeDamage( playerinfo );
m_hPlayer = NULL;
}
m_OnDeath.FireOutput( info.GetAttacker(), this );
//StopSmoking();
Vector vecAbsMins, vecAbsMaxs;
CollisionProp()->WorldSpaceAABB( &vecAbsMins, &vecAbsMaxs );
Vector vecNormalizedMins, vecNormalizedMaxs;
CollisionProp()->WorldToNormalizedSpace( vecAbsMins, &vecNormalizedMins );
CollisionProp()->WorldToNormalizedSpace( vecAbsMaxs, &vecNormalizedMaxs );
Vector vecAbsPoint;
CPASFilter filter( GetAbsOrigin() );
for (int i = 0; i < 5; i++)
{
CollisionProp()->RandomPointInBounds( vecNormalizedMins, vecNormalizedMaxs, &vecAbsPoint );
te->Explosion( filter, random->RandomFloat( 0.0, 1.0 ), &vecAbsPoint,
g_sModelIndexFireball, random->RandomInt( 4, 10 ),
random->RandomInt( 8, 15 ),
( i < 2 ) ? TE_EXPLFLAG_NODLIGHTS : TE_EXPLFLAG_NOPARTICLES | TE_EXPLFLAG_NOFIREBALLSMOKE | TE_EXPLFLAG_NODLIGHTS,
100, 0 );
}
// Aqui destruiremos todo
StopLoopingSounds();
BecomeRagdoll( info, m_vecTotalBulletForce );
UTIL_ScreenShake( vecAbsPoint, 25.0, 150.0, 1.0, 750.0f, SHAKE_START );
CreateCorpse();
//BecomeRagdoll( info, m_vecTotalBulletForce );
//BecomeRagdollOnClient(m_vecTotalBulletForce);
//Dissolve(NULL, gpGlobals->curtime, false, ENTITY_DISSOLVE_NORMAL);
}
int QUA_helicopter::OnTakeDamage( const CTakeDamageInfo &info )
{
if ( m_iHealth == 0 )
return 0;
CTakeDamageInfo dmgInfo = info;
float dim=dmgInfo.GetDamage();
if ( dmgInfo.GetInflictor() && dmgInfo.GetInflictor()->GetOwnerEntity() == this ) {
dmgInfo.SetDamage(dim*0.0);
} else if( (dmgInfo.GetDamageType() & DMG_BULLET) || (dmgInfo.GetDamageType() & DMG_SLASH) ||
(dmgInfo.GetDamageType() & DMG_CLUB) )
{
dmgInfo.SetDamage( dim*0.1 );
} else {
dmgInfo.SetDamage( dim*1.2 );
}
//int nPrevHealth = GetHealth();
m_iHealth -= dmgInfo.GetDamage();
/*if( !IsSmoking() && m_iHealth <= 500 / 2 )
{
StartSmoking();
}*/
if ( m_iHealth <= 0 )
{
m_iHealth = 0;
Event_Killed( dmgInfo );
return 0;
}
return 1;
}
void CASW_Queen_Divers::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr )
{
if ( m_takedamage == DAMAGE_NO )
return;
CTakeDamageInfo subInfo = info;
m_nForceBone = ptr->physicsbone; // save this bone for physics forces
Assert( m_nForceBone > -255 && m_nForceBone < 256 );
if ( subInfo.GetDamage() >= 1.0 && !(subInfo.GetDamageType() & DMG_SHOCK )
&& !(subInfo.GetDamageType() & DMG_BURN ))
{
UTIL_ASW_DroneBleed( ptr->endpos, vecDir, 4 );
ASWTraceBleed( subInfo.GetDamage(), vecDir, ptr, subInfo.GetDamageType() );
}
if( info.GetInflictor() )
{
subInfo.SetInflictor( info.GetInflictor() );
}
else
{
subInfo.SetInflictor( info.GetAttacker() );
}
AddMultiDamage( subInfo, this );
}
void CSDKPlayer::OnDamagedByExplosion( const CTakeDamageInfo &info )
{
if ( info.GetInflictor() && info.GetInflictor()->ClassMatches( "mortarshell" ) )
{
// No ear ringing for mortar
UTIL_ScreenShake( info.GetInflictor()->GetAbsOrigin(), 4.0, 1.0, 0.5, 1000, SHAKE_START, false );
return;
}
BaseClass::OnDamagedByExplosion( info );
}
bool CBaseFilter::PassesDamageFilterImpl( const CTakeDamageInfo &info )
{
//Tony; modified so it can check the inflictor or the attacker. We'll check the attacker first; which is normal if that fails, then check the inflictor.
bool bResult = false;
bResult = PassesFilterImpl( NULL, info.GetAttacker() );
if (!bResult && info.GetInflictor() != NULL)
bResult = PassesFilterImpl( NULL, info.GetInflictor() );
return bResult;//PassesFilterImpl( NULL, info.GetAttacker() );
}
//-----------------------------------------------------------------------------
// Purpose: Called when the train is killed.
// Input : pInflictor - What killed us.
// pAttacker - Who killed us.
// flDamage - The damage that the killing blow inflicted.
// bitsDamageType - Bitfield of damage types that were inflicted.
//-----------------------------------------------------------------------------
void CFuncTankTrain::Event_Killed( const CTakeDamageInfo &info )
{
m_takedamage = DAMAGE_NO;
m_lifeState = LIFE_DEAD;
m_OnDeath.FireOutput( info.GetInflictor(), this );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pVictim -
// *pKiller -
// *pInflictor -
//-----------------------------------------------------------------------------
void CSDKGameRules::DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info )
{
int killer_ID = 0;
// Find the killer & the scorer
CSDKPlayer *pSDKPlayerVictim = ToSDKPlayer( pVictim );
CBaseEntity *pInflictor = info.GetInflictor();
CBaseEntity *pKiller = info.GetAttacker();
CBasePlayer *pScorer = GetDeathScorer( pKiller, pInflictor, pVictim );
// CSDKPlayer *pAssister = ToSDKPlayer( GetAssister( pVictim, pScorer, pInflictor ) );
// Work out what killed the player, and send a message to all clients about it
int iWeaponID;
const char *killer_weapon_name = GetKillingWeaponName( info, pSDKPlayerVictim, &iWeaponID );
if ( pScorer ) // Is the killer a client?
{
killer_ID = pScorer->GetUserID();
}
IGameEvent * event = gameeventmanager->CreateEvent( "player_death" );
if ( event )
{
event->SetInt( "userid", pVictim->GetUserID() );
event->SetInt( "attacker", killer_ID );
// event->SetInt( "assister", pAssister ? pAssister->GetUserID() : -1 );
event->SetString( "weapon", killer_weapon_name );
event->SetInt( "weaponid", iWeaponID );
event->SetInt( "damagebits", info.GetDamageType() );
event->SetInt( "customkill", info.GetDamageCustom() );
event->SetInt( "priority", 7 ); // HLTV event priority, not transmitted
gameeventmanager->FireEvent( event );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CPhysBox::OnTakeDamage( const CTakeDamageInfo &info )
{
// note: if motion is disabled, OnTakeDamage can't apply physics force
int ret = BaseClass::OnTakeDamage( info );
// Check our health against the threshold:
if( m_damageToEnableMotion > 0 && GetHealth() < m_damageToEnableMotion )
{
// only do this once
m_damageToEnableMotion = 0;
IPhysicsObject *pPhysicsObject = VPhysicsGetObject();
if ( pPhysicsObject != NULL )
{
pPhysicsObject->Wake();
pPhysicsObject->EnableMotion( true );
VPhysicsTakeDamage( info );
}
}
if ( info.GetInflictor() )
{
m_OnDamaged.FireOutput( info.GetAttacker(), this );
}
return ret;
}
//------------------------------------------------------------------------------
// Purpose : Only take damage in trace attack
// Input :
// Output :
//------------------------------------------------------------------------------
int CBreakableSurface::OnTakeDamage( const CTakeDamageInfo &info )
{
if ( !m_bIsBroken && info.GetDamageType() == DMG_CRUSH )
{
// physics will kill me now
Die( info.GetAttacker(), info.GetDamageForce() );
return 0;
}
if ( m_nSurfaceType == SHATTERSURFACE_GLASS && info.GetDamageType() & DMG_BLAST )
{
Vector vecDir = info.GetInflictor()->GetAbsOrigin() - WorldSpaceCenter();
VectorNormalize( vecDir );
Die( info.GetAttacker(), vecDir );
return 0;
}
// Accept slash damage, too. Manhacks and such.
if ( m_nSurfaceType == SHATTERSURFACE_GLASS && (info.GetDamageType() & DMG_SLASH) )
{
Die( info.GetAttacker(), info.GetDamageForce() );
return 0;
}
return 0;
}
void CGEStats::Event_PlayerKilledOther( CBasePlayer *pAttacker, CBaseEntity *pVictim, const CTakeDamageInfo &info )
{
//Make sure there is a victim and an attacker
if( !pVictim || !pAttacker )
return;
//Make sure the victim is a player
if( !pVictim->IsPlayer() )
return;
CBasePlayer *pBaseVictim = static_cast<CBasePlayer*>(pVictim);
//Return both Player ID's
int iVictim = FindPlayer( pBaseVictim );
int iAttacker = FindPlayer( pAttacker );
if( iVictim == -1 || iAttacker == -1 )
return;
// Check for suicide
if ( pVictim == pAttacker )
{
m_pPlayerStats[iVictim]->AddStat( GE_AWARD_PROFESSIONAL, -15 );
m_pPlayerStats[iVictim]->AddStat( GE_AWARD_MOSTLYHARMLESS, 50 );
m_pPlayerStats[iVictim]->AddStat( GE_AWARD_LEMMING, 3 );
}
else
{
m_pPlayerStats[iVictim]->AddStat( GE_AWARD_PROFESSIONAL , -5 );
m_pPlayerStats[iVictim]->AddStat( GE_AWARD_MOSTLYHARMLESS, 30 );
m_pPlayerStats[iAttacker]->AddStat( GE_AWARD_DEADLY , 50 );
m_pPlayerStats[iAttacker]->AddStat( GE_AWARD_PROFESSIONAL , 5 );
int weapid = WEAPON_NONE;
if ( info.GetWeapon() )
weapid = ToGEWeapon( (CBaseCombatWeapon*)info.GetWeapon() )->GetWeaponID();
else if ( !info.GetInflictor()->IsNPC() && Q_stristr( info.GetInflictor()->GetClassname(), "npc_" ) )
weapid = ToGEGrenade( info.GetInflictor() )->GetWeaponID();
if ( weapid != WEAPON_NONE )
// Increment our kills with this weapon
m_pPlayerStats[iAttacker]->m_iWeaponsKills[weapid]++;
}
BaseClass::Event_PlayerKilledOther( pAttacker, pVictim, info );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEP2GameStats::Event_PlayerKilled( CBasePlayer *pPlayer, const CTakeDamageInfo &info )
{
BaseClass::Event_PlayerKilled( pPlayer, info );
if ( info.GetDamageType() & DMG_FALL )
{
++m_pCurrentMap->m_IntCounters[ Ep2LevelStats_t::COUNTER_FALLINGDEATHS ];
}
Ep2LevelStats_t::PlayerDeathsLump_t death;
// set the location where the target died
const Vector &org = pPlayer->GetAbsOrigin();
death.nPosition[ 0 ] = static_cast<short>( org.x );
death.nPosition[ 1 ] = static_cast<short>( org.y );
death.nPosition[ 2 ] = static_cast<short>( org.z );
StatsLog( "CEP2GameStats::Event_PlayerKilled at location [%d %d %d]\n", (int)death.nPosition[ 0 ], (int)death.nPosition[ 1 ], (int)death.nPosition[ 2 ] );
// set the class of the attacker
CBaseEntity *pInflictor = info.GetInflictor();
CBaseEntity *pKiller = info.GetAttacker();
if ( pInflictor )
{
StatsLog( "Inflictor: %s\n", pInflictor->GetClassname() );
}
if ( pKiller )
{
char const *pchKiller = pKiller->GetClassname();
Ep2LevelStats_t::EntityDeathsLump_t *lump = FindDeathsLump( pchKiller );
if ( lump )
{
++lump->m_nKilledPlayer;
StatsLog( "Player has been killed %d times by %s's\n", lump->m_nKilledPlayer, pchKiller );
}
else
{
StatsLog( "Player killed by %s (not tracked)\n", pchKiller );
}
}
// add it to the list of deaths
Ep2LevelStats_t *map = FindOrAddMapStats( STRING( gpGlobals->mapname ) );
int slot = map->m_aPlayerDeaths.AddToTail( death );
Ep2LevelStats_t::SaveGameInfoRecord2_t *rec = map->m_SaveGameInfo.m_pCurrentRecord;
if ( rec )
{
if ( rec->m_nFirstDeathIndex == -1 )
{
rec->m_nFirstDeathIndex = slot;
}
++rec->m_nNumDeaths;
StatsLog( "Player has died %d times since last save/load\n", rec->m_nNumDeaths );
}
}
bool CZombie::IsSquashed( const CTakeDamageInfo &info )
{
if( GetHealth() > 0 )
return false;
if( info.GetDamageType() & DMG_CRUSH )
{
IPhysicsObject *pCrusher = info.GetInflictor()->VPhysicsGetObject();
if( pCrusher && pCrusher->GetMass() >= ZOMBIE_SQUASH_MASS && info.GetInflictor()->WorldSpaceCenter().z > EyePosition().z )
// This heuristic detects when a zombie has been squashed from above by a heavy
// item. Done specifically so we can add gore effects to Ravenholm cartraps.
// The zombie must take physics damage from a 300+kg object that is centered above its eyes (comes from above)
return true;
}
return false;
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
int CGrenadeHomer::OnTakeDamage( const CTakeDamageInfo &info )
{
// Don't take damage from other homing grenades so can shoot in vollies
if (FClassnameIs( info.GetInflictor(), "grenade_homer"))
{
return 0;
}
return BaseClass::OnTakeDamage( info );
}
void CZombie::OnTakeDamage( const CTakeDamageInfo& info )
{
CTakeDamageInfo newInfo = info;
// Take 30% damage from bullets
if ( newInfo.GetDamageTypes() == DMG_BULLET )
{
Vector vecDir = GetAbsOrigin() - ( newInfo.GetInflictor()->pev->absmin + newInfo.GetInflictor()->pev->absmax) * 0.5;
vecDir = vecDir.Normalize();
float flForce = DamageForce( newInfo.GetDamage() );
pev->velocity = pev->velocity + vecDir * flForce;
newInfo.GetMutableDamage() *= 0.3;
}
// HACK HACK -- until we fix this.
if ( IsAlive() )
PainSound();
CBaseMonster::OnTakeDamage( newInfo );
}
void CLeech::OnTakeDamage( const CTakeDamageInfo& info )
{
pev->velocity = g_vecZero;
// Nudge the leech away from the damage
if ( auto pInflictor = info.GetInflictor() )
{
pev->velocity = (GetAbsOrigin() - pInflictor->GetAbsOrigin()).Normalize() * 25;
}
CBaseMonster::OnTakeDamage( info );
}
void HapticsDamage(CBasePlayer* pPlayer, const CTakeDamageInfo &info)
{
#if !defined(TF_DLL) && !defined(CSTRIKE_DLL)
if(!pPlayer->HasHaptics())
return;// do not send to non haptic users.
Vector DamageDirection(0,0,0);
CBaseEntity *eInflictor = info.GetInflictor();
// Pat: nuero toxix crash fix
if(!eInflictor) {
return;
}
// Player Data
Vector playerPosition = pPlayer->GetLocalOrigin();
Vector inflictorPosition = eInflictor->GetLocalOrigin();
Vector posWithDir = playerPosition + (playerPosition - inflictorPosition);
pPlayer->WorldToEntitySpace(posWithDir, &DamageDirection);
QAngle dir(0,0,0);
VectorAngles(DamageDirection, dir);
float yawAngle = dir[YAW];
float pitchAngle = dir[PITCH];
int bitDamageType = info.GetDamageType();
if(bitDamageType & DMG_FALL)
{
pitchAngle = ((float)-90.0); // coming from beneath
}
else if(bitDamageType & DMG_BURN && (bitDamageType & ~DMG_BURN)==0)
{
// just burn, use the z axis here.
pitchAngle = 0.0;
}
#ifdef TERROR
else if(
(bitDamageType & ( DMG_PARALYZE | DMG_NERVEGAS | DMG_POISON | DMG_RADIATION | DMG_DROWNRECOVER | DMG_ACID | DMG_SLOWBURN ) ) &&
(bitDamageType & ~( DMG_PARALYZE | DMG_NERVEGAS | DMG_POISON | DMG_RADIATION | DMG_DROWNRECOVER | DMG_ACID | DMG_SLOWBURN ) )==0 )
{
// it is time based. and should not really do a punch.
return;
}
#endif
float sendDamage = info.GetDamage();
if(sendDamage>0.0f)
{
HapticMsg_HapDmg( pPlayer, pitchAngle, -yawAngle, sendDamage, bitDamageType );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Add damage to the existing multidamage, and apply if it won't fit
//-----------------------------------------------------------------------------
void AddMultiDamage( const CTakeDamageInfo &info, CBaseEntity *pEntity )
{
if ( !pEntity )
return;
if ( pEntity != g_MultiDamage.GetTarget() )
{
ApplyMultiDamage();
g_MultiDamage.Init( pEntity, info.GetInflictor(), info.GetAttacker(), info.GetWeapon(), vec3_origin, vec3_origin, vec3_origin, 0.0, info.GetDamageType(), info.GetDamageCustom() );
}
g_MultiDamage.AddDamageType( info.GetDamageType() );
g_MultiDamage.SetDamage( g_MultiDamage.GetDamage() + info.GetDamage() );
g_MultiDamage.SetDamageForce( g_MultiDamage.GetDamageForce() + info.GetDamageForce() );
g_MultiDamage.SetDamagePosition( info.GetDamagePosition() );
g_MultiDamage.SetReportedPosition( info.GetReportedPosition() );
g_MultiDamage.SetMaxDamage( MAX( g_MultiDamage.GetMaxDamage(), info.GetDamage() ) );
g_MultiDamage.SetAmmoType( info.GetAmmoType() );
if ( g_MultiDamage.GetPlayerPenetrationCount() == 0 )
{
g_MultiDamage.SetPlayerPenetrationCount( info.GetPlayerPenetrationCount() );
}
bool bHasPhysicsForceDamage = !g_pGameRules->Damage_NoPhysicsForce( info.GetDamageType() );
if ( bHasPhysicsForceDamage && g_MultiDamage.GetDamageType() != DMG_GENERIC )
{
// If you hit this assert, you've called TakeDamage with a damage type that requires a physics damage
// force & position without specifying one or both of them. Decide whether your damage that's causing
// this is something you believe should impart physics force on the receiver. If it is, you need to
// setup the damage force & position inside the CTakeDamageInfo (Utility functions for this are in
// takedamageinfo.cpp. If you think the damage shouldn't cause force (unlikely!) then you can set the
// damage type to DMG_GENERIC, or | DMG_CRUSH if you need to preserve the damage type for purposes of HUD display.
if ( g_MultiDamage.GetDamageForce() == vec3_origin || g_MultiDamage.GetDamagePosition() == vec3_origin )
{
static int warningCount = 0;
if ( ++warningCount < 10 )
{
if ( g_MultiDamage.GetDamageForce() == vec3_origin )
{
Warning( "AddMultiDamage: g_MultiDamage.GetDamageForce() == vec3_origin\n" );
}
if ( g_MultiDamage.GetDamagePosition() == vec3_origin)
{
Warning( "AddMultiDamage: g_MultiDamage.GetDamagePosition() == vec3_origin\n" );
}
}
}
}
}
//---------------------------------------------------------
//---------------------------------------------------------
int CNPC_GroundTurret::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
if( !info.GetInflictor() )
{
return 0;
}
// Only take damage from self (kill input from my bullseye) or missiles.
if( info.GetInflictor() != this && info.GetInflictor()->Classify() != CLASS_MISSILE )
{
return 0;
}
CTakeDamageInfo infoCopy = info;
if( info.GetInflictor() == this )
{
// Taking damage from myself, make sure it's fatal.
infoCopy.SetDamage( GetHealth() );
infoCopy.SetDamageType( DMG_REMOVENORAGDOLL | DMG_GENERIC );
}
return BaseClass::OnTakeDamage_Alive( infoCopy );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSapper::Killed( const CTakeDamageInfo &info )
{
// If the sapper is removed by someone other than builder, award bonus points.
CTFPlayer *pScorer = ToTFPlayer( TFGameRules()->GetDeathScorer( info.GetAttacker(), info.GetInflictor(), this ) );
if ( pScorer )
{
CBaseObject *pObject = GetParentObject();
if ( pObject && pScorer != pObject->GetBuilder() )
{
CTF_GameStats.Event_PlayerAwardBonusPoints( pScorer, this, 1 );
}
}
BaseClass::Killed( info );
}
int CGunTarget::OnTakeDamage( const CTakeDamageInfo &info )
{
if ( m_iHealth > 0 )
{
m_iHealth -= info.GetDamage();
if ( m_iHealth <= 0 )
{
m_iHealth = 0;
Stop();
m_OnDeath.FireOutput( info.GetInflictor(), this );
}
}
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: Allows us to make damage exceptions that are breakable-specific.
//-----------------------------------------------------------------------------
int CBreakable::OnTakeDamage( const CTakeDamageInfo &info )
{
Vector vecTemp;
CTakeDamageInfo subInfo = info;
// If attacker can't do at least the min required damage to us, don't take any damage from them
if ( m_takedamage == DAMAGE_NO || info.GetDamage() < m_iMinHealthDmg )
return 0;
// Check our damage filter
if ( !PassesDamageFilter(subInfo) )
{
m_bTookPhysicsDamage = false;
return 1;
}
vecTemp = subInfo.GetInflictor()->GetAbsOrigin() - WorldSpaceCenter();
if (!IsBreakable())
return 0;
float flPropDamage = GetBreakableDamage( subInfo, assert_cast<IBreakableWithPropData*>(this) );
subInfo.SetDamage( flPropDamage );
int iPrevHealth = m_iHealth;
BaseClass::OnTakeDamage( subInfo );
// HACK: slam health back to what it was so UpdateHealth can do its thing
int iNewHealth = m_iHealth;
m_iHealth = iPrevHealth;
if ( !UpdateHealth( iNewHealth, info.GetAttacker() ) )
return 1;
// Make a shard noise each time func breakable is hit, if it's capable of taking damage
if ( m_takedamage == DAMAGE_YES )
{
// Don't play shard noise if being burned.
// Don't play shard noise if cbreakable actually died.
if ( ( subInfo.GetDamageType() & DMG_BURN ) == false )
{
DamageSound();
}
}
return 1;
}
//=========================================================
// PlayerKilled - someone/something killed this player
//=========================================================
void CMultiplayRules::PlayerKilled( CBasePlayer *pVictim, const CTakeDamageInfo &info )
{
DeathNotice( pVictim, info );
// Find the killer & the scorer
CBaseEntity *pInflictor = info.GetInflictor();
CBaseEntity *pKiller = info.GetAttacker();
CBasePlayer *pScorer = GetDeathScorer( pKiller, pInflictor, pVictim );
pVictim->IncrementDeathCount( 1 );
// dvsents2: uncomment when removing all FireTargets
// variant_t value;
// g_EventQueue.AddEvent( "game_playerdie", "Use", value, 0, pVictim, pVictim );
FireTargets( "game_playerdie", pVictim, pVictim, USE_TOGGLE, 0 );
// Did the player kill himself?
if ( pVictim == pScorer )
{
if ( UseSuicidePenalty() )
{
// Players lose a frag for killing themselves
pVictim->IncrementFragCount( -1 );
}
}
else if ( pScorer )
{
// if a player dies in a deathmatch game and the killer is a client, award the killer some points
pScorer->IncrementFragCount( IPointsForKill( pScorer, pVictim ) );
// Allow the scorer to immediately paint a decal
pScorer->AllowImmediateDecalPainting();
// dvsents2: uncomment when removing all FireTargets
//variant_t value;
//g_EventQueue.AddEvent( "game_playerkill", "Use", value, 0, pScorer, pScorer );
FireTargets( "game_playerkill", pScorer, pScorer, USE_TOGGLE, 0 );
}
else
{
if ( UseSuicidePenalty() )
{
// Players lose a frag for letting the world kill them
pVictim->IncrementFragCount( -1 );
}
}
}
void CGEStats::Event_PlayerKilled( CBasePlayer *pPlayer, const CTakeDamageInfo &info )
{
int iVictim = FindPlayer( pPlayer );
if ( iVictim == -1 )
return;
CGEMPPlayer *gePlayer = ToGEMPPlayer( pPlayer );
if (!gePlayer)
return;
if ( gePlayer->IsObserver() || gePlayer->GetTeamNumber() == TEAM_SPECTATOR )
return;
m_pPlayerStats[iVictim]->m_iDeaths++;
float deaths = (float)m_pPlayerStats[iVictim]->m_iDeaths;
float lifetime = gpGlobals->curtime - gePlayer->GetSpawnTime();
m_pPlayerStats[iVictim]->AddStat( GE_INNING_VAL, lifetime );
m_pPlayerStats[iVictim]->AddStat( GE_INNING_SQ, lifetime*lifetime );
int inn;
int inn_val = m_pPlayerStats[iVictim]->GetRoundStat( GE_INNING_VAL );
int inn_sq = m_pPlayerStats[iVictim]->GetRoundStat( GE_INNING_SQ );
// Calculate the running standard deviation of our innings
float inn_sd = sqrt( (float)(inn_sq - (float)(inn_val*inn_val) / deaths) / deaths );
inn = (int)((float)inn_val/(float)m_pPlayerStats[iVictim]->m_iDeaths - inn_sd);
m_pPlayerStats[iVictim]->SetStat( GE_AWARD_LONGIN, inn );
m_pPlayerStats[iVictim]->SetStat( GE_AWARD_SHORTIN, inn );
// Fake a weapon switch so we can record their usage time of the weapon
Event_WeaponSwitch( pPlayer, pPlayer->GetActiveWeapon(), NULL );
//test if its a fall death
if( !info.GetInflictor() )
{
m_pPlayerStats[iVictim]->AddStat( GE_AWARD_PROFESSIONAL, -5);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEP2GameStats::Event_PlayerKilledOther( CBasePlayer *pAttacker, CBaseEntity *pVictim, const CTakeDamageInfo &info )
{
BaseClass::Event_PlayerKilledOther( pAttacker, pVictim, info );
if ( pAttacker )
{
StatsLog( "Attacker: %s\n", pAttacker->GetClassname() );
}
if ( !pVictim )
{
return;
}
char const *pchVictim = pVictim->GetClassname();
Ep2LevelStats_t::EntityDeathsLump_t *lump = FindDeathsLump( pchVictim );
if ( lump )
{
++lump->m_nBodyCount;
StatsLog( "Player has killed %d %s's\n", lump->m_nBodyCount, pchVictim );
CPropVehicleDriveable *veh = dynamic_cast< CPropVehicleDriveable * >( pAttacker );
if ( !veh )
veh = dynamic_cast< CPropVehicleDriveable * >( info.GetInflictor() );
if ( veh )
{
CBaseEntity *driver = veh->GetDriver();
if ( driver && driver->IsPlayer() )
{
++m_pCurrentMap->m_IntCounters[ Ep2LevelStats_t::COUNTER_VEHICULARHOMICIDES ];
StatsLog( " Vehicular homicide [%I64d] of %s's\n", m_pCurrentMap->m_IntCounters[ Ep2LevelStats_t::COUNTER_VEHICULARHOMICIDES ], pchVictim );
}
}
}
else
{
StatsLog( "Player killed %s (not tracked)\n", pchVictim );
}
}
int CBaseTurret::OnTakeDamage( const CTakeDamageInfo &inputInfo )
{
if ( !m_takedamage )
return 0;
CTakeDamageInfo info = inputInfo;
if (!m_iOn)
info.ScaleDamage( 0.1f );
m_iHealth -= info.GetDamage();
if (m_iHealth <= 0)
{
m_iHealth = 0;
m_takedamage = DAMAGE_NO;
m_flDamageTime = gpGlobals->curtime;
RemoveFlag( FL_NPC ); // why are they set in the first place???
SetThink(TurretDeath);
m_OnDamaged.FireOutput( info.GetInflictor(), this );
SetNextThink( gpGlobals->curtime + 0.1f );
return 0;
}
if (m_iHealth <= 10)
{
if (m_iOn && (1 || random->RandomInt(0, 0x7FFF) > 800))
{
m_fBeserk = 1;
SetThink(SearchThink);
}
}
return 1;
}