void CPhysicsObject::ApplyForceOffset(const Vector &forceVector, const Vector &worldPosition) {
if (!IsMoveable() || !IsMotionEnabled()) {
return;
}
Wake();
Vector local;
WorldToLocal(&local, worldPosition);
btVector3 force, offset;
ConvertForceImpulseToBull(forceVector, force);
ConvertPosToBull(local, offset);
m_pObject->applyImpulse(force, offset);
Wake();
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::OnPhysGunDrop( CBasePlayer *pPhysGunUser, PhysGunDrop_t Reason )
{
m_hPhysicsAttacker = pPhysGunUser;
m_flLastPhysicsInfluenceTime = gpGlobals->curtime;
m_flTimeGrabbed = FLT_MAX;
m_bHeldByPhysgun = false;
if( m_iMineState == MINE_STATE_ARMED )
{
// Put the mine back to searching.
Wake( false );
return;
}
if( Reason == DROPPED_BY_CANNON )
{
// Set to lock down to ground again.
m_bPlacedByPlayer = true;
OpenHooks( true );
SetMineState( MINE_STATE_DEPLOY );
}
else if ( Reason == LAUNCHED_BY_CANNON )
{
SetMineState( MINE_STATE_LAUNCHED );
}
}
void
Schedulable::Update(Time t)
{
short nWake=0;
if (instances.CountItems() == 0)
return;
instances.Lock();
for (short i=0; i<instances.CountItems(); i++) {
Instance *inst = (Instance *)instances.ItemAt(i);
if ( t>= inst->startTime
&& t <= inst->startTime + inst->duration
&& inst->status != STATUS_RUNNING) {
Wake(inst);
} else if ( (t< inst->startTime
|| t >= inst->startTime + inst->duration)
&& inst->status == STATUS_RUNNING) {
Sleep(inst);
}
if (inst->status == STATUS_RUNNING) {
nWake++;
Run(inst);
}
}
if (nWake == 0) {
;
}
instances.Unlock();
}
void PowerdScheduler::ScheduledWakeup()
{
LOG_AM_TRACE("Entering function %s", __FUNCTION__);
LOG_AM_DEBUG("Powerd wakeup callback received");
Wake();
}
/*virtual*/ void WBCompEldSleeper::HandleEvent(const WBEvent& Event) {
XTRACE_FUNCTION;
Super::HandleEvent(Event);
STATIC_HASHED_STRING(OnDamaged);
STATIC_HASHED_STRING(OnAINoise);
const HashedString EventName = Event.GetEventName();
if (EventName == sOnDamaged) {
Wake();
} else if (EventName == sOnAINoise) {
STATIC_HASHED_STRING(EventOwner);
WBEntity* const pEventOwner = Event.GetEntity(sEventOwner);
ASSERT(pEventOwner);
if (pEventOwner == GetEntity()) {
// Ignore AI noises from self (see SensorHearing for more details).
} else {
STATIC_HASHED_STRING(NoiseLocation);
const Vector NoiseLocation = Event.GetVector(sNoiseLocation);
STATIC_HASHED_STRING(NoiseRadius);
const float NoiseRadius = Event.GetFloat(sNoiseRadius);
HandleNoise(NoiseLocation, NoiseRadius);
}
}
}
void State::Update(double deltaTime) {
if(IsActive() == false) {
ClearImpulses();
ClearForces();
SetVelocity(0.0, 0.0);
SetAcceleration(0.0, 0.0);
return;
}
a2de::Vector2D total_forces;
std::for_each(_forces.begin(), _forces.end(), [&total_forces] (ForceContainer::value_type& current_force) mutable -> a2de::Vector2D
{
if(current_force.second < 0.0) return Vector2D();
total_forces += current_force.first;
return total_forces;
});
Vector2D total_impulses = std::accumulate(_impulses.begin(), _impulses.end(), Vector2D());
Vector2D F(total_forces + total_impulses);
ClearImpulses();
double mass = GetMass();
//If static body, do nothing.
if(Math::IsEqual(mass, 0.0)) {
ClearImpulses();
ClearForces();
SetVelocity(0.0, 0.0);
SetAcceleration(0.0, 0.0);
Sleep();
return;
}
//Integrate from constant acceleration.
//a = F / m
//v = at + v;
//p = (1/2)at^2 + vt + p
SetAcceleration(F / mass);
SetVelocity(GetAcceleration() * deltaTime + GetVelocity());
SetPosition(((0.5 * GetAcceleration()) * deltaTime * deltaTime) + (GetVelocity() * deltaTime) + GetPosition());
_forces.remove_if([=](ForceContainer::value_type& current_force)->bool {
current_force.second -= deltaTime;
return (current_force.second < 0.0);
});
if(_impulses.empty() && _forces.empty() &&
((a2de::Math::IsEqual(_acceleration.GetX(), 0.0) && a2de::Math::IsEqual(_acceleration.GetY(), 0.0)) &&
(a2de::Math::IsEqual(_velocity.GetX(), 0.0) && a2de::Math::IsEqual(_velocity.GetY(), 0.0))))
{
SetVelocity(0.0, 0.0);
SetAcceleration(0.0, 0.0);
Sleep();
} else {
Wake();
}
}
void GlibScheduler::TimeoutCallback()
{
LOG_TRACE("Scheduler timeout callback");
m_timeout.reset();
Wake();
}
void CPhysicsObject::ApplyTorqueCenter(const AngularImpulse &torque) {
if (!IsMoveable() || !IsMotionEnabled()) {
return;
}
Wake();
btVector3 bullTorque;
ConvertAngularImpulseToBull(torque, bullTorque);
m_pObject->applyTorqueImpulse(bullTorque);
}
void Thread::EnqueueAPC(APC *apc)
{
cpu_flags fl = DisableInterrupts();
fApcQueue.Enqueue(apc);
#if 0
if (GetState() == kThreadWaiting)
Wake(E_INTERRUPTED);
#endif
RestoreInterrupts(fl);
}
void CPhysicsObject::ApplyForceCenter(const Vector &forceVector) {
if (!IsMoveable() || !IsMotionEnabled()) {
return;
}
Wake();
// forceVector is in kg*in/s*time
// bullet takes forces in newtons, aka kg*m/s*time
btVector3 force;
ConvertForceImpulseToBull(forceVector, force);
m_pObject->applyCentralImpulse(force);
}
void CPhysicsObject::ApplyTorqueCenter( const AngularImpulse &torqueImpulse )
{
//Assert(IsMoveable());
if ( !IsMoveable() )
return;
IVP_U_Float_Point ivpTorque;
ConvertAngularImpulseToIVP( torqueImpulse, ivpTorque );
IVP_Core *core = m_pObject->get_core();
core->async_rot_push_core_multiple_ws( &ivpTorque, 1.0 );
core->rot_speed_change.k[0] = clamp( core->rot_speed_change.k[0], -MAX_ROT_SPEED, MAX_ROT_SPEED );
core->rot_speed_change.k[1] = clamp( core->rot_speed_change.k[1], -MAX_ROT_SPEED, MAX_ROT_SPEED );
core->rot_speed_change.k[2] = clamp( core->rot_speed_change.k[2], -MAX_ROT_SPEED, MAX_ROT_SPEED );
Wake();
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::Spawn()
{
Precache();
Wake( false );
SetModel("models/props_combine/combine_mine01.mdl");
SetSolid( SOLID_VPHYSICS );
m_hSprite.Set( NULL );
m_takedamage = DAMAGE_EVENTS_ONLY;
// Find my feet!
m_iHookN = LookupPoseParameter( "blendnorth" );
m_iHookE = LookupPoseParameter( "blendeast" );
m_iHookS = LookupPoseParameter( "blendsouth" );
m_iAllHooks = LookupPoseParameter( "blendstates" );
m_flHookPositions = 0;
SetHealth( 100 );
m_bBounce = true;
SetSequence( SelectWeightedSequence( ACT_IDLE ) );
OpenHooks( true );
m_bHeldByPhysgun = false;
m_iFlipAttempts = 0;
if( !GetParent() )
{
// Create vphysics now if I'm not being carried.
CreateVPhysics();
}
m_flTimeGrabbed = FLT_MAX;
if( m_bDisarmed )
{
SetMineState( MINE_STATE_DORMANT );
}
else
{
SetMineState( MINE_STATE_DEPLOY );
}
}
void WBCompEldSleeper::HandleNoise(const Vector& NoiseLocation,
const float NoiseRadius) {
if (m_IsAwake) {
return;
}
WBCompEldSensorHearing* const pHearingSensor =
GET_WBCOMP(GetEntity(), EldSensorHearing);
ASSERT(pHearingSensor);
float Certainty = 0.0f;
if (!pHearingSensor->GetNoiseCertainty(NoiseLocation, NoiseRadius,
Certainty)) {
return;
}
if (Certainty >= m_NoiseThreshold) {
Wake();
}
}
void CPhysicsObject::SetVelocity( const Vector *velocity, const AngularImpulse *angularVelocity )
{
Assert(IsMoveable());
if ( !IsMoveable() )
return;
IVP_Core *core = m_pObject->get_core();
Wake();
if ( velocity )
{
ConvertPositionToIVP( *velocity, core->speed_change );
core->speed.set_to_zero();
}
if ( angularVelocity )
{
ConvertAngularImpulseToIVP( *angularVelocity, core->rot_speed_change );
core->rot_speed.set_to_zero();
}
}
void CPhysicsObject::AddVelocity(const Vector *velocity, const AngularImpulse *angularVelocity) {
if (!velocity && !angularVelocity) return;
if (!IsMoveable() || !IsMotionEnabled()) {
return;
}
Wake();
btVector3 bullvelocity, bullangular;
if (velocity) {
ConvertPosToBull(*velocity, bullvelocity);
m_pObject->setLinearVelocity(m_pObject->getLinearVelocity() + bullvelocity);
}
// Angular velocity is supplied in local space.
if (angularVelocity) {
ConvertAngularImpulseToBull(*angularVelocity, bullangular);
bullangular = m_pObject->getWorldTransform().getBasis() * bullangular;
m_pObject->setAngularVelocity(m_pObject->getAngularVelocity() + bullangular);
}
}
void CPhysicsObject::ApplyForceOffset( const Vector &forceVector, const Vector &worldPosition )
{
// Assert(IsMoveable());
if ( !IsMoveable() )
return;
IVP_U_Point pos;
IVP_U_Float_Point force;
ConvertForceImpulseToIVP( forceVector, force );
ConvertPositionToIVP( worldPosition, pos );
IVP_Core *core = m_pObject->get_core();
core->async_push_core_ws( &pos, &force );
core->speed_change.k[0] = clamp( core->speed_change.k[0], -MAX_SPEED, MAX_SPEED );
core->speed_change.k[1] = clamp( core->speed_change.k[1], -MAX_SPEED, MAX_SPEED );
core->speed_change.k[2] = clamp( core->speed_change.k[2], -MAX_SPEED, MAX_SPEED );
core->rot_speed_change.k[0] = clamp( core->rot_speed_change.k[0], -MAX_ROT_SPEED, MAX_ROT_SPEED );
core->rot_speed_change.k[1] = clamp( core->rot_speed_change.k[1], -MAX_ROT_SPEED, MAX_ROT_SPEED );
core->rot_speed_change.k[2] = clamp( core->rot_speed_change.k[2], -MAX_ROT_SPEED, MAX_ROT_SPEED );
Wake();
}
void Lamp::readSerial(char data[],unsigned char buffLen)
{
_idleTime=0;
char rxData [buffLen];
for (int i=0; i<= buffLen -1; i++) rxData[i] = data[i];
if (_sleeping)
{
if (strcmp(rxData,"t") ==0) LampStatus(!isLampOn());
else Wake();
}
else
{
if (strcmp(rxData,"idx") ==0);// Serial.println(menuPosition(),HEX);
else if (strcmp(rxData,"c") ==0) updateMenuIndex('c');
else if (strcmp(rxData,"lmp") ==0) LampStatus(!isLampOn());
else if (strcmp(rxData,"h") ==0) updateMenuIndex('h');
else if (strcmp(rxData,"l") ==0) updateMenuIndex('l');
else if (strcmp(rxData,"r") ==0) updateMenuIndex('r');
else if (strcmp(rxData,"t") ==0) updateMenuIndex('t');
}
}
// UNDONE: Limit these?
void CPhysicsObject::AddVelocity( const Vector *velocity, const AngularImpulse *angularVelocity )
{
Assert(IsMoveable());
if ( !IsMoveable() )
return;
IVP_Core *core = m_pObject->get_core();
Wake();
if ( velocity )
{
IVP_U_Float_Point ivpVelocity;
ConvertPositionToIVP( *velocity, ivpVelocity );
core->speed_change.add( &ivpVelocity );
}
if ( angularVelocity )
{
IVP_U_Float_Point ivpAngularVelocity;
ConvertAngularImpulseToIVP( *angularVelocity, ivpAngularVelocity );
core->rot_speed_change.add(&ivpAngularVelocity);
}
}
void LongPollThread::fireTermination()
{
Terminated = true;
Wake();
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::SearchThink()
{
if( !UTIL_FindClientInPVS(edict()) )
{
// Sleep!
SetNextThink( gpGlobals->curtime + 0.5 );
return;
}
if( (CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI) )
{
if( IsAwake() )
{
Wake(false);
}
SetNextThink( gpGlobals->curtime + 0.5 );
return;
}
SetNextThink( gpGlobals->curtime + 0.1 );
StudioFrameAdvance();
if( m_pConstraint && gpGlobals->curtime - m_flTimeGrabbed >= 1.0f )
{
m_OnPulledUp.FireOutput( this, this );
SetMineState( MINE_STATE_CAPTIVE );
return;
}
float flNearestNPCDist = FindNearestNPC();
if( flNearestNPCDist <= BOUNCEBOMB_WARN_RADIUS )
{
if( !IsAwake() )
{
Wake( true );
}
}
else
{
if( IsAwake() )
{
Wake( false );
}
return;
}
if( flNearestNPCDist <= BOUNCEBOMB_DETONATE_RADIUS && !IsFriend( m_hNearestNPC ) )
{
if( m_bBounce )
{
SetMineState( MINE_STATE_TRIGGERED );
}
else
{
// Don't pop up in the air, just explode if the NPC gets closer than explode radius.
SetThink( &CBounceBomb::ExplodeThink );
SetNextThink( gpGlobals->curtime + m_flExplosionDelay );
}
}
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::Spawn()
{
Precache();
Wake( false );
SetModel("models/props_combine/combine_mine01.mdl");
SetSolid( SOLID_VPHYSICS );
m_hSprite.Set( NULL );
m_takedamage = DAMAGE_EVENTS_ONLY;
// Find my feet!
m_iHookN = LookupPoseParameter( "blendnorth" );
m_iHookE = LookupPoseParameter( "blendeast" );
m_iHookS = LookupPoseParameter( "blendsouth" );
m_iAllHooks = LookupPoseParameter( "blendstates" );
m_flHookPositions = 0;
SetHealth( 100 );
m_bBounce = true;
SetSequence( SelectWeightedSequence( ACT_IDLE ) );
OpenHooks( true );
m_bHeldByPhysgun = false;
m_iFlipAttempts = 0;
if( !GetParent() )
{
// Create vphysics now if I'm not being carried.
CreateVPhysics();
}
m_flTimeGrabbed = FLT_MAX;
if( m_bDisarmed )
{
SetMineState( MINE_STATE_DORMANT );
}
else
{
SetMineState( MINE_STATE_DEPLOY );
}
// default to a different skin for cavern turrets (unless explicitly overridden)
if ( m_iModification == MINE_MODIFICATION_CAVERN )
{
// look for this value in the first datamap
// loop through the data description list, restoring each data desc block
datamap_t *dmap = GetDataDescMap();
bool bFoundSkin = false;
// search through all the readable fields in the data description, looking for a match
for ( int i = 0; i < dmap->dataNumFields; ++i )
{
if ( dmap->dataDesc[i].flags & (FTYPEDESC_OUTPUT | FTYPEDESC_KEY) )
{
if ( !Q_stricmp(dmap->dataDesc[i].externalName, "Skin") )
{
bFoundSkin = true;
break;
}
}
}
if (!bFoundSkin)
{
// select a random skin for the mine. Actually, we'll cycle through the available skins
// using a static variable to provide better distribution. The static isn't saved but
// really it's only cosmetic.
static unsigned int nextSkin = MINE_CITIZEN_SKIN_MIN;
m_nSkin = nextSkin;
// increment the skin for next time
nextSkin = (nextSkin >= MINE_CITIZEN_SKIN_MAX) ? MINE_CITIZEN_SKIN_MIN : nextSkin + 1;
}
// pretend like the player set me down.
m_bPlacedByPlayer = true;
}
}
void CPhysicsObject::InitFromTemplate( CPhysicsEnvironment *pEnvironment, void *pGameData, const vphysics_save_cphysicsobject_t &objectTemplate )
{
m_collideType = objectTemplate.collideType;
IVP_Template_Real_Object ivpObjectTemplate;
IVP_U_Quat rotation;
IVP_U_Point pos;
ConvertRotationToIVP( objectTemplate.angles, rotation );
ConvertPositionToIVP( objectTemplate.origin, pos );
ivpObjectTemplate.mass = objectTemplate.mass;
if ( objectTemplate.materialIndex >= 0 )
{
ivpObjectTemplate.material = physprops->GetIVPMaterial( objectTemplate.materialIndex );
}
else
{
ivpObjectTemplate.material = physprops->GetIVPMaterial( physprops->GetSurfaceIndex( "default" ) );
}
Assert( ivpObjectTemplate.material );
// HACKHACK: Pass this name in for debug
ivpObjectTemplate.set_name(objectTemplate.pName);
ivpObjectTemplate.set_nocoll_group_ident( NULL );
ivpObjectTemplate.physical_unmoveable = objectTemplate.isStatic ? IVP_TRUE : IVP_FALSE;
ivpObjectTemplate.rot_inertia_is_factor = IVP_TRUE;
ivpObjectTemplate.rot_inertia.set( 1,1,1 );
ivpObjectTemplate.rot_speed_damp_factor.set( objectTemplate.rotSpeedDamping, objectTemplate.rotSpeedDamping, objectTemplate.rotSpeedDamping );
ivpObjectTemplate.speed_damp_factor = objectTemplate.speedDamping;
IVP_U_Matrix massCenterMatrix;
massCenterMatrix.init();
const Vector *massOverride = 0;
if ( objectTemplate.massCenterOverride != vec3_origin )
{
IVP_U_Point center;
ConvertPositionToIVP( objectTemplate.massCenterOverride, center );
massCenterMatrix.shift_os( ¢er );
ivpObjectTemplate.mass_center_override = &massCenterMatrix;
massOverride = &objectTemplate.massCenterOverride;
}
IVP_Real_Object *realObject = NULL;
if ( m_collideType == COLLIDE_BALL )
{
IVP_Template_Ball ballTemplate;
ballTemplate.radius = ConvertDistanceToIVP( objectTemplate.sphereRadius );
realObject = pEnvironment->GetIVPEnvironment()->create_ball( &ballTemplate, &ivpObjectTemplate, &rotation, &pos );
}
else
{
const IVP_Compact_Surface *pSurface = (const IVP_Compact_Surface *)objectTemplate.pCollide;
IVP_SurfaceManager_Polygon *surman = new IVP_SurfaceManager_Polygon( pSurface );
realObject = pEnvironment->GetIVPEnvironment()->create_polygon(surman, &ivpObjectTemplate, &rotation, &pos);
}
Init( realObject, objectTemplate.materialIndex, objectTemplate.volume, objectTemplate.dragCoefficient, objectTemplate.dragCoefficient, massOverride );
SetInertia( objectTemplate.rotInertia );
// will wake up the object
if ( objectTemplate.velocity.LengthSqr() != 0 || objectTemplate.angVelocity.LengthSqr() != 0 )
{
Assert( !objectTemplate.isAsleep );
SetVelocity( &objectTemplate.velocity, &objectTemplate.angVelocity );
}
SetCallbackFlags( (unsigned short) objectTemplate.callbacks );
SetGameFlags( (unsigned short) objectTemplate.gameFlags );
SetGameData( pGameData );
SetContents( objectTemplate.contentsMask );
if ( objectTemplate.dragEnabled )
{
Assert( !objectTemplate.isStatic );
EnableDrag( true );
}
if ( !objectTemplate.motionEnabled )
{
Assert( !objectTemplate.isStatic );
EnableMotion( false );
}
if ( objectTemplate.isTrigger )
{
BecomeTrigger();
}
if ( !objectTemplate.gravityEnabled )
{
EnableGravity( false );
}
if ( objectTemplate.collisionEnabled )
{
EnableCollisions( true );
}
if ( !objectTemplate.isAsleep )
{
Assert( !objectTemplate.isStatic );
Wake();
}
m_pShadow = NULL;
}
void
XmppClient::OnAuthDone() {
Wake();
}
void NSBContext::OnClick()
{
if (WaitInterrupt || (pText && !pText->Advance()))
Wake();
}
void NSBContext::TryWake()
{
if (pObject && pObject->Action())
Wake();
}
ScreenSaverWaker::ScreenSaverWaker(QObject* parent) : QObject(parent)
{
QObject::connect(&timer,SIGNAL(timeout()),this,SLOT(Wake()));
}
void State::ApplyForce(const Vector2D& force, double duration) {
if(duration < 0.0) return;
Wake();
_forces.push_back(std::make_pair(force, duration));
}
int CE_Cycler_Fix::OnTakeDamage_Alive(const CTakeDamageInfo& info)
{
#if 0
return BaseClass::OnTakeDamage_Alive(info);
#endif
Forget( bits_MEMORY_INCOVER );
if ( !CCombatCharacter::FAKE_OnTakeDamage_Alive( info ) )
return 0;
if ( GetSleepState() == AISS_WAITING_FOR_THREAT )
Wake();
CEntity *attacker = CEntity::Instance(info.GetAttacker());
// NOTE: This must happen after the base class is called; we need to reduce
// health before the pain sound, since some NPCs use the final health
// level as a modifier to determine which pain sound to use.
// REVISIT: Combine soldiers shoot each other a lot and then talk about it
// this improves that case a bunch, but it seems kind of harsh.
if ( !GetSquad() || !GetSquad()->SquadIsMember( attacker ) )
{
PainSound( info );// "Ouch!"
}
// See if we're running a dynamic interaction that should break when I am damaged.
if ( IsActiveDynamicInteraction() )
{
ScriptedNPCInteraction_t *pInteraction = GetRunningDynamicInteraction();
if ( pInteraction->iLoopBreakTriggerMethod & SNPCINT_LOOPBREAK_ON_DAMAGE )
{
CEAI_ScriptedSequence *_m_hCine = Get_m_hCine();
// Can only break when we're in the action anim
if ( _m_hCine->IsPlayingAction() )
{
_m_hCine->StopActionLoop( true );
}
}
}
// If we're not allowed to die, refuse to die
// Allow my interaction partner to kill me though
if ( m_iHealth <= 0 && HasInteractionCantDie() && attacker != m_hInteractionPartner )
{
m_iHealth = 1;
}
// -----------------------------------
// Fire outputs
// -----------------------------------
if ( m_flLastDamageTime != gpGlobals->curtime )
{
// only fire once per frame
m_OnDamaged->FireOutput( attacker, this);
if( attacker && attacker->IsPlayer() )
{
m_OnDamagedByPlayer->FireOutput( attacker, this );
// This also counts as being harmed by player's squad.
m_OnDamagedByPlayerSquad->FireOutput( attacker, this );
} else {
// See if the person that injured me is an NPC.
CAI_NPC *pAttacker = dynamic_cast<CAI_NPC *>( attacker );
if( pAttacker && pAttacker->IsAlive() )
{
if( pAttacker->GetSquad() != NULL && pAttacker->IsInPlayerSquad() )
{
m_OnDamagedByPlayerSquad->FireOutput( attacker, this );
}
}
}
}
if( (info.GetDamageType() & DMG_CRUSH) && !(info.GetDamageType() & DMG_PHYSGUN) && info.GetDamage() >= MIN_PHYSICS_FLINCH_DAMAGE )
{
SetCondition( COND_PHYSICS_DAMAGE );
}
if ( m_iHealth <= ( m_iMaxHealth / 2 ) )
{
m_OnHalfHealth->FireOutput( attacker, this );
}
// react to the damage (get mad)
if ( ( (GetFlags() & FL_NPC) == 0 ) || !attacker )
return 1;
// If the attacker was an NPC or client update my position memory
if ( attacker->GetFlags() & (FL_NPC | FL_CLIENT) )
{
// ------------------------------------------------------------------
// DO NOT CHANGE THIS CODE W/O CONSULTING
// Only update information about my attacker I don't see my attacker
// ------------------------------------------------------------------
if ( !FInViewCone_Entity( info.GetAttacker() ) || !FVisible_Entity( info.GetAttacker() ) )
{
// -------------------------------------------------------------
// If I have an inflictor (enemy / grenade) update memory with
// position of inflictor, otherwise update with an position
// estimate for where the attack came from
// ------------------------------------------------------
Vector vAttackPos;
CEntity *inflictor = CEntity::Instance(info.GetInflictor());
if (inflictor)
{
vAttackPos = inflictor->GetAbsOrigin();
}
else
{
vAttackPos = (GetAbsOrigin() + ( *g_vecAttackDir * 64 ));
}
// ----------------------------------------------------------------
// If I already have an enemy, assume that the attack
// came from the enemy and update my enemy's position
// unless I already know about the attacker or I can see my enemy
// ----------------------------------------------------------------
if ( GetEnemy() != NULL &&
!GetEnemies()->HasMemory( info.GetAttacker() ) &&
!HasCondition(COND_SEE_ENEMY) )
{
UpdateEnemyMemory(GetEnemy_CBase(), vAttackPos, GetEnemy_CBase());
}
// ----------------------------------------------------------------
// If I already know about this enemy, update his position
// ----------------------------------------------------------------
else if (GetEnemies()->HasMemory( info.GetAttacker() ))
{
UpdateEnemyMemory(info.GetAttacker(), vAttackPos);
}
// -----------------------------------------------------------------
// Otherwise just note the position, but don't add enemy to my list
// -----------------------------------------------------------------
else
{
UpdateEnemyMemory(NULL, vAttackPos);
}
}
// add pain to the conditions
if ( IsLightDamage( info ) )
{
SetCondition( COND_LIGHT_DAMAGE );
}
if ( IsHeavyDamage( info ) )
{
SetCondition( COND_HEAVY_DAMAGE );
}
ForceGatherConditions();
// Keep track of how much consecutive damage I have recieved
if ((gpGlobals->curtime - m_flLastDamageTime) < 1.0)
{
m_flSumDamage += info.GetDamage();
}
else
{
m_flSumDamage = info.GetDamage();
}
m_flLastDamageTime = gpGlobals->curtime;
if ( attacker && attacker->IsPlayer() )
m_flLastPlayerDamageTime = gpGlobals->curtime;
GetEnemies()->OnTookDamageFrom( info.GetAttacker() );
if (m_flSumDamage > m_iMaxHealth*0.3)
{
SetCondition(COND_REPEATED_DAMAGE);
}
NotifyFriendsOfDamage( info.GetAttacker() );
}
// ---------------------------------------------------------------
// Insert a combat sound so that nearby NPCs know I've been hit
// ---------------------------------------------------------------
g_helpfunc.CSoundEnt_InsertSound(SOUND_COMBAT, GetAbsOrigin(), 1024, 0.5, BaseEntity(), SOUNDENT_CHANNEL_INJURY );
return 1;
}
void GeneralTask::OnHttpResponse(int status_code, const char * buf, int len) {
GotResponse(status_code, buf, len); // here?
Wake();
}
void State::ApplyImpulse(const Vector2D& impulse) {
Wake();
_impulses.push_back(impulse);
}
