diff options
Diffstat (limited to 'game/server/hl2/npc_basescanner.cpp')
| -rw-r--r-- | game/server/hl2/npc_basescanner.cpp | 1847 |
1 files changed, 1847 insertions, 0 deletions
diff --git a/game/server/hl2/npc_basescanner.cpp b/game/server/hl2/npc_basescanner.cpp new file mode 100644 index 0000000..b05441d --- /dev/null +++ b/game/server/hl2/npc_basescanner.cpp @@ -0,0 +1,1847 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//============================================================================= + +#include "cbase.h" +#include "npcevent.h" +#include "ai_basenpc_physicsflyer.h" +#include "weapon_physcannon.h" +#include "hl2_player.h" +#include "npc_scanner.h" +#include "IEffects.h" +#include "explode.h" +#include "ai_route.h" + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + +ConVar g_debug_basescanner( "g_debug_basescanner", "0", FCVAR_CHEAT ); + +BEGIN_DATADESC( CNPC_BaseScanner ) + DEFINE_EMBEDDED( m_KilledInfo ), + DEFINE_SOUNDPATCH( m_pEngineSound ), + + DEFINE_FIELD( m_flFlyNoiseBase, FIELD_FLOAT ), + DEFINE_FIELD( m_flEngineStallTime, FIELD_TIME ), + DEFINE_FIELD( m_fNextFlySoundTime, FIELD_TIME ), + DEFINE_FIELD( m_nFlyMode, FIELD_INTEGER ), + + DEFINE_FIELD( m_vecDiveBombDirection, FIELD_VECTOR ), + DEFINE_FIELD( m_flDiveBombRollForce, FIELD_FLOAT ), + + // Physics Influence + DEFINE_FIELD( m_hPhysicsAttacker, FIELD_EHANDLE ), + DEFINE_FIELD( m_flLastPhysicsInfluenceTime, FIELD_TIME ), + + DEFINE_FIELD( m_flGoalOverrideDistance, FIELD_FLOAT ), + + DEFINE_FIELD( m_flAttackNearDist, FIELD_FLOAT ), + DEFINE_FIELD( m_flAttackFarDist, FIELD_FLOAT ), + DEFINE_FIELD( m_flAttackRange, FIELD_FLOAT ), + + DEFINE_FIELD( m_nPoseTail, FIELD_INTEGER ), + DEFINE_FIELD( m_nPoseDynamo, FIELD_INTEGER ), + DEFINE_FIELD( m_nPoseFlare, FIELD_INTEGER ), + DEFINE_FIELD( m_nPoseFaceVert, FIELD_INTEGER ), + DEFINE_FIELD( m_nPoseFaceHoriz, FIELD_INTEGER ), + + // DEFINE_FIELD( m_bHasSpoken, FIELD_BOOLEAN ), + + DEFINE_FIELD( m_pSmokeTrail, FIELD_CLASSPTR ), + + DEFINE_INPUTFUNC( FIELD_FLOAT, "SetDistanceOverride", InputSetDistanceOverride ), + DEFINE_INPUTFUNC( FIELD_INTEGER, "SetFlightSpeed", InputSetFlightSpeed ), + + DEFINE_THINKFUNC( DiveBombSoundThink ), +END_DATADESC() + +ConVar sk_scanner_dmg_dive( "sk_scanner_dmg_dive","0"); + +//----------------------------------------------------------------------------- +// Think contexts +//----------------------------------------------------------------------------- +static const char *s_pDiveBombSoundThinkContext = "DiveBombSoundThinkContext"; + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CNPC_BaseScanner::CNPC_BaseScanner() +{ +#ifdef _DEBUG + m_vCurrentBanking.Init(); +#endif + m_pEngineSound = NULL; + m_bHasSpoken = false; + + m_flAttackNearDist = SCANNER_ATTACK_NEAR_DIST; + m_flAttackFarDist = SCANNER_ATTACK_FAR_DIST; + m_flAttackRange = SCANNER_ATTACK_RANGE; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::Spawn(void) +{ +#ifdef _XBOX + // Always fade the corpse + AddSpawnFlags( SF_NPC_FADE_CORPSE ); + AddEffects( EF_NOSHADOW ); +#endif // _XBOX + + SetHullType( HULL_TINY_CENTERED ); + SetHullSizeNormal(); + + SetSolid( SOLID_BBOX ); + AddSolidFlags( FSOLID_NOT_STANDABLE ); + + SetMoveType( MOVETYPE_VPHYSICS ); + + m_bloodColor = DONT_BLEED; + SetViewOffset( Vector(0, 0, 10) ); // Position of the eyes relative to NPC's origin. + m_flFieldOfView = 0.2; + m_NPCState = NPC_STATE_NONE; + + SetNavType( NAV_FLY ); + + AddFlag( FL_FLY ); + + // This entity cannot be dissolved by the combine balls, + // nor does it get killed by the mega physcannon. + AddEFlags( EFL_NO_DISSOLVE | EFL_NO_MEGAPHYSCANNON_RAGDOLL ); + + m_flGoalOverrideDistance = 0.0f; + + m_nFlyMode = SCANNER_FLY_PATROL; + AngleVectors( GetLocalAngles(), &m_vCurrentBanking ); + m_fHeadYaw = 0; + m_pSmokeTrail = NULL; + + SetCurrentVelocity( vec3_origin ); + + // Noise modifier + Vector bobAmount; + bobAmount.x = random->RandomFloat( -2.0f, 2.0f ); + bobAmount.y = random->RandomFloat( -2.0f, 2.0f ); + bobAmount.z = random->RandomFloat( 2.0f, 4.0f ); + if ( random->RandomInt( 0, 1 ) ) + { + bobAmount.z *= -1.0f; + } + SetNoiseMod( bobAmount ); + + // set flight speed + m_flSpeed = GetMaxSpeed(); + + // -------------------------------------------- + + CapabilitiesAdd( bits_CAP_MOVE_FLY | bits_CAP_SQUAD | bits_CAP_TURN_HEAD | bits_CAP_SKIP_NAV_GROUND_CHECK ); + + NPCInit(); + + m_flFlyNoiseBase = random->RandomFloat( 0, M_PI ); + + m_flNextAttack = gpGlobals->curtime; +} + +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::UpdateEfficiency( bool bInPVS ) +{ + SetEfficiency( ( GetSleepState() != AISS_AWAKE ) ? AIE_DORMANT : AIE_NORMAL ); + SetMoveEfficiency( AIME_NORMAL ); +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +float CNPC_BaseScanner::GetAutoAimRadius() +{ + if( g_pGameRules->GetAutoAimMode() == AUTOAIM_ON_CONSOLE ) + { + return 24.0f; + } + + return 12.0f; +} + +//----------------------------------------------------------------------------- +// Purpose: Called just before we are deleted. +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::UpdateOnRemove( void ) +{ + // Stop combat loops if I'm alive. If I'm dead, the die sound will already have stopped it. + if ( IsAlive() && m_bHasSpoken ) + { + SentenceStop(); + } + + BaseClass::UpdateOnRemove(); +} + +//----------------------------------------------------------------------------- +// Purpose: Gets the appropriate next schedule based on current condition +// bits. +//----------------------------------------------------------------------------- +int CNPC_BaseScanner::SelectSchedule(void) +{ + // ---------------------------------------------------- + // If I'm dead, go into a dive bomb + // ---------------------------------------------------- + if ( m_iHealth <= 0 ) + { + m_flSpeed = SCANNER_MAX_DIVE_BOMB_SPEED; + return SCHED_SCANNER_ATTACK_DIVEBOMB; + } + + // ------------------------------- + // If I'm in a script sequence + // ------------------------------- + if ( m_NPCState == NPC_STATE_SCRIPT ) + return(BaseClass::SelectSchedule()); + + // ------------------------------- + // Flinch + // ------------------------------- + if ( HasCondition(COND_LIGHT_DAMAGE) || HasCondition(COND_HEAVY_DAMAGE) ) + { + if ( IsHeldByPhyscannon( ) ) + return SCHED_SMALL_FLINCH; + + if ( m_NPCState == NPC_STATE_IDLE ) + return SCHED_SMALL_FLINCH; + + if ( m_NPCState == NPC_STATE_ALERT ) + { + if ( m_iHealth < ( 3 * m_iMaxHealth / 4 )) + return SCHED_TAKE_COVER_FROM_ORIGIN; + + if ( SelectWeightedSequence( ACT_SMALL_FLINCH ) != -1 ) + return SCHED_SMALL_FLINCH; + } + else + { + if ( random->RandomInt( 0, 10 ) < 4 ) + return SCHED_SMALL_FLINCH; + } + } + + // I'm being held by the physcannon... struggle! + if ( IsHeldByPhyscannon( ) ) + return SCHED_SCANNER_HELD_BY_PHYSCANNON; + + // ---------------------------------------------------------- + // If I have an enemy + // ---------------------------------------------------------- + if ( GetEnemy() != NULL && GetEnemy()->IsAlive() ) + { + // Patrol if the enemy has vanished + if ( HasCondition( COND_LOST_ENEMY ) ) + return SCHED_SCANNER_PATROL; + + // Chase via route if we're directly blocked + if ( HasCondition( COND_SCANNER_FLY_BLOCKED ) ) + return SCHED_SCANNER_CHASE_ENEMY; + + // Attack if it's time + if ( gpGlobals->curtime >= m_flNextAttack ) + { + if ( HasCondition( COND_CAN_MELEE_ATTACK1 ) ) + return SCHED_SCANNER_ATTACK; + } + + // Otherwise fly in low for attack + return SCHED_SCANNER_ATTACK_HOVER; + } + + // Default to patrolling around + return SCHED_SCANNER_PATROL; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::OnScheduleChange( void ) +{ + m_flSpeed = GetMaxSpeed(); + + BaseClass::OnScheduleChange(); +} + +//----------------------------------------------------------------------------- +// Purpose: For innate melee attack +//----------------------------------------------------------------------------- +int CNPC_BaseScanner::MeleeAttack1Conditions( float flDot, float flDist ) +{ + if (GetEnemy() == NULL) + { + return COND_NONE; + } + + // Check too far to attack with 2D distance + float vEnemyDist2D = (GetEnemy()->GetLocalOrigin() - GetLocalOrigin()).Length2D(); + + if (m_flNextAttack > gpGlobals->curtime) + { + return COND_NONE; + } + else if (vEnemyDist2D > m_flAttackRange) + { + return COND_TOO_FAR_TO_ATTACK; + } + else if (flDot < 0.7) + { + return COND_NOT_FACING_ATTACK; + } + return COND_CAN_MELEE_ATTACK1; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : eOldState - +// eNewState - +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::OnStateChange( NPC_STATE eOldState, NPC_STATE eNewState ) +{ + if (( eNewState == NPC_STATE_ALERT ) || ( eNewState == NPC_STATE_COMBAT )) + { + SetPoseParameter(m_nPoseFlare, 1.0f); + } + else + { + SetPoseParameter(m_nPoseFlare, 0); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : pTask - +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::StartTask( const Task_t *pTask ) +{ + switch (pTask->iTask) + { + case TASK_SCANNER_SET_FLY_PATROL: + { + // Fly in patrol mode and clear any + // remaining target entity + m_nFlyMode = SCANNER_FLY_PATROL; + TaskComplete(); + break; + } + case TASK_SCANNER_SET_FLY_CHASE: + { + m_nFlyMode = SCANNER_FLY_CHASE; + TaskComplete(); + break; + } + case TASK_SCANNER_SET_FLY_ATTACK: + { + m_nFlyMode = SCANNER_FLY_ATTACK; + TaskComplete(); + break; + } + + case TASK_SCANNER_SET_FLY_DIVE: + { + // Pick a direction to divebomb. + if ( GetEnemy() != NULL ) + { + // Fly towards my enemy + Vector vEnemyPos = GetEnemyLKP(); + m_vecDiveBombDirection = vEnemyPos - GetLocalOrigin(); + } + else + { + // Pick a random forward and down direction. + Vector forward; + GetVectors( &forward, NULL, NULL ); + m_vecDiveBombDirection = forward + Vector( random->RandomFloat( -10, 10 ), random->RandomFloat( -10, 10 ), random->RandomFloat( -20, -10 ) ); + } + VectorNormalize( m_vecDiveBombDirection ); + + // Calculate a roll force. + m_flDiveBombRollForce = random->RandomFloat( 20.0, 420.0 ); + if ( random->RandomInt( 0, 1 ) ) + { + m_flDiveBombRollForce *= -1; + } + + DiveBombSoundThink(); + + m_nFlyMode = SCANNER_FLY_DIVE; + TaskComplete(); + break; + } + + default: + BaseClass::StartTask(pTask); + break; + } +} + +//------------------------------------------------------------------------------ +// Purpose: Override to split in two when attacked +//------------------------------------------------------------------------------ +int CNPC_BaseScanner::OnTakeDamage_Alive( const CTakeDamageInfo &info ) +{ + // Start smoking when we're nearly dead + if ( m_iHealth < ( m_iMaxHealth - ( m_iMaxHealth / 4 ) ) ) + { + StartSmokeTrail(); + } + + return (BaseClass::OnTakeDamage_Alive( info )); +} + +//------------------------------------------------------------------------------ +// Purpose: Override to split in two when attacked +//------------------------------------------------------------------------------ +int CNPC_BaseScanner::OnTakeDamage_Dying( const CTakeDamageInfo &info ) +{ + // do the damage + m_iHealth -= info.GetDamage(); + + if ( m_iHealth < -40 ) + { + Gib(); + return 1; + } + + return VPhysicsTakeDamage( info ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator ) +{ + if ( info.GetDamageType() & DMG_BULLET) + { + g_pEffects->Ricochet(ptr->endpos,ptr->plane.normal); + } + + BaseClass::TraceAttack( info, vecDir, ptr, pAccumulator ); +} + +//----------------------------------------------------------------------------- +// Take damage from being thrown by a physcannon +//----------------------------------------------------------------------------- +#define SCANNER_SMASH_SPEED 250.0 // How fast a scanner must slam into something to take full damage +void CNPC_BaseScanner::TakeDamageFromPhyscannon( CBasePlayer *pPlayer ) +{ + CTakeDamageInfo info; + info.SetDamageType( DMG_GENERIC ); + info.SetInflictor( this ); + info.SetAttacker( pPlayer ); + info.SetDamagePosition( GetAbsOrigin() ); + info.SetDamageForce( Vector( 1.0, 1.0, 1.0 ) ); + + // Convert velocity into damage. + Vector vel; + VPhysicsGetObject()->GetVelocity( &vel, NULL ); + float flSpeed = vel.Length(); + + float flFactor = flSpeed / SCANNER_SMASH_SPEED; + + // Clamp. Don't inflict negative damage or massive damage! + flFactor = clamp( flFactor, 0.0f, 2.0f ); + float flDamage = m_iMaxHealth * flFactor; + +#if 0 + Msg("Doing %f damage for %f speed!\n", flDamage, flSpeed ); +#endif + + info.SetDamage( flDamage ); + TakeDamage( info ); +} + + +//----------------------------------------------------------------------------- +// Take damage from physics impacts +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::TakeDamageFromPhysicsImpact( int index, gamevcollisionevent_t *pEvent ) +{ + CBaseEntity *pHitEntity = pEvent->pEntities[!index]; + + // NOTE: Augment the normal impact energy scale here. + float flDamageScale = PlayerHasMegaPhysCannon() ? 10.0f : 5.0f; + + // Scale by the mapmaker's energyscale + flDamageScale *= m_impactEnergyScale; + + int damageType = 0; + float damage = CalculateDefaultPhysicsDamage( index, pEvent, flDamageScale, true, damageType ); + if ( damage == 0 ) + return; + + Vector damagePos; + pEvent->pInternalData->GetContactPoint( damagePos ); + Vector damageForce = pEvent->postVelocity[index] * pEvent->pObjects[index]->GetMass(); + if ( damageForce == vec3_origin ) + { + // This can happen if this entity is motion disabled, and can't move. + // Use the velocity of the entity that hit us instead. + damageForce = pEvent->postVelocity[!index] * pEvent->pObjects[!index]->GetMass(); + } + + // FIXME: this doesn't pass in who is responsible if some other entity "caused" this collision + PhysCallbackDamage( this, CTakeDamageInfo( pHitEntity, pHitEntity, damageForce, damagePos, damage, damageType ), *pEvent, index ); +} + +//----------------------------------------------------------------------------- +// Is the scanner being held? +//----------------------------------------------------------------------------- +bool CNPC_BaseScanner::IsHeldByPhyscannon( ) +{ + return VPhysicsGetObject() && (VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_PLAYER_HELD); +} + +//------------------------------------------------------------------------------ +// Physics impact +//------------------------------------------------------------------------------ +#define SCANNER_SMASH_TIME 0.75 // How long after being thrown from a physcannon that a manhack is eligible to die from impact +void CNPC_BaseScanner::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent ) +{ + BaseClass::VPhysicsCollision( index, pEvent ); + + // Take no impact damage while being carried. + if ( IsHeldByPhyscannon( ) ) + return; + + CBasePlayer *pPlayer = HasPhysicsAttacker( SCANNER_SMASH_TIME ); + if( pPlayer ) + { + TakeDamageFromPhyscannon( pPlayer ); + return; + } + + // It also can take physics damage from things thrown by the player. + int otherIndex = !index; + CBaseEntity *pHitEntity = pEvent->pEntities[otherIndex]; + if ( pHitEntity ) + { + if ( pHitEntity->HasPhysicsAttacker( 0.5f ) ) + { + // It can take physics damage from things thrown by the player. + TakeDamageFromPhysicsImpact( index, pEvent ); + } + else if ( FClassnameIs( pHitEntity, "prop_combine_ball" ) ) + { + // It also can take physics damage from a combine ball. + TakeDamageFromPhysicsImpact( index, pEvent ); + } + } +} + +//------------------------------------------------------------------------------ +// Purpose: +//------------------------------------------------------------------------------ +void CNPC_BaseScanner::Gib( void ) +{ + if ( IsMarkedForDeletion() ) + return; + + // Sparks + for ( int i = 0; i < 4; i++ ) + { + Vector sparkPos = GetAbsOrigin(); + sparkPos.x += random->RandomFloat(-12,12); + sparkPos.y += random->RandomFloat(-12,12); + sparkPos.z += random->RandomFloat(-12,12); + g_pEffects->Sparks(sparkPos); + } + + // Light + CBroadcastRecipientFilter filter; + te->DynamicLight( filter, 0.0, &WorldSpaceCenter(), 255, 180, 100, 0, 100, 0.1, 0 ); + + // Cover the gib spawn + ExplosionCreate( WorldSpaceCenter(), GetAbsAngles(), this, 64, 64, false ); + + // Turn off any smoke trail + if ( m_pSmokeTrail ) + { + m_pSmokeTrail->m_ParticleLifetime = 0; + UTIL_Remove(m_pSmokeTrail); + m_pSmokeTrail = NULL; + } + + // FIXME: This is because we couldn't save/load the CTakeDamageInfo. + // because it's midnight before the teamwide playtest. Real solution + // is to add a datadesc to CTakeDamageInfo + if ( m_KilledInfo.GetInflictor() ) + { + BaseClass::Event_Killed( m_KilledInfo ); + } + + UTIL_Remove(this); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : *pPhysGunUser - +// bPunting - +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::OnPhysGunPickup( CBasePlayer *pPhysGunUser, PhysGunPickup_t reason ) +{ + m_hPhysicsAttacker = pPhysGunUser; + m_flLastPhysicsInfluenceTime = gpGlobals->curtime; + + if ( reason == PUNTED_BY_CANNON ) + { + // There's about to be a massive change in velocity. + // Think immediately to handle changes in m_vCurrentVelocity; + SetNextThink( gpGlobals->curtime + 0.01f ); + + m_flEngineStallTime = gpGlobals->curtime + 2.0f; + ScannerEmitSound( "DiveBomb" ); + } + else + { + SetCondition( COND_SCANNER_GRABBED_BY_PHYSCANNON ); + ClearCondition( COND_SCANNER_RELEASED_FROM_PHYSCANNON ); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Input : *pPhysGunUser - +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::OnPhysGunDrop( CBasePlayer *pPhysGunUser, PhysGunDrop_t Reason ) +{ + m_hPhysicsAttacker = pPhysGunUser; + m_flLastPhysicsInfluenceTime = gpGlobals->curtime; + + ClearCondition( COND_SCANNER_GRABBED_BY_PHYSCANNON ); + SetCondition( COND_SCANNER_RELEASED_FROM_PHYSCANNON ); + + if ( Reason == LAUNCHED_BY_CANNON ) + { + m_flEngineStallTime = gpGlobals->curtime + 2.0f; + + // There's about to be a massive change in velocity. + // Think immediately to handle changes in m_vCurrentVelocity; + SetNextThink( gpGlobals->curtime + 0.01f ); + ScannerEmitSound( "DiveBomb" ); + } +} + + +//------------------------------------------------------------------------------ +// Do we have a physics attacker? +//------------------------------------------------------------------------------ +CBasePlayer *CNPC_BaseScanner::HasPhysicsAttacker( float dt ) +{ + // If the player is holding me now, or I've been recently thrown + // then return a pointer to that player + if ( IsHeldByPhyscannon( ) || (gpGlobals->curtime - dt <= m_flLastPhysicsInfluenceTime) ) + { + return m_hPhysicsAttacker; + } + return NULL; +} + + +//------------------------------------------------------------------------------ +// Purpose: +//------------------------------------------------------------------------------ +void CNPC_BaseScanner::StopLoopingSounds(void) +{ + CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController(); + controller.SoundDestroy( m_pEngineSound ); + m_pEngineSound = NULL; + + BaseClass::StopLoopingSounds(); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : pInflictor - +// pAttacker - +// flDamage - +// bitsDamageType - +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::Event_Killed( const CTakeDamageInfo &info ) +{ + // Copy off the takedamage info that killed me, since we're not going to call + // up into the base class's Event_Killed() until we gib. (gibbing is ultimate death) + m_KilledInfo = info; + + // Interrupt whatever schedule I'm on + SetCondition(COND_SCHEDULE_DONE); + + // If I have an enemy and I'm up high, do a dive bomb (unless dissolved) + if ( GetEnemy() != NULL && (info.GetDamageType() & DMG_DISSOLVE) == false ) + { + Vector vecDelta = GetLocalOrigin() - GetEnemy()->GetLocalOrigin(); + if ( ( vecDelta.z > 120 ) && ( vecDelta.Length() > 360 ) ) + { + // If I'm divebombing, don't take any more damage. It will make Event_Killed() be called again. + // This is especially bad if someone machineguns the divebombing scanner. + AttackDivebomb(); + return; + } + } + + Gib(); +} + +//------------------------------------------------------------------------------ +// Purpose: +//------------------------------------------------------------------------------ +void CNPC_BaseScanner::AttackDivebomb( void ) +{ + ScannerEmitSound( "DiveBomb" ); + + m_takedamage = DAMAGE_NO; + + StartSmokeTrail(); +} + +//------------------------------------------------------------------------------ +// Purpose: Checks to see if we hit anything while dive bombing. +//------------------------------------------------------------------------------ +void CNPC_BaseScanner::AttackDivebombCollide(float flInterval) +{ + // + // Trace forward to see if I hit anything + // + Vector checkPos = GetAbsOrigin() + (GetCurrentVelocity() * flInterval); + trace_t tr; + CBaseEntity* pHitEntity = NULL; + AI_TraceHull( GetAbsOrigin(), checkPos, GetHullMins(), GetHullMaxs(), MASK_SOLID, this, COLLISION_GROUP_NONE, &tr ); + + if (tr.m_pEnt) + { + pHitEntity = tr.m_pEnt; + + // Did I hit an entity that isn't another scanner? + if (pHitEntity && pHitEntity->Classify()!=CLASS_SCANNER) + { + if ( !pHitEntity->ClassMatches("item_battery") ) + { + if ( !pHitEntity->IsWorld() ) + { + CTakeDamageInfo info( this, this, sk_scanner_dmg_dive.GetFloat(), DMG_CLUB ); + CalculateMeleeDamageForce( &info, (tr.endpos - tr.startpos), tr.endpos ); + pHitEntity->TakeDamage( info ); + } + Gib(); + } + } + } + + if (tr.fraction != 1.0) + { + // We've hit something so deflect our velocity based on the surface + // norm of what we've hit + if (flInterval > 0) + { + float moveLen = (1.0 - tr.fraction)*(GetAbsOrigin() - checkPos).Length(); + Vector vBounceVel = moveLen*tr.plane.normal/flInterval; + + // If I'm right over the ground don't push down + if (vBounceVel.z < 0) + { + float floorZ = GetFloorZ(GetAbsOrigin()); + if (abs(GetAbsOrigin().z - floorZ) < 36) + { + vBounceVel.z = 0; + } + } + SetCurrentVelocity( GetCurrentVelocity() + vBounceVel ); + } + CBaseCombatCharacter* pBCC = ToBaseCombatCharacter( pHitEntity ); + + if (pBCC) + { + // Spawn some extra blood where we hit + SpawnBlood(tr.endpos, g_vecAttackDir, pBCC->BloodColor(), sk_scanner_dmg_dive.GetFloat()); + } + else + { + if (!(m_spawnflags & SF_NPC_GAG)) + { + // <<TEMP>> need better sound here... + ScannerEmitSound( "Shoot" ); + } + // For sparks we must trace a line in the direction of the surface norm + // that we hit. + checkPos = GetAbsOrigin() - (tr.plane.normal * 24); + + AI_TraceLine( GetAbsOrigin(), checkPos,MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr ); + if (tr.fraction != 1.0) + { + g_pEffects->Sparks( tr.endpos ); + + CBroadcastRecipientFilter filter; + te->DynamicLight( filter, 0.0, + &GetAbsOrigin(), 255, 180, 100, 0, 50, 0.1, 0 ); + } + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::PlayFlySound(void) +{ + if ( IsMarkedForDeletion() ) + return; + + CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController(); + + //Setup the sound if we're not already + if ( m_pEngineSound == NULL ) + { + // Create the sound + CPASAttenuationFilter filter( this ); + + m_pEngineSound = controller.SoundCreate( filter, entindex(), CHAN_STATIC, GetEngineSound(), ATTN_NORM ); + + Assert(m_pEngineSound); + + // Start the engine sound + controller.Play( m_pEngineSound, 0.0f, 100.0f ); + controller.SoundChangeVolume( m_pEngineSound, 1.0f, 2.0f ); + } + + float speed = GetCurrentVelocity().Length(); + float flVolume = 0.25f + (0.75f*(speed/GetMaxSpeed())); + int iPitch = MIN( 255, 80 + (20*(speed/GetMaxSpeed())) ); + + //Update our pitch and volume based on our speed + controller.SoundChangePitch( m_pEngineSound, iPitch, 0.1f ); + controller.SoundChangeVolume( m_pEngineSound, flVolume, 0.1f ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::ScannerEmitSound( const char *pszSoundName ) +{ + CFmtStr snd; + snd.sprintf("%s.%s", GetScannerSoundPrefix(), pszSoundName ); + + m_bHasSpoken = true; + + EmitSound( snd.Access() ); +} + +//------------------------------------------------------------------------------ +// Purpose: +//------------------------------------------------------------------------------ +void CNPC_BaseScanner::SpeakSentence( int sentenceType ) +{ + if (sentenceType == SCANNER_SENTENCE_ATTENTION) + { + ScannerEmitSound( "Attention" ); + } + else if (sentenceType == SCANNER_SENTENCE_HANDSUP) + { + ScannerEmitSound( "Scan" ); + } + else if (sentenceType == SCANNER_SENTENCE_PROCEED) + { + ScannerEmitSound( "Proceed" ); + } + else if (sentenceType == SCANNER_SENTENCE_CURIOUS) + { + ScannerEmitSound( "Curious" ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::InputSetFlightSpeed(inputdata_t &inputdata) +{ + //FIXME: Currently unsupported + + /* + m_flFlightSpeed = inputdata.value.Int(); + m_bFlightSpeedOverridden = (m_flFlightSpeed > 0); + */ +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::StartSmokeTrail( void ) +{ + if ( m_pSmokeTrail != NULL ) + return; + + m_pSmokeTrail = SmokeTrail::CreateSmokeTrail(); + + if ( m_pSmokeTrail ) + { + m_pSmokeTrail->m_SpawnRate = 10; + m_pSmokeTrail->m_ParticleLifetime = 1; + m_pSmokeTrail->m_StartSize = 8; + m_pSmokeTrail->m_EndSize = 50; + m_pSmokeTrail->m_SpawnRadius = 10; + m_pSmokeTrail->m_MinSpeed = 15; + m_pSmokeTrail->m_MaxSpeed = 25; + + m_pSmokeTrail->m_StartColor.Init( 0.5f, 0.5f, 0.5f ); + m_pSmokeTrail->m_EndColor.Init( 0, 0, 0 ); + m_pSmokeTrail->SetLifetime( 500.0f ); + m_pSmokeTrail->FollowEntity( this ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::BlendPhyscannonLaunchSpeed() +{ + // Blend out desired velocity when launched by the physcannon + if (!VPhysicsGetObject()) + return; + + if ( HasPhysicsAttacker( SCANNER_SMASH_TIME ) && !IsHeldByPhyscannon( ) ) + { + Vector vecCurrentVelocity; + VPhysicsGetObject()->GetVelocity( &vecCurrentVelocity, NULL ); + float flLerpFactor = (gpGlobals->curtime - m_flLastPhysicsInfluenceTime) / SCANNER_SMASH_TIME; + flLerpFactor = clamp( flLerpFactor, 0.0f, 1.0f ); + flLerpFactor = SimpleSplineRemapVal( flLerpFactor, 0.0f, 1.0f, 0.0f, 1.0f ); + flLerpFactor *= flLerpFactor; + VectorLerp( vecCurrentVelocity, m_vCurrentVelocity, flLerpFactor, m_vCurrentVelocity ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::MoveExecute_Alive(float flInterval) +{ + // Amount of noise to add to flying + float noiseScale = 3.0f; + + // ------------------------------------------- + // Avoid obstacles, unless I'm dive bombing + // ------------------------------------------- + if (m_nFlyMode != SCANNER_FLY_DIVE) + { + SetCurrentVelocity( GetCurrentVelocity() + VelocityToAvoidObstacles(flInterval) ); + } + // If I am dive bombing add more noise to my flying + else + { + AttackDivebombCollide(flInterval); + noiseScale *= 4; + } + + IPhysicsObject *pPhysics = VPhysicsGetObject(); + + if ( pPhysics && pPhysics->IsAsleep() ) + { + pPhysics->Wake(); + } + + // Add time-coherent noise to the current velocity so that it never looks bolted in place. + AddNoiseToVelocity( noiseScale ); + + AdjustScannerVelocity(); + + float maxSpeed = GetEnemy() ? ( GetMaxSpeed() * 2.0f ) : GetMaxSpeed(); + if ( m_nFlyMode == SCANNER_FLY_DIVE ) + { + maxSpeed = -1; + } + + // Limit fall speed + LimitSpeed( maxSpeed ); + + // Blend out desired velocity when launched by the physcannon + BlendPhyscannonLaunchSpeed(); + + // Update what we're looking at + UpdateHead( flInterval ); + + // Control the tail based on our vertical travel + float tailPerc = clamp( GetCurrentVelocity().z, -150, 250 ); + tailPerc = SimpleSplineRemapVal( tailPerc, -150, 250, -25, 80 ); + + SetPoseParameter( m_nPoseTail, tailPerc ); + + // Spin the dynamo based upon our speed + float flCurrentDynamo = GetPoseParameter( m_nPoseDynamo ); + float speed = GetCurrentVelocity().Length(); + float flDynamoSpeed = (maxSpeed > 0 ? speed / maxSpeed : 1.0) * 60; + flCurrentDynamo -= flDynamoSpeed; + if ( flCurrentDynamo < -180.0 ) + { + flCurrentDynamo += 360.0; + } + SetPoseParameter( m_nPoseDynamo, flCurrentDynamo ); + + PlayFlySound(); +} + +//----------------------------------------------------------------------------- +// Purpose: Handles movement towards the last move target. +// Input : flInterval - +//----------------------------------------------------------------------------- +bool CNPC_BaseScanner::OverridePathMove( CBaseEntity *pMoveTarget, float flInterval ) +{ + // Save our last patrolling direction + Vector lastPatrolDir = GetNavigator()->GetCurWaypointPos() - GetAbsOrigin(); + + // Continue on our path + if ( ProgressFlyPath( flInterval, pMoveTarget, (MASK_NPCSOLID|CONTENTS_WATER), false, 64 ) == AINPP_COMPLETE ) + { + if ( IsCurSchedule( SCHED_SCANNER_PATROL ) ) + { + m_vLastPatrolDir = lastPatrolDir; + VectorNormalize(m_vLastPatrolDir); + } + + return true; + } + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : flInterval - +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool CNPC_BaseScanner::OverrideMove( float flInterval ) +{ + // ---------------------------------------------- + // If dive bombing + // ---------------------------------------------- + if (m_nFlyMode == SCANNER_FLY_DIVE) + { + MoveToDivebomb( flInterval ); + } + else + { + Vector vMoveTargetPos(0,0,0); + CBaseEntity *pMoveTarget = NULL; + + // The original line of code was, due to the accidental use of '|' instead of + // '&', always true. Replacing with 'true' to suppress the warning without changing + // the (long-standing) behavior. + if ( true ) //!GetNavigator()->IsGoalActive() || ( GetNavigator()->GetCurWaypointFlags() | bits_WP_TO_PATHCORNER ) ) + { + // Select move target + if ( GetTarget() != NULL ) + { + pMoveTarget = GetTarget(); + } + else if ( GetEnemy() != NULL ) + { + pMoveTarget = GetEnemy(); + } + + // Select move target position + if ( GetEnemy() != NULL ) + { + vMoveTargetPos = GetEnemy()->GetAbsOrigin(); + } + } + else + { + vMoveTargetPos = GetNavigator()->GetCurWaypointPos(); + } + + ClearCondition( COND_SCANNER_FLY_CLEAR ); + ClearCondition( COND_SCANNER_FLY_BLOCKED ); + + // See if we can fly there directly + if ( pMoveTarget ) + { + trace_t tr; + AI_TraceHull( GetAbsOrigin(), vMoveTargetPos, GetHullMins(), GetHullMaxs(), MASK_NPCSOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr ); + + float fTargetDist = (1.0f-tr.fraction)*(GetAbsOrigin() - vMoveTargetPos).Length(); + + if ( ( tr.m_pEnt == pMoveTarget ) || ( fTargetDist < 50 ) ) + { + if ( g_debug_basescanner.GetBool() ) + { + NDebugOverlay::Line(GetLocalOrigin(), vMoveTargetPos, 0,255,0, true, 0); + NDebugOverlay::Cross3D(tr.endpos,Vector(-5,-5,-5),Vector(5,5,5),0,255,0,true,0.1); + } + + SetCondition( COND_SCANNER_FLY_CLEAR ); + } + else + { + //HANDY DEBUG TOOL + if ( g_debug_basescanner.GetBool() ) + { + NDebugOverlay::Line(GetLocalOrigin(), vMoveTargetPos, 255,0,0, true, 0); + NDebugOverlay::Cross3D(tr.endpos,Vector(-5,-5,-5),Vector(5,5,5),255,0,0,true,0.1); + } + + SetCondition( COND_SCANNER_FLY_BLOCKED ); + } + } + + // If I have a route, keep it updated and move toward target + if ( GetNavigator()->IsGoalActive() ) + { + if ( OverridePathMove( pMoveTarget, flInterval ) ) + { + BlendPhyscannonLaunchSpeed(); + return true; + } + } + // ---------------------------------------------- + // If attacking + // ---------------------------------------------- + else if (m_nFlyMode == SCANNER_FLY_ATTACK) + { + MoveToAttack( flInterval ); + } + // ----------------------------------------------------------------- + // If I don't have a route, just decelerate + // ----------------------------------------------------------------- + else if (!GetNavigator()->IsGoalActive()) + { + float myDecay = 9.5; + Decelerate( flInterval, myDecay); + } + } + + MoveExecute_Alive( flInterval ); + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : &goalPos - +// &startPos - +// idealRange - +// idealHeight - +// Output : Vector +//----------------------------------------------------------------------------- +Vector CNPC_BaseScanner::IdealGoalForMovement( const Vector &goalPos, const Vector &startPos, float idealRange, float idealHeightDiff ) +{ + Vector vMoveDir; + + if ( GetGoalDirection( &vMoveDir ) == false ) + { + vMoveDir = ( goalPos - startPos ); + vMoveDir.z = 0; + VectorNormalize( vMoveDir ); + } + + // Move up from the position by the desired amount + Vector vIdealPos = goalPos + Vector( 0, 0, idealHeightDiff ) + ( vMoveDir * -idealRange ); + + // Trace down and make sure we can fit here + trace_t tr; + AI_TraceHull( vIdealPos, vIdealPos - Vector( 0, 0, MinGroundDist() ), GetHullMins(), GetHullMaxs(), MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr ); + + // Move up otherwise + if ( tr.fraction < 1.0f ) + { + vIdealPos.z += ( MinGroundDist() * ( 1.0f - tr.fraction ) ); + } + + //FIXME: We also need to make sure that we fit here at all, and if not, chose a new spot + + // Debug tools + if ( g_debug_basescanner.GetBool() ) + { + NDebugOverlay::Cross3D( goalPos, -Vector(8,8,8), Vector(8,8,8), 255, 255, 0, true, 0.1f ); + NDebugOverlay::Cross3D( startPos, -Vector(8,8,8), Vector(8,8,8), 255, 0, 255, true, 0.1f ); + NDebugOverlay::Cross3D( vIdealPos, -Vector(8,8,8), Vector(8,8,8), 255, 255, 255, true, 0.1f ); + NDebugOverlay::Line( startPos, goalPos, 0, 255, 0, true, 0.1f ); + + NDebugOverlay::Cross3D( goalPos + ( vMoveDir * -idealRange ), -Vector(8,8,8), Vector(8,8,8), 255, 255, 255, true, 0.1f ); + NDebugOverlay::Line( goalPos, goalPos + ( vMoveDir * -idealRange ), 255, 255, 0, true, 0.1f ); + NDebugOverlay::Line( goalPos + ( vMoveDir * -idealRange ), vIdealPos, 255, 255, 0, true, 0.1f ); + } + + return vIdealPos; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : flInterval - +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::MoveToAttack(float flInterval) +{ + if (GetEnemy() == NULL) + return; + + if ( flInterval <= 0 ) + return; + + Vector vTargetPos = GetEnemyLKP(); + + //float flDesiredDist = m_flAttackNearDist + ( ( m_flAttackFarDist - m_flAttackNearDist ) / 2 ); + + Vector idealPos = IdealGoalForMovement( vTargetPos, GetAbsOrigin(), GetGoalDistance(), m_flAttackNearDist ); + + MoveToTarget( flInterval, idealPos ); + + //FIXME: Re-implement? + + /* + // --------------------------------------------------------- + // Add evasion if I have taken damage recently + // --------------------------------------------------------- + if ((m_flLastDamageTime + SCANNER_EVADE_TIME) > gpGlobals->curtime) + { + vFlyDirection = vFlyDirection + VelocityToEvade(GetEnemyCombatCharacterPointer()); + } + */ +} + +//----------------------------------------------------------------------------- +// Purpose: Accelerates toward a given position. +// Input : flInterval - Time interval over which to move. +// vecMoveTarget - Position to move toward. +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::MoveToTarget( float flInterval, const Vector &vecMoveTarget ) +{ + // Don't move if stalling + if ( m_flEngineStallTime > gpGlobals->curtime ) + return; + + // Look at our inspection target if we have one + if ( GetEnemy() != NULL ) + { + // Otherwise at our enemy + TurnHeadToTarget( flInterval, GetEnemy()->EyePosition() ); + } + else + { + // Otherwise face our motion direction + TurnHeadToTarget( flInterval, vecMoveTarget ); + } + + // ------------------------------------- + // Move towards our target + // ------------------------------------- + float myAccel; + float myZAccel = 400.0f; + float myDecay = 0.15f; + + Vector vecCurrentDir; + + // Get the relationship between my current velocity and the way I want to be going. + vecCurrentDir = GetCurrentVelocity(); + VectorNormalize( vecCurrentDir ); + + Vector targetDir = vecMoveTarget - GetAbsOrigin(); + float flDist = VectorNormalize(targetDir); + + float flDot; + flDot = DotProduct( targetDir, vecCurrentDir ); + + if( flDot > 0.25 ) + { + // If my target is in front of me, my flight model is a bit more accurate. + myAccel = 250; + } + else + { + // Have a harder time correcting my course if I'm currently flying away from my target. + myAccel = 128; + } + + if ( myAccel > flDist / flInterval ) + { + myAccel = flDist / flInterval; + } + + if ( myZAccel > flDist / flInterval ) + { + myZAccel = flDist / flInterval; + } + + MoveInDirection( flInterval, targetDir, myAccel, myZAccel, myDecay ); + + // calc relative banking targets + Vector forward, right, up; + GetVectors( &forward, &right, &up ); + + m_vCurrentBanking.x = targetDir.x; + m_vCurrentBanking.z = 120.0f * DotProduct( right, targetDir ); + m_vCurrentBanking.y = 0; + + float speedPerc = SimpleSplineRemapVal( GetCurrentVelocity().Length(), 0.0f, GetMaxSpeed(), 0.0f, 1.0f ); + + speedPerc = clamp( speedPerc, 0.0f, 1.0f ); + + m_vCurrentBanking *= speedPerc; +} + +//----------------------------------------------------------------------------- +// Danger sounds. +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::DiveBombSoundThink() +{ + Vector vecPosition, vecVelocity; + IPhysicsObject *pPhysicsObject = VPhysicsGetObject(); + + if ( pPhysicsObject == NULL ) + return; + + pPhysicsObject->GetPosition( &vecPosition, NULL ); + pPhysicsObject->GetVelocity( &vecVelocity, NULL ); + + CBasePlayer *pPlayer = AI_GetSinglePlayer(); + if ( pPlayer ) + { + Vector vecDelta; + VectorSubtract( pPlayer->GetAbsOrigin(), vecPosition, vecDelta ); + VectorNormalize( vecDelta ); + if ( DotProduct( vecDelta, vecVelocity ) > 0.5f ) + { + Vector vecEndPoint; + VectorMA( vecPosition, 2.0f * TICK_INTERVAL, vecVelocity, vecEndPoint ); + float flDist = CalcDistanceToLineSegment( pPlayer->GetAbsOrigin(), vecPosition, vecEndPoint ); + if ( flDist < 200.0f ) + { + ScannerEmitSound( "DiveBombFlyby" ); + SetContextThink( &CNPC_BaseScanner::DiveBombSoundThink, gpGlobals->curtime + 0.5f, s_pDiveBombSoundThinkContext ); + return; + } + } + } + + SetContextThink( &CNPC_BaseScanner::DiveBombSoundThink, gpGlobals->curtime + 2.0f * TICK_INTERVAL, s_pDiveBombSoundThinkContext ); +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Input : flInterval - +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::MoveToDivebomb(float flInterval) +{ + float myAccel = 1600; + float myDecay = 0.05f; // decay current velocity to 10% in 1 second + + // Fly towards my enemy + Vector vEnemyPos = GetEnemyLKP(); + Vector vFlyDirection = vEnemyPos - GetLocalOrigin(); + VectorNormalize( vFlyDirection ); + + // Set net velocity + MoveInDirection( flInterval, m_vecDiveBombDirection, myAccel, myAccel, myDecay); + + // Spin out of control. + Vector forward; + VPhysicsGetObject()->LocalToWorldVector( &forward, Vector( 1.0, 0.0, 0.0 ) ); + AngularImpulse torque = forward * m_flDiveBombRollForce; + VPhysicsGetObject()->ApplyTorqueCenter( torque ); + + // BUGBUG: why Y axis and not Z? + Vector up; + VPhysicsGetObject()->LocalToWorldVector( &up, Vector( 0.0, 1.0, 0.0 ) ); + VPhysicsGetObject()->ApplyForceCenter( up * 2000 ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CNPC_BaseScanner::IsEnemyPlayerInSuit() +{ + if( GetEnemy() && GetEnemy()->IsPlayer() ) + { + CHL2_Player *pPlayer = NULL; + pPlayer = (CHL2_Player *)GetEnemy(); + + if( pPlayer && pPlayer->IsSuitEquipped() ) + { + return true; + } + } + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : float +//----------------------------------------------------------------------------- +float CNPC_BaseScanner::GetGoalDistance( void ) +{ + if ( m_flGoalOverrideDistance != 0.0f ) + return m_flGoalOverrideDistance; + + switch ( m_nFlyMode ) + { + case SCANNER_FLY_ATTACK: + { + float goalDist = ( m_flAttackNearDist + ( ( m_flAttackFarDist - m_flAttackNearDist ) / 2 ) ); + if( IsEnemyPlayerInSuit() ) + { + goalDist *= 0.5; + } + return goalDist; + } + break; + } + + return 128.0f; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : &vOut - +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool CNPC_BaseScanner::GetGoalDirection( Vector *vOut ) +{ + CBaseEntity *pTarget = GetTarget(); + + if ( pTarget == NULL ) + return false; + + if ( FClassnameIs( pTarget, "info_hint_air" ) || FClassnameIs( pTarget, "info_target" ) ) + { + AngleVectors( pTarget->GetAbsAngles(), vOut ); + return true; + } + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +Vector CNPC_BaseScanner::VelocityToEvade(CBaseCombatCharacter *pEnemy) +{ + if (pEnemy) + { + // ----------------------------------------- + // Keep out of enemy's shooting position + // ----------------------------------------- + Vector vEnemyFacing = pEnemy->BodyDirection2D( ); + Vector vEnemyDir = pEnemy->EyePosition() - GetLocalOrigin(); + VectorNormalize(vEnemyDir); + float fDotPr = DotProduct(vEnemyFacing,vEnemyDir); + + if (fDotPr < -0.9) + { + Vector vDirUp(0,0,1); + Vector vDir; + CrossProduct( vEnemyFacing, vDirUp, vDir); + + Vector crossProduct; + CrossProduct(vEnemyFacing, vEnemyDir, crossProduct); + if (crossProduct.y < 0) + { + vDir = vDir * -1; + } + return (vDir); + } + else if (fDotPr < -0.85) + { + Vector vDirUp(0,0,1); + Vector vDir; + CrossProduct( vEnemyFacing, vDirUp, vDir); + + Vector crossProduct; + CrossProduct(vEnemyFacing, vEnemyDir, crossProduct); + if (random->RandomInt(0,1)) + { + vDir = vDir * -1; + } + return (vDir); + } + } + return vec3_origin; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int CNPC_BaseScanner::DrawDebugTextOverlays(void) +{ + int nOffset = BaseClass::DrawDebugTextOverlays(); + + if ( m_debugOverlays & OVERLAY_TEXT_BIT ) + { + Vector vel; + GetVelocity( &vel, NULL ); + + char tempstr[512]; + Q_snprintf( tempstr, sizeof(tempstr), "speed (max): %.2f (%.2f)", vel.Length(), m_flSpeed ); + EntityText( nOffset, tempstr, 0 ); + nOffset++; + } + + return nOffset; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : float +//----------------------------------------------------------------------------- +float CNPC_BaseScanner::GetHeadTurnRate( void ) +{ + if ( GetEnemy() ) + return 800.0f; + + return 350.0f; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +inline CBaseEntity *CNPC_BaseScanner::EntityToWatch( void ) +{ + return ( GetTarget() != NULL ) ? GetTarget() : GetEnemy(); // Okay if NULL +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : flInterval - +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::UpdateHead( float flInterval ) +{ + float yaw = GetPoseParameter( m_nPoseFaceHoriz ); + float pitch = GetPoseParameter( m_nPoseFaceVert ); + + CBaseEntity *pTarget = EntityToWatch(); + + Vector vLookPos; + + if ( !HasCondition( COND_IN_PVS ) || GetAttachment( "eyes", vLookPos ) == false ) + { + vLookPos = EyePosition(); + } + + if ( pTarget != NULL ) + { + Vector lookDir = pTarget->EyePosition() - vLookPos; + VectorNormalize( lookDir ); + + if ( DotProduct( lookDir, BodyDirection3D() ) < 0.0f ) + { + SetPoseParameter( m_nPoseFaceHoriz, UTIL_Approach( 0, yaw, 10 ) ); + SetPoseParameter( m_nPoseFaceVert, UTIL_Approach( 0, pitch, 10 ) ); + + return; + } + + float facingYaw = VecToYaw( BodyDirection3D() ); + float yawDiff = VecToYaw( lookDir ); + yawDiff = UTIL_AngleDiff( yawDiff, facingYaw + yaw ); + + float facingPitch = UTIL_VecToPitch( BodyDirection3D() ); + float pitchDiff = UTIL_VecToPitch( lookDir ); + pitchDiff = UTIL_AngleDiff( pitchDiff, facingPitch + pitch ); + + SetPoseParameter( m_nPoseFaceHoriz, UTIL_Approach( yaw + yawDiff, yaw, 50 ) ); + SetPoseParameter( m_nPoseFaceVert, UTIL_Approach( pitch + pitchDiff, pitch, 50 ) ); + } + else + { + SetPoseParameter( m_nPoseFaceHoriz, UTIL_Approach( 0, yaw, 10 ) ); + SetPoseParameter( m_nPoseFaceVert, UTIL_Approach( 0, pitch, 10 ) ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : &linear - +// &angular - +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::ClampMotorForces( Vector &linear, AngularImpulse &angular ) +{ + // limit reaction forces + if ( m_nFlyMode != SCANNER_FLY_DIVE ) + { + linear.x = clamp( linear.x, -500, 500 ); + linear.y = clamp( linear.y, -500, 500 ); + linear.z = clamp( linear.z, -500, 500 ); + } + + // If we're dive bombing, we need to drop faster than normal + if ( m_nFlyMode != SCANNER_FLY_DIVE ) + { + // Add in weightlessness + linear.z += 800; + } + + angular.z = clamp( angular.z, -GetHeadTurnRate(), GetHeadTurnRate() ); + if ( m_nFlyMode == SCANNER_FLY_DIVE ) + { + // Disable pitch and roll motors while crashing. + angular.x = 0; + angular.y = 0; + } +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : &inputdata - +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::InputSetDistanceOverride( inputdata_t &inputdata ) +{ + m_flGoalOverrideDistance = inputdata.value.Float(); +} + +//----------------------------------------------------------------------------- +// Purpose: Emit sounds specific to the NPC's state. +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::AlertSound(void) +{ + ScannerEmitSound( "Alert" ); +} + +//------------------------------------------------------------------------------ +// Purpose: +//------------------------------------------------------------------------------ +void CNPC_BaseScanner::DeathSound( const CTakeDamageInfo &info ) +{ + ScannerEmitSound( "Die" ); +} + +//----------------------------------------------------------------------------- +// Purpose: Overridden so that scanners play battle sounds while fighting. +// Output : Returns TRUE on success, FALSE on failure. +//----------------------------------------------------------------------------- +bool CNPC_BaseScanner::ShouldPlayIdleSound( void ) +{ + if ( HasSpawnFlags( SF_NPC_GAG ) ) + return false; + + if ( random->RandomInt( 0, 25 ) != 0 ) + return false; + + return true; +} + + +//----------------------------------------------------------------------------- +// Purpose: Plays sounds while idle or in combat. +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::IdleSound(void) +{ + if ( m_NPCState == NPC_STATE_COMBAT ) + { + // dvs: the combat sounds should be related to what is happening, rather than random + ScannerEmitSound( "Combat" ); + } + else + { + ScannerEmitSound( "Idle" ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Plays a sound when hurt. +//----------------------------------------------------------------------------- +void CNPC_BaseScanner::PainSound( const CTakeDamageInfo &info ) +{ + ScannerEmitSound( "Pain" ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +float CNPC_BaseScanner::GetMaxSpeed() +{ + return SCANNER_MAX_SPEED; +} + +//----------------------------------------------------------------------------- +// +// Schedules +// +//----------------------------------------------------------------------------- + +AI_BEGIN_CUSTOM_NPC( npc_basescanner, CNPC_BaseScanner ) + + DECLARE_TASK( TASK_SCANNER_SET_FLY_PATROL ) + DECLARE_TASK( TASK_SCANNER_SET_FLY_CHASE ) + DECLARE_TASK( TASK_SCANNER_SET_FLY_ATTACK ) + DECLARE_TASK( TASK_SCANNER_SET_FLY_DIVE ) + + DECLARE_CONDITION(COND_SCANNER_FLY_CLEAR) + DECLARE_CONDITION(COND_SCANNER_FLY_BLOCKED) + DECLARE_CONDITION(COND_SCANNER_RELEASED_FROM_PHYSCANNON) + DECLARE_CONDITION(COND_SCANNER_GRABBED_BY_PHYSCANNON) + + //========================================================= + // > SCHED_SCANNER_PATROL + //========================================================= + DEFINE_SCHEDULE + ( + SCHED_SCANNER_PATROL, + + " Tasks" + " TASK_SCANNER_SET_FLY_PATROL 0" + " TASK_SET_TOLERANCE_DISTANCE 32" + " TASK_SET_ROUTE_SEARCH_TIME 5" // Spend 5 seconds trying to build a path if stuck + " TASK_GET_PATH_TO_RANDOM_NODE 2000" + " TASK_RUN_PATH 0" + " TASK_WAIT_FOR_MOVEMENT 0" + "" + " Interrupts" + " COND_GIVE_WAY" + " COND_NEW_ENEMY" + " COND_SEE_ENEMY" + " COND_SEE_FEAR" + " COND_HEAR_COMBAT" + " COND_HEAR_DANGER" + " COND_HEAR_PLAYER" + " COND_LIGHT_DAMAGE" + " COND_HEAVY_DAMAGE" + " COND_PROVOKED" + " COND_SCANNER_GRABBED_BY_PHYSCANNON" + ) + + //========================================================= + // > SCHED_SCANNER_ATTACK + // + // This task does nothing. Translate it in your derived + // class to perform your attack. + // + //========================================================= + DEFINE_SCHEDULE + ( + SCHED_SCANNER_ATTACK, + + " Tasks" + " TASK_SCANNER_SET_FLY_ATTACK 0" + " TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE" + " TASK_WAIT 0.1" + "" + " Interrupts" + " COND_TOO_FAR_TO_ATTACK" + " COND_SCANNER_FLY_BLOCKED" + " COND_NEW_ENEMY" + " COND_SCANNER_GRABBED_BY_PHYSCANNON" + ) + + //========================================================= + // > SCHED_SCANNER_ATTACK_HOVER + //========================================================= + DEFINE_SCHEDULE + ( + SCHED_SCANNER_ATTACK_HOVER, + + " Tasks" + " TASK_SCANNER_SET_FLY_ATTACK 0" + " TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE" + " TASK_WAIT 0.1" + "" + " Interrupts" + " COND_TOO_FAR_TO_ATTACK" + " COND_SCANNER_FLY_BLOCKED" + " COND_NEW_ENEMY" + " COND_SCANNER_GRABBED_BY_PHYSCANNON" + ) + + //========================================================= + // > SCHED_SCANNER_ATTACK_DIVEBOMB + // + // Only done when scanner is dead + //========================================================= + DEFINE_SCHEDULE + ( + SCHED_SCANNER_ATTACK_DIVEBOMB, + + " Tasks" + " TASK_SCANNER_SET_FLY_DIVE 0" + " TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE" + " TASK_WAIT 10" + "" + " Interrupts" + " COND_SCANNER_GRABBED_BY_PHYSCANNON" + ) + + //========================================================= + // > SCHED_SCANNER_CHASE_ENEMY + // + // Different interrupts than normal chase enemy. + //========================================================= + DEFINE_SCHEDULE + ( + SCHED_SCANNER_CHASE_ENEMY, + + " Tasks" + " TASK_SCANNER_SET_FLY_CHASE 0" + " TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_SCANNER_PATROL" + " TASK_SET_TOLERANCE_DISTANCE 120" + " TASK_GET_PATH_TO_ENEMY 0" + " TASK_RUN_PATH 0" + " TASK_WAIT_FOR_MOVEMENT 0" + "" + "" + " Interrupts" + " COND_SCANNER_FLY_CLEAR" + " COND_NEW_ENEMY" + " COND_ENEMY_DEAD" + " COND_LOST_ENEMY" + " COND_SCANNER_GRABBED_BY_PHYSCANNON" + ) + + //========================================================= + // > SCHED_SCANNER_CHASE_TARGET + //========================================================= + DEFINE_SCHEDULE + ( + SCHED_SCANNER_CHASE_TARGET, + + " Tasks" + " TASK_SCANNER_SET_FLY_CHASE 0" + " TASK_SET_TOLERANCE_DISTANCE 64" + " TASK_GET_PATH_TO_TARGET 0" //FIXME: This is wrong! + " TASK_RUN_PATH 0" + " TASK_WAIT_FOR_MOVEMENT 0" + "" + " Interrupts" + " COND_SCANNER_FLY_CLEAR" + " COND_NEW_ENEMY" + " COND_SCANNER_GRABBED_BY_PHYSCANNON" + ) + + //========================================================= + // > SCHED_SCANNER_FOLLOW_HOVER + //========================================================= + DEFINE_SCHEDULE + ( + SCHED_SCANNER_FOLLOW_HOVER, + + " Tasks" + " TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE" + " TASK_WAIT 0.1" + "" + " Interrupts" + " COND_SCANNER_FLY_BLOCKED" + " COND_SCANNER_GRABBED_BY_PHYSCANNON" + ) + + //========================================================= + // > SCHED_SCANNER_HELD_BY_PHYSCANNON + //========================================================= + DEFINE_SCHEDULE + ( + SCHED_SCANNER_HELD_BY_PHYSCANNON, + + " Tasks" + " TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE" + " TASK_WAIT 5.0" + "" + " Interrupts" + " COND_LIGHT_DAMAGE" + " COND_HEAVY_DAMAGE" + " COND_SCANNER_RELEASED_FROM_PHYSCANNON" + ) + +AI_END_CUSTOM_NPC() |