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 CNPC_HL1Barney::TraceAttack( const CTakeDamageInfo &inputInfo, const Vector &vecDir, trace_t *ptr )
{
CTakeDamageInfo info = inputInfo;
switch( ptr->hitgroup )
{
case HITGROUP_CHEST:
case HITGROUP_STOMACH:
if ( info.GetDamageType() & (DMG_BULLET | DMG_SLASH | DMG_BLAST) )
{
info.ScaleDamage( 0.5f );
}
break;
case 10:
if ( info.GetDamageType() & (DMG_BULLET | DMG_SLASH | DMG_CLUB) )
{
info.SetDamage( info.GetDamage() - 20 );
if ( info.GetDamage() <= 0 )
{
g_pEffects->Ricochet( ptr->endpos, ptr->plane.normal );
info.SetDamage( 0.01 );
}
}
// always a head shot
ptr->hitgroup = HITGROUP_HEAD;
break;
}
BaseClass::TraceAttack( info, vecDir, ptr );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseProjectile::ProjectileTouch( CBaseEntity *pOther )
{
// Verify a correct "other."
Assert( pOther );
if ( !pOther->IsSolid() || pOther->IsSolidFlagSet( FSOLID_VOLUME_CONTENTS ) )
return;
// Handle hitting skybox (disappear).
const trace_t *pTrace = &CBaseEntity::GetTouchTrace();
trace_t *pNewTrace = const_cast<trace_t*>( pTrace );
if( pTrace->surface.flags & SURF_SKY )
{
UTIL_Remove( this );
return;
}
CTakeDamageInfo info;
info.SetAttacker( GetOwnerEntity() );
info.SetInflictor( this );
info.SetDamage( GetDamage() );
info.SetDamageType( GetDamageType() );
CalculateMeleeDamageForce( &info, GetAbsVelocity(), GetAbsOrigin(), GetDamageScale() );
Vector dir;
AngleVectors( GetAbsAngles(), &dir );
pOther->DispatchTraceAttack( info, dir, pNewTrace );
ApplyMultiDamage();
UTIL_Remove( this );
}
void CNPC_BigMomma::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr )
{
CTakeDamageInfo dmgInfo = info;
if ( ptr->hitbox <= 9 )
{
// didn't hit the sack?
if ( m_flDmgTime != gpGlobals->curtime || (random->RandomInt( 0, 10 ) < 1) )
{
g_pEffects->Ricochet( ptr->endpos, ptr->plane.normal );
m_flDmgTime = gpGlobals->curtime;
}
// don't hurt the monster much, but allow bits_COND_LIGHT_DAMAGE to be generated
dmgInfo.SetDamage( 0.1 );
}
else
{
SpawnBlood( ptr->endpos + ptr->plane.normal * 15, vecDir, m_bloodColor, 100 );
if ( gpGlobals->curtime > m_painSoundTime )
{
m_painSoundTime = gpGlobals->curtime + random->RandomInt(1, 3);
EmitSound( "BigMomma.Pain" );
}
}
BaseClass::TraceAttack( dmgInfo, vecDir, ptr );
}
int CNPC_Gargantua::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
if( GetState() == NPC_STATE_SCRIPT )
{
// Invulnerable while scripted. This fixes the problem where garg wouldn't
// explode in C2A1 because for some reason he wouldn't die while scripted, he'd
// only freeze in place. Now he's just immune until he gets to the script and stops.
return 0;
}
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 );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pInflictor -
// *pAttacker -
// flDamage -
// bitsDamageType -
// Output : int
//-----------------------------------------------------------------------------
int CNPC_Bullseye::OnTakeDamage( const CTakeDamageInfo &info )
{
SetNextThink( gpGlobals->curtime );
//If specified, we must be the enemy of the target
if ( m_spawnflags & SF_BULLSEYE_ENEMYDAMAGEONLY )
{
CAI_BaseNPC *pInstigator = info.GetAttacker()->MyNPCPointer();
if ( pInstigator == NULL )
return 0;
if ( pInstigator->GetEnemy() != this )
return 0;
}
//If we're a pain proxy, send the damage through
if ( m_hPainPartner != NULL )
{
m_hPainPartner->TakeDamage( info );
//Fire all pain indicators but take no real damage
CTakeDamageInfo subInfo = info;
subInfo.SetDamage( 0 );
return BaseClass::OnTakeDamage( subInfo );
}
return BaseClass::OnTakeDamage( info );
}
void CGEPropDynamic::InputDestroy(inputdata_t &inputdata)
{
CTakeDamageInfo destroyinfo;
destroyinfo.SetDamage(m_iHealth);
destroyinfo.SetAttacker(inputdata.pActivator);
destroyinfo.SetInflictor(this);
TakeDamage(destroyinfo);
}
//-----------------------------------------------------------------------------
// 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 );
}
//-----------------------------------------------------------------------------
// Purpose: Deal the damage from the defanged parasite's touch attack.
//-----------------------------------------------------------------------------
void CASW_Parasite::TouchDamage( CBaseEntity *pOther )
{
CTakeDamageInfo info;
CalcDamageInfo( &info );
int damage = ASWGameRules()->ModifyAlienDamageBySkillLevel(info.GetDamage());
info.SetDamage(damage);
pOther->TakeDamage( info );
EmitSound("ASWFire.AcidBurn");
CEffectData data;
data.m_vOrigin = GetAbsOrigin();
data.m_nOtherEntIndex = pOther->entindex();
DispatchEffect( "ASWAcidBurn", data );
}
int CNPC_BigMomma::OnTakeDamage( const CTakeDamageInfo &info )
{
CTakeDamageInfo newInfo = info;
// Don't take any acid damage -- BigMomma's mortar is acid
if ( newInfo.GetDamageType() & DMG_ACID )
{
newInfo.SetDamage( 0 );
}
// never die from damage, just advance to the next node
if ( ( GetHealth() - newInfo.GetDamage() ) < 1 )
{
newInfo.SetDamage( 0 );
Remember( bits_MEMORY_ADVANCE_NODE );
DevMsg( 2, "BM: Finished node health!!!\n" );
}
DevMsg( 2, "BM Health: %f\n", GetHealth() - newInfo.GetDamage() );
return BaseClass::OnTakeDamage( newInfo );
}
//-----------------------------------------------------------------------------
// Purpose: Note our last attacked time
//-----------------------------------------------------------------------------
int CObjectSentrygun::OnTakeDamage( const CTakeDamageInfo &info )
{
CTakeDamageInfo newInfo = info;
// As we increase in level, we get more resistant to minigun bullets, to compensate for
// our increased surface area taking more minigun hits.
if ( ( info.GetDamageType() & DMG_BULLET ) && ( info.GetDamageCustom() == TF_DMG_CUSTOM_MINIGUN ) )
{
float flDamage = newInfo.GetDamage();
flDamage *= ( 1.0 - m_flHeavyBulletResist );
newInfo.SetDamage( flDamage );
}
// Check to see if we are being sapped.
if ( HasSapper() )
{
// Get the sapper owner.
CBaseObject *pSapper = GetObjectOfTypeOnMe( OBJ_ATTACHMENT_SAPPER );
Assert( pSapper );
// Take less damage if the owner is causing additional damage.
if ( pSapper && ( info.GetAttacker() == pSapper->GetOwner() ) )
{
float flDamage = newInfo.GetDamage() * SENTRYGUN_SAPPER_OWNER_DAMAGE_MODIFIER;
newInfo.SetDamage( flDamage );
}
}
int iDamageTaken = BaseClass::OnTakeDamage( newInfo );
if ( iDamageTaken > 0 )
{
m_flLastAttackedTime = gpGlobals->curtime;
}
return iDamageTaken;
}
int CNPC_Tentacle::OnTakeDamage( const CTakeDamageInfo &info )
{
CTakeDamageInfo i = info;
//Don't allow the tentacle to die. Instead set health to 1, so we can do our own death and rebirth
if( (int)i.GetDamage() >= m_iHealth )
{
i.SetDamage( 0.0f );
m_iHealth = 1;
}
return BaseClass::OnTakeDamage( i );
}
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 );
}
void CNPC_Sentry::SentryTouch( CBaseEntity *pOther )
{
//trigger the sentry to turn on if a monster or player touches it
if ( pOther && (pOther->IsPlayer() || FBitSet ( pOther->GetFlags(), FL_NPC )) )
{
CTakeDamageInfo info;
info.SetAttacker( pOther );
info.SetInflictor( pOther );
info.SetDamage( 0 );
TakeDamage(info);
}
}
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;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pOther -
//-----------------------------------------------------------------------------
void CDODBaseRocket::RocketTouch( CBaseEntity *pOther )
{
Assert( pOther );
if ( !pOther->IsSolid() || pOther->IsSolidFlagSet(FSOLID_VOLUME_CONTENTS) )
return;
if ( pOther->GetCollisionGroup() == COLLISION_GROUP_WEAPON )
return;
// if we hit the skybox, just disappear
const trace_t &tr = CBaseEntity::GetTouchTrace();
const trace_t *p = &tr;
trace_t *newTrace = const_cast<trace_t*>(p);
if( tr.surface.flags & SURF_SKY )
{
UTIL_Remove( this );
return;
}
if( !pOther->IsPlayer() )
{
CTakeDamageInfo info;
info.SetAttacker( this );
info.SetInflictor( this );
info.SetDamage( 50 );
info.SetDamageForce( vec3_origin ); // don't worry about this not having a damage force.
// It will explode on touch and impart its own forces
info.SetDamageType( DMG_CLUB );
Vector dir;
AngleVectors( GetAbsAngles(), &dir );
pOther->DispatchTraceAttack( info, dir, newTrace );
ApplyMultiDamage();
}
if( pOther->IsAlive() )
{
Explode();
}
// else we will continue our movement
}
void CNPC_AlienGrunt::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr )
{
CTakeDamageInfo ainfo = info;
float flDamage = ainfo.GetDamage();
if ( ptr->hitgroup == 10 && (ainfo.GetDamageType() & (DMG_BULLET | DMG_SLASH | DMG_CLUB)))
{
// hit armor
if ( m_flDamageTime != gpGlobals->curtime || (random->RandomInt(0,10) < 1) )
{
CPVSFilter filter( ptr->endpos );
te->ArmorRicochet( filter, 0.0, &ptr->endpos, &ptr->plane.normal );
m_flDamageTime = gpGlobals->curtime;
}
if ( random->RandomInt( 0, 1 ) == 0 )
{
Vector vecTracerDir = vecDir;
vecTracerDir.x += random->RandomFloat( -0.3, 0.3 );
vecTracerDir.y += random->RandomFloat( -0.3, 0.3 );
vecTracerDir.z += random->RandomFloat( -0.3, 0.3 );
vecTracerDir = vecTracerDir * -512;
Vector vEndPos = ptr->endpos + vecTracerDir;
UTIL_Tracer( ptr->endpos, vEndPos, ENTINDEX( edict() ) );
}
flDamage -= 20;
if (flDamage <= 0)
flDamage = 0.1;// don't hurt the monster much, but allow bits_COND_LIGHT_DAMAGE to be generated
ainfo.SetDamage( flDamage );
}
else
{
SpawnBlood( ptr->endpos, vecDir, BloodColor(), flDamage);// a little surface blood.
TraceBleed( flDamage, vecDir, ptr, ainfo.GetDamageType() );
}
AddMultiDamage( ainfo, this );
}
void CAI_BaseHumanoid::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr )
{
bool bSneakAttacked = false;
if( ptr->hitgroup == HITGROUP_HEAD )
{
if ( info.GetAttacker() && info.GetAttacker()->IsPlayer() && info.GetAttacker() != GetEnemy() && !IsInAScript() )
{
// Shot in the head by a player I've never seen. In this case the player
// has gotten the drop on this enemy and such an attack is always lethal (at close range)
bSneakAttacked = true;
AIEnemiesIter_t iter;
for( AI_EnemyInfo_t *pMemory = GetEnemies()->GetFirst(&iter); pMemory != NULL; pMemory = GetEnemies()->GetNext(&iter) )
{
if ( pMemory->hEnemy == info.GetAttacker() )
{
bSneakAttacked = false;
break;
}
}
float flDist;
flDist = (info.GetAttacker()->GetAbsOrigin() - GetAbsOrigin()).Length();
if( flDist > SNEAK_ATTACK_DIST )
{
bSneakAttacked = false;
}
}
}
if( bSneakAttacked )
{
CTakeDamageInfo newInfo = info;
newInfo.SetDamage( GetHealth() );
BaseClass::TraceAttack( newInfo, vecDir, ptr );
return;
}
BaseClass::TraceAttack( info, vecDir, ptr );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::BusterDetachThink()
{
SetNextThink( gpGlobals->curtime + 0.1f );
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector( 0, 0, 1200), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
if( fabs(tr.startpos.z - tr.endpos.z) < 240.0f )
{
SetThink(NULL);
EmitSound( "Weapon_StriderBuster.Dud_Detonate" );
DispatchParticleEffect( "striderbuster_break_flechette", GetAbsOrigin(), GetAbsAngles() );
SetHealth( 0 );
CTakeDamageInfo info;
info.SetDamage( 1.0f );
info.SetAttacker( this );
info.SetInflictor( this );
Shatter(this);
}
}
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:
//-----------------------------------------------------------------------------
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;
}
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 );
}
void CBaseTurret::TraceAttack( const CTakeDamageInfo &inputInfo, const Vector &vecDir, trace_t *ptr )
{
CTakeDamageInfo info = inputInfo;
if ( ptr->hitgroup == 10 )
{
// hit armor
if ( m_flDamageTime != gpGlobals->curtime || (random->RandomInt(0,10) < 1) )
{
g_pEffects->Ricochet( ptr->endpos, (vecDir*-1.0f) );
m_flDamageTime = gpGlobals->curtime;
}
info.SetDamage( 0.1 );// don't hurt the NPC much, but allow bits_COND_LIGHT_DAMAGE to be generated
}
if ( !m_takedamage )
return;
AddMultiDamage( info, this );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CPropVehicleChoreoGeneric::OnTakeDamage( const CTakeDamageInfo &inputInfo )
{
CTakeDamageInfo info = inputInfo;
info.ScaleDamage( 25 );
// reset the damage
info.SetDamage( inputInfo.GetDamage() );
// Check to do damage to prisoner
if ( m_hPlayer != NULL )
{
// Take no damage from physics damages
if ( info.GetDamageType() & DMG_CRUSH )
return 0;
// Take the damage
m_hPlayer->TakeDamage( info );
}
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: Slowly destroy the object I'm attached to
//-----------------------------------------------------------------------------
void CObjectSapper::SapperThink( void )
{
if ( !GetTeam() )
return;
CBaseObject *pObject = GetParentObject();
if ( !pObject )
{
DestroyObject();
return;
}
SetNextThink( gpGlobals->curtime + 0.1, SAPPER_THINK_CONTEXT );
// Don't bring objects back from the dead
if ( !pObject->IsAlive() || pObject->IsDying() )
return;
// how much damage to give this think?
float flTimeSinceLastThink = gpGlobals->curtime - m_flLastThinkTime;
float flDamageToGive = ( flTimeSinceLastThink ) * obj_sapper_amount.GetFloat();
// add to accumulator
m_flSapperDamageAccumulator += flDamageToGive;
int iDamage = (int)m_flSapperDamageAccumulator;
m_flSapperDamageAccumulator -= iDamage;
CTakeDamageInfo info;
info.SetDamage( iDamage );
info.SetAttacker( this );
info.SetInflictor( this );
info.SetDamageType( DMG_CRUSH );
pObject->TakeDamage( info );
m_flLastThinkTime = gpGlobals->curtime;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CPropCrane::OnTakeDamage( const CTakeDamageInfo &inputInfo )
{
//Do scaled up physics damage to the car
CTakeDamageInfo info = inputInfo;
info.ScaleDamage( 25 );
// reset the damage
info.SetDamage( inputInfo.GetDamage() );
//Check to do damage to driver
if ( m_hPlayer != NULL )
{
//Take no damage from physics damages
if ( info.GetDamageType() & DMG_CRUSH )
return 0;
//Take the damage
m_hPlayer->TakeDamage( info );
}
return 0;
}
//=========================================================
// TraceAttack - being attacked
//=========================================================
void CNPC_BaseTurret::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr )
{
CTakeDamageInfo ainfo = info;
if ( ptr->hitgroup == 10 )
{
// hit armor
if ( m_flDamageTime != gpGlobals->curtime || (random->RandomInt(0,10) < 1) )
{
g_pEffects->Ricochet( ptr->endpos, ptr->plane.normal );
m_flDamageTime = gpGlobals->curtime;
}
ainfo.SetDamage( 0.1 );// don't hurt the monster much, but allow bits_COND_LIGHT_DAMAGE to be generated
}
if ( m_takedamage == DAMAGE_NO )
return;
//DevMsg( 1, "traceattack: %f\n", ainfo.GetDamage() );
AddMultiDamage( info, this );
}
//=========================================================
// Pensamiento: Nectar
//=========================================================
void CFR_Player::NectarThink()
{
// Menos nectar para tu cuerpo.
if ( random->RandomInt(0, 5) <= 2 && m_iNectar > 0 )
--m_iNectar;
DevMsg("m_iEmptyNectarSeconds: %i \r\n", m_iEmptyNectarSeconds);
// ¡Te has quedado sin nectar!
if ( m_iNectar <= 0 )
{
// Todavia te quedan unos segundos para recuperar el nectar perdido.
if ( m_iEmptyNectarSeconds > 0 )
--m_iEmptyNectarSeconds;
// Sin nectar y sin segundos. Le quitamos salud cada 5 segs.
else if ( GetLastDamageTime() < (gpGlobals->curtime - 5) )
{
CTakeDamageInfo damage;
damage.SetAttacker(this);
damage.SetInflictor(this);
damage.SetDamageType(DMG_GENERIC);
damage.SetDamage(random->RandomInt(10, 30)); // Entre 10 a 30 de daño.
TakeDamage(damage);
}
}
// Tienes nectar, restaurar los segundos para recuperarlo.
else if ( m_iEmptyNectarSeconds != fr_emptynectar_seconds.GetInt() )
m_iEmptyNectarSeconds = fr_emptynectar_seconds.GetInt();
m_HL2Local.m_iNectar = GetNectar();
SetNextThink(gpGlobals->curtime + 1, "NectarContext");
}