//---------------------------------------------------------
//---------------------------------------------------------
int CNPC_Roller::VPhysicsTakeDamage( const CTakeDamageInfo &info )
{
if( RollerPhysicsDamageMask() & info.GetDamageType() )
{
SetCondition( COND_ROLLER_PHYSICS );
}
return BaseClass::VPhysicsTakeDamage( info );
}
void CHL1BaseNPC::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr )
{
if ( info.GetDamage() >= 1.0 && !(info.GetDamageType() & DMG_SHOCK ) )
{
UTIL_BloodSpray( ptr->endpos, vecDir, BloodColor(), 4, FX_BLOODSPRAY_ALL );
}
BaseClass::TraceAttack( info, vecDir, ptr, NULL );
}
void CHL1NPCTalker::TraceAttack(const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator)
{
if ( info.GetDamage() >= 1.0 && !(info.GetDamageType() & DMG_SHOCK ) )
{
UTIL_BloodImpact( ptr->endpos, vecDir, BloodColor(), 4 );
}
BaseClass::TraceAttack( info, vecDir, ptr, pAccumulator );
}
// only shock damage counts as heavy (and thus causes a flinch even during normal running)
bool CASW_Harvester::IsHeavyDamage( const CTakeDamageInfo &info )
{
// shock damage never causes flinching
if (( info.GetDamageType() & DMG_SHOCK ) != 0 )
return false;
// explosions always cause a flinch
if (( info.GetDamageType() & DMG_BLAST ) != 0 )
return true;
CASW_Marine *pMarine = dynamic_cast<CASW_Marine*>(info.GetAttacker());
if (pMarine && pMarine->GetActiveASWWeapon())
{
return pMarine->GetActiveASWWeapon()->ShouldAlienFlinch(this, info);
}
return false;
}
int CHL2MP_Player::OnTakeDamage( const CTakeDamageInfo &inputInfo )
{
//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();
return BaseClass::OnTakeDamage( inputInfo );
}
int CNPC_Vortigaunt::OnTakeDamage_Alive( const CTakeDamageInfo &inputInfo )
{
// don't slash one of your own
if ( ( inputInfo.GetDamageType() & DMG_SLASH ) && inputInfo.GetAttacker() && IRelationType( inputInfo.GetAttacker() ) == D_NU )
return 0;
Remember( bits_MEMORY_PROVOKED );
return BaseClass::OnTakeDamage_Alive( inputInfo );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CBaseHelicopter::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr )
{
// Take no damage from trace attacks unless it's blast damage. RadiusDamage() sometimes calls
// TraceAttack() as a means for delivering blast damage. Usually when the explosive penetrates
// the target. (RPG missiles do this sometimes).
if( info.GetDamageType() & (DMG_BLAST|DMG_AIRBOAT) )
{
BaseClass::TraceAttack( info, vecDir, ptr );
}
}
int CRocketMissile::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
if ( ( info.GetDamageType() & (DMG_AIRBOAT) ) == false )
{
return 0;
}
int nRetVal = BaseClass::OnTakeDamage_Alive( info );
return nRetVal;
}
int CGrenadeFrag::OnTakeDamage( const CTakeDamageInfo &inputInfo )
{
// Manually apply vphysics because BaseCombatCharacter takedamage doesn't call back to CBaseEntity OnTakeDamage
VPhysicsTakeDamage( inputInfo );
// Grenades only suffer blast damage and burn damage.
if( !(inputInfo.GetDamageType() & (DMG_BLAST|DMG_BURN) ) )
return 0;
return BaseClass::OnTakeDamage( inputInfo );
}
//-----------------------------------------------------------------------------
// Item crates blow up immediately
//-----------------------------------------------------------------------------
int CItem_ItemCrate::OnTakeDamage( const CTakeDamageInfo &info )
{
if ( info.GetDamageType() & DMG_AIRBOAT )
{
CTakeDamageInfo dmgInfo = info;
dmgInfo.ScaleDamage( 10.0 );
return BaseClass::OnTakeDamage( dmgInfo );
}
return BaseClass::OnTakeDamage( info );
}
void CHL2MP_Player::Event_Killed( const CTakeDamageInfo &info )
{
//update damage info with our accumulated physics force
CTakeDamageInfo subinfo = info;
subinfo.SetDamageForce( m_vecTotalBulletForce );
#ifdef GE_DLL
// Since we fixed force application, give the ragdoll an extra oomph to emphasize his death
m_vecTotalBulletForce.x *= 2.5f;
m_vecTotalBulletForce.y *= 2.5f;
m_vecTotalBulletForce.z *= 2.0f;
#endif
// Note: since we're dead, it won't draw us on the client, but we don't set EF_NODRAW
// because we still want to transmit to the clients in our PVS.
CreateRagdollEntity();
#ifndef GE_DLL
DetonateTripmines();
#endif
BaseClass::Event_Killed( subinfo );
if ( info.GetDamageType() & DMG_DISSOLVE )
{
if ( m_hRagdoll )
{
m_hRagdoll->GetBaseAnimating()->Dissolve( NULL, gpGlobals->curtime, false, ENTITY_DISSOLVE_NORMAL );
}
}
#ifndef GE_DLL
CBaseEntity *pAttacker = info.GetAttacker();
if ( pAttacker )
{
int iScoreToAdd = 1;
if ( pAttacker == this )
{
iScoreToAdd = -1;
}
GetGlobalTeam( pAttacker->GetTeamNumber() )->AddMatchScore( iScoreToAdd );
}
#endif
FlashlightTurnOff();
m_lifeState = LIFE_DEAD;
RemoveEffects( EF_NODRAW ); // still draw player body
StopZooming();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CWeaponBrickbat::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr )
{
if ( info.GetDamageType() & DMG_BULLET)
{
if ( BrickBatAmmoArray[m_iCurrentAmmoType].m_nAmmoType == BRICKBAT_ROCK )
{
g_pEffects->Ricochet(ptr->endpos,ptr->plane.normal);
}
}
BaseClass::TraceAttack( info, vecDir, ptr );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CASW_PropJeep::OnTakeDamage( const CTakeDamageInfo &inputInfo )
{
//Do scaled up physics damage to the car
CTakeDamageInfo info = inputInfo;
info.ScaleDamage( 25 );
// HACKHACK: Scale up grenades until we get a better explosion/pressure damage system
if ( inputInfo.GetDamageType() & DMG_BLAST )
{
info.SetDamageForce( inputInfo.GetDamageForce() * 10 );
}
VPhysicsTakeDamage( info );
// reset the damage
info.SetDamage( inputInfo.GetDamage() );
// small amounts of shock damage disrupt the car, but aren't transferred to the player
if ( info.GetDamageType() == DMG_SHOCK )
{
if ( info.GetDamage() <= 10 )
{
// take 10% damage and make the engine stall
info.ScaleDamage( 0.1 );
m_throttleDisableTime = gpGlobals->curtime + 2;
}
}
//Check to do damage to driver
if ( GetDriver() )
{
//Take no damage from physics damages
if ( info.GetDamageType() & DMG_CRUSH )
return 0;
// Take the damage (strip out the DMG_BLAST)
info.SetDamageType( info.GetDamageType() & (~DMG_BLAST) );
GetDriver()->TakeDamage( info );
}
return 0;
}
void CNPC_Gargantua::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr )
{
CTakeDamageInfo subInfo = info;
if ( !IsAlive() )
{
BaseClass::TraceAttack( subInfo, vecDir, ptr );
return;
}
// UNDONE: Hit group specific damage?
if ( subInfo.GetDamageType() & ( GARG_DAMAGE | DMG_BLAST ) )
{
if ( m_painSoundTime < gpGlobals->curtime )
{
CPASAttenuationFilter filter( this );
EmitSound( filter, entindex(), "Garg.Pain" );
m_painSoundTime = gpGlobals->curtime + random->RandomFloat( 2.5, 4 );
}
}
int bitsDamageType = subInfo.GetDamageType();
bitsDamageType &= GARG_DAMAGE;
subInfo.SetDamageType( bitsDamageType );
if ( subInfo.GetDamageType() == 0 )
{
if ( m_flDmgTime != gpGlobals->curtime || (random->RandomInt( 0, 100 ) < 20) )
{
g_pEffects->Ricochet(ptr->endpos, -vecDir );
m_flDmgTime = gpGlobals->curtime;
}
subInfo.SetDamage( 0 );
}
BaseClass::TraceAttack( subInfo, vecDir, ptr );
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
int CNPC_MissileDefense::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
// Only take blast damage
if (info.GetDamageType() & DMG_BLAST )
{
return BaseClass::OnTakeDamage_Alive( info );
}
else
{
return 0;
}
}
//-----------------------------------------------------------------------------
// Purpose: Twiddle damage based on certain criteria
//-----------------------------------------------------------------------------
int CNPC_AntlionGrub::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
CTakeDamageInfo newInfo = info;
// Always squash on a crowbar hit
if ( newInfo.GetDamageType() & DMG_CLUB )
{
newInfo.SetDamage( GetHealth() + 1.0f );
}
return BaseClass::OnTakeDamage_Alive( newInfo );
}
int CNPC_Gargantua::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
CTakeDamageInfo subInfo = info;
float flDamage = subInfo.GetDamage();
if ( IsAlive() )
{
if ( !(subInfo.GetDamageType() & GARG_DAMAGE) )
{
flDamage *= 0.01;
subInfo.SetDamage( flDamage );
}
if ( subInfo.GetDamageType() & DMG_BLAST )
{
SetCondition( COND_LIGHT_DAMAGE );
}
}
return BaseClass::OnTakeDamage_Alive( subInfo );
}
int DotaObjective::OnTakeDamage( const CTakeDamageInfo &inputInfo )
{
if ( m_bMet )
return 0;
if ( !(inputInfo.GetDamageType() & DMG_BULLET) )
{
CHL2MP_Player * playerAttacker = ToHL2MPPlayer( inputInfo.GetAttacker() );
CreepMaker * maker = (CreepMaker*)gEntList.FindEntityByName( NULL, m_creepMakerName );
if ( !maker )
AssertMsg( false, "Objective can't find its creepmaker!\n" );
CAI_BaseNPC * guardian = (CAI_BaseNPC*)gEntList.FindEntityByName( NULL, m_guardianName );
if( guardian && guardian->IsAlive() )
{
if( playerAttacker )
ClientPrint( playerAttacker, HUD_PRINTTALK, UTIL_VarArgs("The guradian is alive in this lane, you can't hurt the gate.\n") );
}
else
{
m_timesHit++;
m_timesHit = min(m_timesHit, OBJECTIVE_HEALTHI); // make sure times hit never goes above the maximum times an objective can be hit!
CRecipientFilter user;
user.AddRecipientsByTeam( this->GetTeam() );
user.MakeReliable();
char szText[200];
Q_snprintf( szText, sizeof(szText), "Your ally gate is under attack from an enemy!" );
UTIL_ClientPrintFilter( user, HUD_PRINTCENTER, szText );
if( playerAttacker )
ClientPrint( playerAttacker, HUD_PRINTTALK, UTIL_VarArgs("Gate has %i health left.\n", OBJECTIVE_HEALTHI - m_timesHit) );
if (m_timesHit >= OBJECTIVE_HEALTHI)
{
TakeAction(DOBJ_ACTION_CLOSE);
} else {
IGameEvent *pEvent = gameeventmanager->CreateEvent( "objectivegate_attacked" );
if ( pEvent )
{
pEvent->SetString( "lane", GetLane() );
pEvent->SetInt( "team", this->GetTeamNumber() );
pEvent->SetFloat( "health", (OBJECTIVE_HEALTHF - m_timesHit)/OBJECTIVE_HEALTHF );
gameeventmanager->FireEvent( pEvent );
}
}
}
}
return 0;
}
//---------------------------------------------------------
//---------------------------------------------------------
int CASW_Zombie::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
#ifndef HL2_EPISODIC
if ( info.GetDamageType() & DMG_BUCKSHOT )
{
if( !m_fIsTorso && info.GetDamage() > (m_iMaxHealth/3) )
{
// Always flinch if damaged a lot by buckshot, even if not shot in the head.
// The reason for making sure we did at least 1/3rd of the zombie's max health
// is so the zombie doesn't flinch every time the odd shotgun pellet hits them,
// and so the maximum number of times you'll see a zombie flinch like this is 2.(sjb)
AddGesture( ACT_GESTURE_FLINCH_HEAD );
}
}
#endif // HL2_EPISODIC
// catching on fire
int result = 0;
// scale burning damage up
if (dynamic_cast<CEntityFlame*>(info.GetAttacker()))
{
CTakeDamageInfo newDamage = info;
newDamage.ScaleDamage(asw_fire_zombie_damage_scale.GetFloat());
result = BaseClass::OnTakeDamage_Alive(newDamage);
}
else
{
result = BaseClass::OnTakeDamage_Alive(info);
}
// if we take fire damage, catch on fire
if (result > 0 && (info.GetDamageType() & DMG_BURN))
ASW_Ignite(30.0f, 0, info.GetAttacker());
//CASW_Marine* pMarine = dynamic_cast<CASW_Marine*>(info.GetAttacker());
//if (pMarine)
//pMarine->HurtAlien(this);
return BaseClass::OnTakeDamage_Alive( 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:
// Input : &info -
//-----------------------------------------------------------------------------
int CNPC_Portal_FloorTurret::OnTakeDamage( const CTakeDamageInfo &info )
{
if ( m_lifeState == LIFE_ALIVE && ( info.GetDamageType() & DMG_BULLET ) && !info.GetAttacker()->IsPlayer() )
{
if ( gpGlobals->curtime > m_fNextTalk )
{
EmitSound( GetTurretTalkName( PORTAL_TURRET_SHOTAT ) );
m_fNextTalk = gpGlobals->curtime + 3.0f;
}
}
return BaseClass::OnTakeDamage( info );
}
int CNPC_Portal_GroundTurret::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
// Taking damage from myself, make sure it's fatal.
CTakeDamageInfo infoCopy = info;
if ( infoCopy.GetDamageType() == DMG_CRUSH )
{
infoCopy.SetDamage( GetHealth() );
infoCopy.SetDamageType( DMG_REMOVENORAGDOLL | DMG_GENERIC );
}
return BaseClass::BaseClass::OnTakeDamage_Alive( infoCopy );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CASW_PropJeep::TraceAttack( const CTakeDamageInfo &inputInfo, const Vector &vecDir, trace_t *ptr )
{
CTakeDamageInfo info = inputInfo;
if ( ptr->hitbox != VEHICLE_HITBOX_DRIVER )
{
if ( inputInfo.GetDamageType() & DMG_BULLET )
{
info.ScaleDamage( 0.0001 );
}
}
BaseClass::TraceAttack( info, vecDir, ptr );
}
//-----------------------------------------------------------------------------
// Purpose: Prevent Team Damage
//-----------------------------------------------------------------------------
int CBaseObjectUpgrade::OnTakeDamage( const CTakeDamageInfo &info )
{
#if !defined( CLIENT_DLL )
// Check teams
if ( info.GetDamageType() & DMG_BLAST )
{
return 0;
}
return BaseClass::OnTakeDamage( info );
#else
return 0;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pevInflictor -
// pevAttacker -
// flDamage -
// bitsDamageType -
// Output :
//-----------------------------------------------------------------------------
int CNPC_Headcrab::OnTakeDamage_Alive( const CTakeDamageInfo &inputInfo )
{
CTakeDamageInfo info = inputInfo;
//
// Don't take any acid damage.
//
if ( info.GetDamageType() & DMG_ACID )
{
return 0;
}
return BaseClass::OnTakeDamage_Alive( info );
}
int CPhysicsCannister::OnTakeDamage( const CTakeDamageInfo &info )
{
// HACKHACK: Shouldn't g_vecAttackDir be a parameter to this function?
if ( !m_takedamage )
return 0;
if ( !m_active )
{
m_iHealth -= info.GetDamage();
if ( m_iHealth < 0 )
{
Explode( info.GetAttacker() );
}
else
{
// explosions that don't destroy will activate
// 50% of the time blunt damage will activate as well
if ( (info.GetDamageType() & DMG_BLAST) ||
( (info.GetDamageType() & (DMG_CLUB|DMG_SLASH|DMG_CRUSH) ) && random->RandomInt(1,100) < 50 ) )
{
CannisterActivate( info.GetAttacker(), g_vecAttackDir );
}
}
return 1;
}
if ( (gpGlobals->curtime - m_activateTime) <= 0.1 )
return 0;
if ( info.GetDamageType() & (DMG_BULLET|DMG_BUCKSHOT|DMG_BURN|DMG_BLAST) )
{
Explode( info.GetAttacker() );
}
return 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFWeaponBaseGrenadeProj::OnTakeDamage( const CTakeDamageInfo &info )
{
CTakeDamageInfo info2 = info;
// Reduce explosion damage so that we don't get knocked too far
if ( info.GetDamageType() & DMG_BLAST )
{
info2.ScaleDamageForce( 0.05 );
}
// We need to skip back to the base entity take damage, because
// CBaseCombatCharacter doesn't, which prevents us from reacting
// to physics impact damage.
return CBaseEntity::OnTakeDamage( info2 );
}
// Крематор игнорирует урон огнем
int CNPC_Cremator::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
CTakeDamageInfo newInfo = info;
if( newInfo.GetDamageType() & DMG_BURN)
{
newInfo.ScaleDamage( 0 );
DevMsg( "Fire damage; no actual damage is taken\n" );
}
int nDamageTaken = BaseClass::OnTakeDamage_Alive( newInfo );
// m_bHeadshot = false;
// m_bCanisterShot = false;
return nDamageTaken;
}
void CNPC_Crow::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr )
{
CTakeDamageInfo newInfo = info;
if ( info.GetDamageType() & DMG_PHYSGUN )
{
Vector puntDir = ( info.GetDamageForce() * 5000.0f );
newInfo.SetDamage( m_iMaxHealth );
PainSound( newInfo );
newInfo.SetDamageForce( puntDir );
}
BaseClass::TraceAttack( newInfo, vecDir, ptr );
}
//-----------------------------------------------------------------------------
// 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;
}