From 39ed87570bdb2f86969d4be821c94b722dc71179 Mon Sep 17 00:00:00 2001 From: Joe Ludwig Date: Wed, 26 Jun 2013 15:22:04 -0700 Subject: First version of the SOurce SDK 2013 --- mp/src/game/server/ai_basenpc.cpp | 14130 ++++++++++++++++++++++++++++++++++++ 1 file changed, 14130 insertions(+) create mode 100644 mp/src/game/server/ai_basenpc.cpp (limited to 'mp/src/game/server/ai_basenpc.cpp') diff --git a/mp/src/game/server/ai_basenpc.cpp b/mp/src/game/server/ai_basenpc.cpp new file mode 100644 index 00000000..54b47636 --- /dev/null +++ b/mp/src/game/server/ai_basenpc.cpp @@ -0,0 +1,14130 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + +#include "cbase.h" + +#include "ai_basenpc.h" +#include "fmtstr.h" +#include "activitylist.h" +#include "animation.h" +#include "basecombatweapon.h" +#include "soundent.h" +#include "decals.h" +#include "entitylist.h" +#include "eventqueue.h" +#include "entityapi.h" +#include "bitstring.h" +#include "gamerules.h" // For g_pGameRules +#include "scripted.h" +#include "worldsize.h" +#include "game.h" +#include "shot_manipulator.h" + +#ifdef HL2_DLL +#include "ai_interactions.h" +#include "hl2_gamerules.h" +#endif // HL2_DLL + +#include "ai_network.h" +#include "ai_networkmanager.h" +#include "ai_pathfinder.h" +#include "ai_node.h" +#include "ai_default.h" +#include "ai_schedule.h" +#include "ai_task.h" +#include "ai_hull.h" +#include "ai_moveprobe.h" +#include "ai_hint.h" +#include "ai_navigator.h" +#include "ai_senses.h" +#include "ai_squadslot.h" +#include "ai_memory.h" +#include "ai_squad.h" +#include "ai_localnavigator.h" +#include "ai_tacticalservices.h" +#include "ai_behavior.h" +#include "ai_dynamiclink.h" +#include "AI_Criteria.h" +#include "basegrenade_shared.h" +#include "ammodef.h" +#include "player.h" +#include "sceneentity.h" +#include "ndebugoverlay.h" +#include "mathlib/mathlib.h" +#include "bone_setup.h" +#include "IEffects.h" +#include "vstdlib/random.h" +#include "engine/IEngineSound.h" +#include "tier1/strtools.h" +#include "doors.h" +#include "BasePropDoor.h" +#include "saverestore_utlvector.h" +#include "npcevent.h" +#include "movevars_shared.h" +#include "te_effect_dispatch.h" +#include "globals.h" +#include "saverestore_bitstring.h" +#include "checksum_crc.h" +#include "iservervehicle.h" +#include "filters.h" +#ifdef HL2_DLL +#include "npc_bullseye.h" +#include "hl2_player.h" +#include "weapon_physcannon.h" +#endif +#include "waterbullet.h" +#include "in_buttons.h" +#include "eventlist.h" +#include "globalstate.h" +#include "physics_prop_ragdoll.h" +#include "vphysics/friction.h" +#include "physics_npc_solver.h" +#include "tier0/vcrmode.h" +#include "death_pose.h" +#include "datacache/imdlcache.h" +#include "vstdlib/jobthread.h" + +#ifdef HL2_EPISODIC +#include "npc_alyx_episodic.h" +#endif + +#ifdef PORTAL + #include "prop_portal_shared.h" +#endif + +#include "env_debughistory.h" +#include "collisionutils.h" + +extern ConVar sk_healthkit; + +// dvs: for opening doors -- these should probably not be here +#include "ai_route.h" +#include "ai_waypoint.h" + +#include "utlbuffer.h" +#include "gamestats.h" + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + +#ifdef __clang__ + // These clang 3.1 warnings don't seem very useful, and cannot easily be + // avoided in this file. + #pragma GCC diagnostic ignored "-Wdangling-else" // warning: add explicit braces to avoid dangling else [-Wdangling-else] +#endif + +//#define DEBUG_LOOK + +bool RagdollManager_SaveImportant( CAI_BaseNPC *pNPC ); + +#define MIN_PHYSICS_FLINCH_DAMAGE 5.0f + +#define NPC_GRENADE_FEAR_DIST 200 +#define MAX_GLASS_PENETRATION_DEPTH 16.0f + +#define FINDNAMEDENTITY_MAX_ENTITIES 32 // max number of entities to be considered for random entity selection in FindNamedEntity + +extern bool g_fDrawLines; +extern short g_sModelIndexLaser; // holds the index for the laser beam +extern short g_sModelIndexLaserDot; // holds the index for the laser beam dot + +// Debugging tools +ConVar ai_no_select_box( "ai_no_select_box", "0" ); + +ConVar ai_show_think_tolerance( "ai_show_think_tolerance", "0" ); +ConVar ai_debug_think_ticks( "ai_debug_think_ticks", "0" ); +ConVar ai_debug_doors( "ai_debug_doors", "0" ); +ConVar ai_debug_enemies( "ai_debug_enemies", "0" ); + +ConVar ai_rebalance_thinks( "ai_rebalance_thinks", "1" ); +ConVar ai_use_efficiency( "ai_use_efficiency", "1" ); +ConVar ai_use_frame_think_limits( "ai_use_frame_think_limits", "1" ); +ConVar ai_default_efficient( "ai_default_efficient", ( IsX360() ) ? "1" : "0" ); +ConVar ai_efficiency_override( "ai_efficiency_override", "0" ); +ConVar ai_debug_efficiency( "ai_debug_efficiency", "0" ); +ConVar ai_debug_dyninteractions( "ai_debug_dyninteractions", "0", FCVAR_NONE, "Debug the NPC dynamic interaction system." ); +ConVar ai_frametime_limit( "ai_frametime_limit", "50", FCVAR_NONE, "frametime limit for min efficiency AIE_NORMAL (in sec's)." ); + +ConVar ai_use_think_optimizations( "ai_use_think_optimizations", "1" ); + +ConVar ai_test_moveprobe_ignoresmall( "ai_test_moveprobe_ignoresmall", "0" ); + +#ifdef HL2_EPISODIC +extern ConVar ai_vehicle_avoidance; +#endif // HL2_EPISODIC + +#ifndef _RETAIL +#define ShouldUseEfficiency() ( ai_use_think_optimizations.GetBool() && ai_use_efficiency.GetBool() ) +#define ShouldUseFrameThinkLimits() ( ai_use_think_optimizations.GetBool() && ai_use_frame_think_limits.GetBool() ) +#define ShouldRebalanceThinks() ( ai_use_think_optimizations.GetBool() && ai_rebalance_thinks.GetBool() ) +#define ShouldDefaultEfficient() ( ai_use_think_optimizations.GetBool() && ai_default_efficient.GetBool() ) +#else +#define ShouldUseEfficiency() ( true ) +#define ShouldUseFrameThinkLimits() ( true ) +#define ShouldRebalanceThinks() ( true ) +#define ShouldDefaultEfficient() ( true ) +#endif + +#ifndef _RETAIL +#define DbgEnemyMsg if ( !ai_debug_enemies.GetBool() ) ; else DevMsg +#else +#define DbgEnemyMsg if ( 0 ) ; else DevMsg +#endif + +#ifdef DEBUG_AI_FRAME_THINK_LIMITS +#define DbgFrameLimitMsg DevMsg +#else +#define DbgFrameLimitMsg (void) +#endif + +// NPC damage adjusters +ConVar sk_npc_head( "sk_npc_head","2" ); +ConVar sk_npc_chest( "sk_npc_chest","1" ); +ConVar sk_npc_stomach( "sk_npc_stomach","1" ); +ConVar sk_npc_arm( "sk_npc_arm","1" ); +ConVar sk_npc_leg( "sk_npc_leg","1" ); +ConVar showhitlocation( "showhitlocation", "0" ); + +// Squad debugging +ConVar ai_debug_squads( "ai_debug_squads", "0" ); +ConVar ai_debug_loners( "ai_debug_loners", "0" ); + +// Shoot trajectory +ConVar ai_lead_time( "ai_lead_time","0.0" ); +ConVar ai_shot_stats( "ai_shot_stats", "0" ); +ConVar ai_shot_stats_term( "ai_shot_stats_term", "1000" ); +ConVar ai_shot_bias( "ai_shot_bias", "1.0" ); + +ConVar ai_spread_defocused_cone_multiplier( "ai_spread_defocused_cone_multiplier","3.0" ); +ConVar ai_spread_cone_focus_time( "ai_spread_cone_focus_time","0.6" ); +ConVar ai_spread_pattern_focus_time( "ai_spread_pattern_focus_time","0.8" ); + +ConVar ai_reaction_delay_idle( "ai_reaction_delay_idle","0.3" ); +ConVar ai_reaction_delay_alert( "ai_reaction_delay_alert", "0.1" ); + +ConVar ai_strong_optimizations( "ai_strong_optimizations", ( IsX360() ) ? "1" : "0" ); +bool AIStrongOpt( void ) +{ + return ai_strong_optimizations.GetBool(); +} + +//----------------------------------------------------------------------------- +// +// Crude frame timings +// + +CFastTimer g_AIRunTimer; +CFastTimer g_AIPostRunTimer; +CFastTimer g_AIMoveTimer; + +CFastTimer g_AIConditionsTimer; +CFastTimer g_AIPrescheduleThinkTimer; +CFastTimer g_AIMaintainScheduleTimer; + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- + +CAI_Manager g_AI_Manager; + +//------------------------------------- + +CAI_Manager::CAI_Manager() +{ + m_AIs.EnsureCapacity( MAX_AIS ); +} + +//------------------------------------- + +CAI_BaseNPC **CAI_Manager::AccessAIs() +{ + if (m_AIs.Count()) + return &m_AIs[0]; + return NULL; +} + +//------------------------------------- + +int CAI_Manager::NumAIs() +{ + return m_AIs.Count(); +} + +//------------------------------------- + +void CAI_Manager::AddAI( CAI_BaseNPC *pAI ) +{ + m_AIs.AddToTail( pAI ); +} + +//------------------------------------- + +void CAI_Manager::RemoveAI( CAI_BaseNPC *pAI ) +{ + int i = m_AIs.Find( pAI ); + + if ( i != -1 ) + m_AIs.FastRemove( i ); +} + + +//----------------------------------------------------------------------------- + +// ================================================================ +// Init static data +// ================================================================ +int CAI_BaseNPC::m_nDebugBits = 0; +CAI_BaseNPC* CAI_BaseNPC::m_pDebugNPC = NULL; +int CAI_BaseNPC::m_nDebugPauseIndex = -1; + +CAI_ClassScheduleIdSpace CAI_BaseNPC::gm_ClassScheduleIdSpace( true ); +CAI_GlobalScheduleNamespace CAI_BaseNPC::gm_SchedulingSymbols; +CAI_LocalIdSpace CAI_BaseNPC::gm_SquadSlotIdSpace( true ); + +string_t CAI_BaseNPC::gm_iszPlayerSquad; + +int CAI_BaseNPC::gm_iNextThinkRebalanceTick; +float CAI_BaseNPC::gm_flTimeLastSpawn; +int CAI_BaseNPC::gm_nSpawnedThisFrame; + +CSimpleSimTimer CAI_BaseNPC::m_AnyUpdateEnemyPosTimer; + +// +// Deferred Navigation calls go here +// + +CPostFrameNavigationHook g_PostFrameNavigationHook; +CPostFrameNavigationHook *PostFrameNavigationSystem( void ) +{ + return &g_PostFrameNavigationHook; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CPostFrameNavigationHook::Init( void ) +{ + m_Functors.Purge(); + m_bGameFrameRunning = false; + return true; +} + +// Main query job +CJob *g_pQueuedNavigationQueryJob = NULL; + +static void ProcessNavigationQueries( CFunctor **pData, unsigned int nCount ) +{ + // Run all queued navigation on a separate thread + for ( int i = 0; i < nCount; i++ ) + { + (*pData[i])(); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CPostFrameNavigationHook::FrameUpdatePreEntityThink( void ) +{ + // If the thread is executing, then wait for it to finish + if ( g_pQueuedNavigationQueryJob ) + { + g_pQueuedNavigationQueryJob->WaitForFinishAndRelease(); + g_pQueuedNavigationQueryJob = NULL; + m_Functors.Purge(); + } + + if ( ai_post_frame_navigation.GetBool() == false ) + return; + + SetGrameFrameRunning( true ); +} + +//----------------------------------------------------------------------------- +// Purpose: Now that the game frame has collected all the navigation queries, service them +//----------------------------------------------------------------------------- +void CPostFrameNavigationHook::FrameUpdatePostEntityThink( void ) +{ + if ( ai_post_frame_navigation.GetBool() == false ) + return; + + // The guts of the NPC will check against this to decide whether or not to queue its navigation calls + SetGrameFrameRunning( false ); + + // Throw this off to a thread job + g_pQueuedNavigationQueryJob = ThreadExecute( &ProcessNavigationQueries, m_Functors.Base(), m_Functors.Count() ); +} + +//----------------------------------------------------------------------------- +// Purpose: Queue up our navigation call +//----------------------------------------------------------------------------- +void CPostFrameNavigationHook::EnqueueEntityNavigationQuery( CAI_BaseNPC *pNPC, CFunctor *pFunctor ) +{ + if ( ai_post_frame_navigation.GetBool() == false ) + return; + + m_Functors.AddToTail( pFunctor ); + pNPC->SetNavigationDeferred( true ); +} + +// +// Deferred Navigation calls go here +// + + +// ================================================================ +// Class Methods +// ================================================================ + +//----------------------------------------------------------------------------- +// Purpose: Static debug function to clear schedules for all NPCS +// Input : +// Output : +//----------------------------------------------------------------------------- +void CAI_BaseNPC::ClearAllSchedules(void) +{ + CAI_BaseNPC *npc = gEntList.NextEntByClass( (CAI_BaseNPC *)NULL ); + + while (npc) + { + npc->ClearSchedule( "CAI_BaseNPC::ClearAllSchedules" ); + npc->GetNavigator()->ClearGoal(); + npc = gEntList.NextEntByClass(npc); + } +} + +// ============================================================================== + +//----------------------------------------------------------------------------- +// Purpose: +// Input : +// Output : +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::Event_Gibbed( const CTakeDamageInfo &info ) +{ + bool gibbed = CorpseGib( info ); + + if ( gibbed ) + { + // don't remove players! + UTIL_Remove( this ); + SetThink( NULL ); //We're going away, so don't think anymore. + } + else + { + CorpseFade(); + } + + return gibbed; +} + +//========================================================= +// GetFlinchActivity - determines the best type of flinch +// anim to play. +//========================================================= +Activity CAI_BaseNPC::GetFlinchActivity( bool bHeavyDamage, bool bGesture ) +{ + Activity flinchActivity; + + switch ( LastHitGroup() ) + { + // pick a region-specific flinch + case HITGROUP_HEAD: + flinchActivity = bGesture ? ACT_GESTURE_FLINCH_HEAD : ACT_FLINCH_HEAD; + break; + case HITGROUP_STOMACH: + flinchActivity = bGesture ? ACT_GESTURE_FLINCH_STOMACH : ACT_FLINCH_STOMACH; + break; + case HITGROUP_LEFTARM: + flinchActivity = bGesture ? ACT_GESTURE_FLINCH_LEFTARM : ACT_FLINCH_LEFTARM; + break; + case HITGROUP_RIGHTARM: + flinchActivity = bGesture ? ACT_GESTURE_FLINCH_RIGHTARM : ACT_FLINCH_RIGHTARM; + break; + case HITGROUP_LEFTLEG: + flinchActivity = bGesture ? ACT_GESTURE_FLINCH_LEFTLEG : ACT_FLINCH_LEFTLEG; + break; + case HITGROUP_RIGHTLEG: + flinchActivity = bGesture ? ACT_GESTURE_FLINCH_RIGHTLEG : ACT_FLINCH_RIGHTLEG; + break; + case HITGROUP_CHEST: + flinchActivity = bGesture ? ACT_GESTURE_FLINCH_CHEST : ACT_FLINCH_CHEST; + break; + case HITGROUP_GEAR: + case HITGROUP_GENERIC: + default: + // just get a generic flinch. + if ( bHeavyDamage ) + { + flinchActivity = bGesture ? ACT_GESTURE_BIG_FLINCH : ACT_BIG_FLINCH; + } + else + { + flinchActivity = bGesture ? ACT_GESTURE_SMALL_FLINCH : ACT_SMALL_FLINCH; + } + break; + } + + // do we have a sequence for the ideal activity? + if ( SelectWeightedSequence ( flinchActivity ) == ACTIVITY_NOT_AVAILABLE ) + { + if ( bHeavyDamage ) + { + flinchActivity = bGesture ? ACT_GESTURE_BIG_FLINCH : ACT_BIG_FLINCH; + + // If we fail at finding a big flinch, resort to a small one + if ( SelectWeightedSequence ( flinchActivity ) == ACTIVITY_NOT_AVAILABLE ) + { + flinchActivity = bGesture ? ACT_GESTURE_SMALL_FLINCH : ACT_SMALL_FLINCH; + } + } + else + { + flinchActivity = bGesture ? ACT_GESTURE_SMALL_FLINCH : ACT_SMALL_FLINCH; + } + } + + return flinchActivity; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : +//----------------------------------------------------------------------------- +void CAI_BaseNPC::CleanupOnDeath( CBaseEntity *pCulprit, bool bFireDeathOutput ) +{ + if ( !m_bDidDeathCleanup ) + { + m_bDidDeathCleanup = true; + + if ( m_NPCState == NPC_STATE_SCRIPT && m_hCine ) + { + // bail out of this script here + m_hCine->CancelScript(); + // now keep going with the death code + } + + if ( GetHintNode() ) + { + GetHintNode()->Unlock(); + SetHintNode( NULL ); + } + + if( bFireDeathOutput ) + { + m_OnDeath.FireOutput( pCulprit, this ); + } + + // Vacate any strategy slot I might have + VacateStrategySlot(); + + // Remove from squad if in one + if (m_pSquad) + { + // If I'm in idle it means that I didn't see who killed me + // and my squad is still in idle state. Tell squad we have + // an enemy to wake them up and put the enemy position at + // my death position + if ( m_NPCState == NPC_STATE_IDLE && pCulprit) + { + // If we already have some danger memory, don't do this cheat + if ( GetEnemies()->GetDangerMemory() == NULL ) + { + UpdateEnemyMemory( pCulprit, GetAbsOrigin() ); + } + } + + // Remove from squad + m_pSquad->RemoveFromSquad(this, true); + m_pSquad = NULL; + } + + RemoveActorFromScriptedScenes( this, false /*all scenes*/ ); + } + else + DevMsg( "Unexpected double-death-cleanup\n" ); +} + +void CAI_BaseNPC::SelectDeathPose( const CTakeDamageInfo &info ) +{ + if ( !GetModelPtr() || (info.GetDamageType() & DMG_PREVENT_PHYSICS_FORCE) ) + return; + + if ( ShouldPickADeathPose() == false ) + return; + + Activity aActivity = ACT_INVALID; + int iDeathFrame = 0; + + SelectDeathPoseActivityAndFrame( this, info, LastHitGroup(), aActivity, iDeathFrame ); + if ( aActivity == ACT_INVALID ) + { + SetDeathPose( ACT_INVALID ); + SetDeathPoseFrame( 0 ); + return; + } + + SetDeathPose( SelectWeightedSequence( aActivity ) ); + SetDeathPoseFrame( iDeathFrame ); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : +//----------------------------------------------------------------------------- +void CAI_BaseNPC::Event_Killed( const CTakeDamageInfo &info ) +{ + if (IsCurSchedule(SCHED_NPC_FREEZE)) + { + // We're frozen; don't die. + return; + } + + Wake( false ); + + //Adrian: Select a death pose to extrapolate the ragdoll's velocity. + SelectDeathPose( info ); + + m_lifeState = LIFE_DYING; + + CleanupOnDeath( info.GetAttacker() ); + + StopLoopingSounds(); + DeathSound( info ); + + if ( ( GetFlags() & FL_NPC ) && ( ShouldGib( info ) == false ) ) + { + SetTouch( NULL ); + } + + BaseClass::Event_Killed( info ); + + if ( m_bFadeCorpse ) + { + m_bImportanRagdoll = RagdollManager_SaveImportant( this ); + } + + // Make sure this condition is fired too (OnTakeDamage breaks out before this happens on death) + SetCondition( COND_LIGHT_DAMAGE ); + SetIdealState( NPC_STATE_DEAD ); + + // Some characters rely on getting a state transition, even to death. + // zombies, for instance. When a character becomes a ragdoll, their + // server entity ceases to think, so we have to set the dead state here + // because the AI code isn't going to pick up the change on the next think + // for us. + + // Adrian - Only set this if we are going to become a ragdoll. We still want to + // select SCHED_DIE or do something special when this NPC dies and we wont + // catch the change of state if we set this to whatever the ideal state is. + if ( CanBecomeRagdoll() || IsRagdoll() ) + SetState( NPC_STATE_DEAD ); + + // If the remove-no-ragdoll flag is set in the damage type, we're being + // told to remove ourselves immediately on death. This is used when something + // else has some special reason for us to vanish instead of creating a ragdoll. + // i.e. The barnacle does this because it's already got a ragdoll for us. + if ( info.GetDamageType() & DMG_REMOVENORAGDOLL ) + { + if ( !IsEFlagSet( EFL_IS_BEING_LIFTED_BY_BARNACLE ) ) + { + // Go away + RemoveDeferred(); + } + } +} + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::Ignite( float flFlameLifetime, bool bNPCOnly, float flSize, bool bCalledByLevelDesigner ) +{ + BaseClass::Ignite( flFlameLifetime, bNPCOnly, flSize, bCalledByLevelDesigner ); + +#ifdef HL2_EPISODIC + CBasePlayer *pPlayer = AI_GetSinglePlayer(); + if ( pPlayer->IRelationType( this ) != D_LI ) + { + CNPC_Alyx *alyx = CNPC_Alyx::GetAlyx(); + + if ( alyx ) + { + alyx->EnemyIgnited( this ); + } + } +#endif +} + +//----------------------------------------------------------------------------- + +ConVar ai_block_damage( "ai_block_damage","0" ); + +bool CAI_BaseNPC::PassesDamageFilter( const CTakeDamageInfo &info ) +{ + if ( ai_block_damage.GetBool() ) + return false; + // FIXME: hook a friendly damage filter to the npc instead? + if ( (CapabilitiesGet() & bits_CAP_FRIENDLY_DMG_IMMUNE) && info.GetAttacker() && info.GetAttacker() != this ) + { + // check attackers relationship with me + CBaseCombatCharacter *npcEnemy = info.GetAttacker()->MyCombatCharacterPointer(); + bool bHitByVehicle = false; + if ( !npcEnemy ) + { + if ( info.GetAttacker()->GetServerVehicle() ) + { + bHitByVehicle = true; + } + } + + if ( bHitByVehicle || (npcEnemy && npcEnemy->IRelationType( this ) == D_LI) ) + { + m_fNoDamageDecal = true; + + if ( npcEnemy && npcEnemy->IsPlayer() ) + { + m_OnDamagedByPlayer.FireOutput( info.GetAttacker(), this ); + // This also counts as being harmed by player's squad. + m_OnDamagedByPlayerSquad.FireOutput( info.GetAttacker(), this ); + } + + return false; + } + } + + if ( !BaseClass::PassesDamageFilter( info ) ) + { + m_fNoDamageDecal = true; + return false; + } + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : +// Output : +//----------------------------------------------------------------------------- +int CAI_BaseNPC::OnTakeDamage_Alive( const CTakeDamageInfo &info ) +{ + Forget( bits_MEMORY_INCOVER ); + + if ( !BaseClass::OnTakeDamage_Alive( info ) ) + return 0; + + if ( GetSleepState() == AISS_WAITING_FOR_THREAT ) + Wake(); + + // 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 ( !m_pSquad || !m_pSquad->SquadIsMember( info.GetAttacker() ) ) + { + 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 ) + { + // 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() && info.GetAttacker() != m_hInteractionPartner ) + { + m_iHealth = 1; + } + +#if 0 + // HACKHACK Don't kill npcs in a script. Let them break their scripts first + // THIS is a Half-Life 1 hack that's not cutting the mustard in the scripts + // that have been authored for Half-Life 2 thus far. (sjb) + if ( m_NPCState == NPC_STATE_SCRIPT ) + { + SetCondition( COND_LIGHT_DAMAGE ); + } +#endif + + // ----------------------------------- + // Fire outputs + // ----------------------------------- + if ( m_flLastDamageTime != gpGlobals->curtime ) + { + // only fire once per frame + m_OnDamaged.FireOutput( info.GetAttacker(), this); + + if( info.GetAttacker()->IsPlayer() ) + { + m_OnDamagedByPlayer.FireOutput( info.GetAttacker(), this ); + + // This also counts as being harmed by player's squad. + m_OnDamagedByPlayerSquad.FireOutput( info.GetAttacker(), this ); + } + else + { + // See if the person that injured me is an NPC. + CAI_BaseNPC *pAttacker = dynamic_cast( info.GetAttacker() ); + CBasePlayer *pPlayer = AI_GetSinglePlayer(); + + if( pAttacker && pAttacker->IsAlive() && pPlayer ) + { + if( pAttacker->GetSquad() != NULL && pAttacker->IsInPlayerSquad() ) + { + m_OnDamagedByPlayerSquad.FireOutput( info.GetAttacker(), 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( info.GetAttacker(), this ); + } + + // react to the damage (get mad) + if ( ( (GetFlags() & FL_NPC) == 0 ) || !info.GetAttacker() ) + return 1; + + // If the attacker was an NPC or client update my position memory + if ( info.GetAttacker()->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( info.GetAttacker() ) || !FVisible( 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; + if (info.GetInflictor()) + { + vAttackPos = info.GetInflictor()->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(), vAttackPos, GetEnemy()); + } + // ---------------------------------------------------------------- + // 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 ( info.GetAttacker() && info.GetAttacker()->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 + // --------------------------------------------------------------- + CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 1024, 0.5, this, SOUNDENT_CHANNEL_INJURY ); + + return 1; +} + + +//========================================================= +// OnTakeDamage_Dying - takedamage function called when a npc's +// corpse is damaged. +//========================================================= +int CAI_BaseNPC::OnTakeDamage_Dying( const CTakeDamageInfo &info ) +{ + if ( info.GetDamageType() & DMG_PLASMA ) + { + if ( m_takedamage != DAMAGE_EVENTS_ONLY ) + { + m_iHealth -= info.GetDamage(); + + if (m_iHealth < -500) + { + UTIL_Remove(this); + } + } + } + return BaseClass::OnTakeDamage_Dying( info ); +} + +//========================================================= +// OnTakeDamage_Dead - takedamage function called when a npc's +// corpse is damaged. +//========================================================= +int CAI_BaseNPC::OnTakeDamage_Dead( const CTakeDamageInfo &info ) +{ + Vector vecDir; + + // grab the vector of the incoming attack. ( pretend that the inflictor is a little lower than it really is, so the body will tend to fly upward a bit). + vecDir = vec3_origin; + if ( info.GetInflictor() ) + { + vecDir = info.GetInflictor()->WorldSpaceCenter() - Vector ( 0, 0, 10 ) - WorldSpaceCenter(); + VectorNormalize( vecDir ); + g_vecAttackDir = vecDir; + } + +#if 0// turn this back on when the bounding box issues are resolved. + + SetGroundEntity( NULL ); + GetLocalOrigin().z += 1; + + // let the damage scoot the corpse around a bit. + if ( info.GetInflictor() && (info.GetAttacker()->GetSolid() != SOLID_TRIGGER) ) + { + ApplyAbsVelocityImpulse( vecDir * -DamageForce( flDamage ) ); + } + +#endif + + // kill the corpse if enough damage was done to destroy the corpse and the damage is of a type that is allowed to destroy the corpse. + if ( g_pGameRules->Damage_ShouldGibCorpse( info.GetDamageType() ) ) + { + // Accumulate corpse gibbing damage, so you can gib with multiple hits + if ( m_takedamage != DAMAGE_EVENTS_ONLY ) + { + m_iHealth -= info.GetDamage() * 0.1; + } + } + + if ( info.GetDamageType() & DMG_PLASMA ) + { + if ( m_takedamage != DAMAGE_EVENTS_ONLY ) + { + m_iHealth -= info.GetDamage(); + + if (m_iHealth < -500) + { + UTIL_Remove(this); + } + } + } + + return 1; +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +void CAI_BaseNPC::NotifyFriendsOfDamage( CBaseEntity *pAttackerEntity ) +{ + CAI_BaseNPC *pAttacker = pAttackerEntity->MyNPCPointer(); + if ( pAttacker ) + { + const Vector &origin = GetAbsOrigin(); + for ( int i = 0; i < g_AI_Manager.NumAIs(); i++ ) + { + const float NEAR_Z = 10*12; + const float NEAR_XY_SQ = Square( 50*12 ); + CAI_BaseNPC *pNpc = g_AI_Manager.AccessAIs()[i]; + if ( pNpc && pNpc != this ) + { + const Vector &originNpc = pNpc->GetAbsOrigin(); + if ( fabsf( originNpc.z - origin.z ) < NEAR_Z ) + { + if ( (originNpc.AsVector2D() - origin.AsVector2D()).LengthSqr() < NEAR_XY_SQ ) + { + if ( pNpc->GetSquad() == GetSquad() || IRelationType( pNpc ) == D_LI ) + pNpc->OnFriendDamaged( this, pAttacker ); + } + } + } + } + } +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +void CAI_BaseNPC::OnFriendDamaged( CBaseCombatCharacter *pSquadmate, CBaseEntity *pAttacker ) +{ + if ( GetSleepState() != AISS_WAITING_FOR_INPUT ) + { + float distSqToThreat = ( GetAbsOrigin() - pAttacker->GetAbsOrigin() ).LengthSqr(); + + if ( GetSleepState() != AISS_AWAKE && distSqToThreat < Square( 20 * 12 ) ) + Wake(); + + if ( distSqToThreat < Square( 50 * 12 ) ) + ForceGatherConditions(); + } +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::IsLightDamage( const CTakeDamageInfo &info ) +{ + // ALL nonzero damage is light damage! Mask off COND_LIGHT_DAMAGE if you want to ignore light damage. + return ( info.GetDamage() > 0 ); +} + +bool CAI_BaseNPC::IsHeavyDamage( const CTakeDamageInfo &info ) +{ + return ( info.GetDamage() > 20 ); +} + +void CAI_BaseNPC::DoRadiusDamage( const CTakeDamageInfo &info, int iClassIgnore, CBaseEntity *pEntityIgnore ) +{ + RadiusDamage( info, GetAbsOrigin(), info.GetDamage() * 2.5, iClassIgnore, pEntityIgnore ); +} + + +void CAI_BaseNPC::DoRadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrc, int iClassIgnore, CBaseEntity *pEntityIgnore ) +{ + RadiusDamage( info, vecSrc, info.GetDamage() * 2.5, iClassIgnore, pEntityIgnore ); +} + + +//----------------------------------------------------------------------------- +// Set the contents types that are solid by default to all NPCs +//----------------------------------------------------------------------------- +unsigned int CAI_BaseNPC::PhysicsSolidMaskForEntity( void ) const +{ + return MASK_NPCSOLID; +} + + +//========================================================= + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::DecalTrace( trace_t *pTrace, char const *decalName ) +{ + if ( m_fNoDamageDecal ) + { + m_fNoDamageDecal = false; + // @Note (toml 04-23-03): e3, don't decal face on damage if still alive + return; + } + BaseClass::DecalTrace( pTrace, decalName ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName ) +{ + if ( m_fNoDamageDecal ) + { + m_fNoDamageDecal = false; + // @Note (toml 04-23-03): e3, don't decal face on damage if still alive + return; + } + BaseClass::ImpactTrace( pTrace, iDamageType, pCustomImpactName ); +} + +//--------------------------------------------------------- +// Return the number by which to multiply incoming damage +// based on the hitgroup it hits. This exists mainly so +// that individual NPC's can have more or less resistance +// to damage done to certain hitgroups. +//--------------------------------------------------------- +float CAI_BaseNPC::GetHitgroupDamageMultiplier( int iHitGroup, const CTakeDamageInfo &info ) +{ + switch( iHitGroup ) + { + case HITGROUP_GENERIC: + return 1.0f; + + case HITGROUP_HEAD: + return sk_npc_head.GetFloat(); + + case HITGROUP_CHEST: + return sk_npc_chest.GetFloat(); + + case HITGROUP_STOMACH: + return sk_npc_stomach.GetFloat(); + + case HITGROUP_LEFTARM: + case HITGROUP_RIGHTARM: + return sk_npc_arm.GetFloat(); + + case HITGROUP_LEFTLEG: + case HITGROUP_RIGHTLEG: + return sk_npc_leg.GetFloat(); + + default: + return 1.0f; + } +} + +//========================================================= +// TraceAttack +//========================================================= +void CAI_BaseNPC::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator ) +{ + m_fNoDamageDecal = false; + if ( m_takedamage == DAMAGE_NO ) + return; + + CTakeDamageInfo subInfo = info; + + SetLastHitGroup( ptr->hitgroup ); + m_nForceBone = ptr->physicsbone; // save this bone for physics forces + + Assert( m_nForceBone > -255 && m_nForceBone < 256 ); + + bool bDebug = showhitlocation.GetBool(); + + switch ( ptr->hitgroup ) + { + case HITGROUP_GENERIC: + if( bDebug ) DevMsg("Hit Location: Generic\n"); + break; + + // hit gear, react but don't bleed + case HITGROUP_GEAR: + subInfo.SetDamage( 0.01 ); + ptr->hitgroup = HITGROUP_GENERIC; + if( bDebug ) DevMsg("Hit Location: Gear\n"); + break; + + case HITGROUP_HEAD: + subInfo.ScaleDamage( GetHitgroupDamageMultiplier(ptr->hitgroup, info) ); + if( bDebug ) DevMsg("Hit Location: Head\n"); + break; + + case HITGROUP_CHEST: + subInfo.ScaleDamage( GetHitgroupDamageMultiplier(ptr->hitgroup, info) ); + if( bDebug ) DevMsg("Hit Location: Chest\n"); + break; + + case HITGROUP_STOMACH: + subInfo.ScaleDamage( GetHitgroupDamageMultiplier(ptr->hitgroup, info) ); + if( bDebug ) DevMsg("Hit Location: Stomach\n"); + break; + + case HITGROUP_LEFTARM: + case HITGROUP_RIGHTARM: + subInfo.ScaleDamage( GetHitgroupDamageMultiplier(ptr->hitgroup, info) ); + if( bDebug ) DevMsg("Hit Location: Left/Right Arm\n"); + break + ; + case HITGROUP_LEFTLEG: + case HITGROUP_RIGHTLEG: + subInfo.ScaleDamage( GetHitgroupDamageMultiplier(ptr->hitgroup, info) ); + if( bDebug ) DevMsg("Hit Location: Left/Right Leg\n"); + break; + + default: + if( bDebug ) DevMsg("Hit Location: UNKNOWN\n"); + break; + } + + if ( subInfo.GetDamage() >= 1.0 && !(subInfo.GetDamageType() & DMG_SHOCK ) ) + { + if( !IsPlayer() || ( IsPlayer() && g_pGameRules->IsMultiplayer() ) ) + { + // NPC's always bleed. Players only bleed in multiplayer. + SpawnBlood( ptr->endpos, vecDir, BloodColor(), subInfo.GetDamage() );// a little surface blood. + } + + TraceBleed( subInfo.GetDamage(), vecDir, ptr, subInfo.GetDamageType() ); + + if ( ptr->hitgroup == HITGROUP_HEAD && m_iHealth - subInfo.GetDamage() > 0 ) + { + m_fNoDamageDecal = true; + } + } + + // Airboat gun will impart major force if it's about to kill him.... + if ( info.GetDamageType() & DMG_AIRBOAT ) + { + if ( subInfo.GetDamage() >= GetHealth() ) + { + float flMagnitude = subInfo.GetDamageForce().Length(); + if ( (flMagnitude != 0.0f) && (flMagnitude < 400.0f * 65.0f) ) + { + subInfo.ScaleDamageForce( 400.0f * 65.0f / flMagnitude ); + } + } + } + + if( info.GetInflictor() ) + { + subInfo.SetInflictor( info.GetInflictor() ); + } + else + { + subInfo.SetInflictor( info.GetAttacker() ); + } + + AddMultiDamage( subInfo, this ); +} + +//----------------------------------------------------------------------------- +// Purpose: Checks if point is in spread angle between source and target Pos +// Used to prevent friendly fire +// Input : Source of attack, target position, spread angle +// Output : +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::PointInSpread( CBaseCombatCharacter *pCheckEntity, const Vector &sourcePos, const Vector &targetPos, const Vector &testPoint, float flSpread, float maxDistOffCenter ) +{ + float distOffLine = CalcDistanceToLine2D( testPoint.AsVector2D(), sourcePos.AsVector2D(), targetPos.AsVector2D() ); + if ( distOffLine < maxDistOffCenter ) + { + Vector toTarget = targetPos - sourcePos; + float distTarget = VectorNormalize(toTarget); + + Vector toTest = testPoint - sourcePos; + float distTest = VectorNormalize(toTest); + // Only reject if target is on other side + if (distTarget > distTest) + { + toTarget.z = 0.0; + toTest.z = 0.0; + + float dotProduct = DotProduct(toTarget,toTest); + if (dotProduct > flSpread) + { + return true; + } + else if( dotProduct > 0.0f ) + { + // If this guy is in front, do the hull/line test: + if( pCheckEntity ) + { + float flBBoxDist = NAI_Hull::Width( pCheckEntity->GetHullType() ); + flBBoxDist *= 1.414f; // sqrt(2) + + // !!!BUGBUG - this 2d check will stop a citizen shooting at a gunship or strider + // if another citizen is between them, even though the strider or gunship may be + // high up in the air (sjb) + distOffLine = CalcDistanceToLine( testPoint, sourcePos, targetPos ); + if( distOffLine < flBBoxDist ) + { + return true; + } + } + } + } + } + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: Checks if player is in spread angle between source and target Pos +// Used to prevent friendly fire +// Input : Source of attack, target position, spread angle +// Output : +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::PlayerInSpread( const Vector &sourcePos, const Vector &targetPos, float flSpread, float maxDistOffCenter, bool ignoreHatedPlayers ) +{ + // loop through all players + for (int i = 1; i <= gpGlobals->maxClients; i++ ) + { + CBasePlayer *pPlayer = UTIL_PlayerByIndex( i ); + + if ( pPlayer && ( !ignoreHatedPlayers || IRelationType( pPlayer ) != D_HT ) ) + { + if ( PointInSpread( pPlayer, sourcePos, targetPos, pPlayer->WorldSpaceCenter(), flSpread, maxDistOffCenter ) ) + return true; + } + } + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: Checks if player is in range of given location. Used by NPCs +// to prevent friendly fire +// Input : +// Output : +//----------------------------------------------------------------------------- +CBaseEntity *CAI_BaseNPC::PlayerInRange( const Vector &vecLocation, float flDist ) +{ + // loop through all players + for (int i = 1; i <= gpGlobals->maxClients; i++ ) + { + CBasePlayer *pPlayer = UTIL_PlayerByIndex( i ); + + if (pPlayer && (vecLocation - pPlayer->WorldSpaceCenter() ).Length2D() <= flDist) + { + return pPlayer; + } + } + return NULL; +} + + +#define BULLET_WIZZDIST 80.0 +#define SLOPE ( -1.0 / BULLET_WIZZDIST ) + +void BulletWizz( Vector vecSrc, Vector vecEndPos, edict_t *pShooter, bool isTracer ) +{ + CBasePlayer *pPlayer; + Vector vecBulletPath; + Vector vecPlayerPath; + Vector vecBulletDir; + Vector vecNearestPoint; + float flDist; + float flBulletDist; + + vecBulletPath = vecEndPos - vecSrc; + vecBulletDir = vecBulletPath; + VectorNormalize(vecBulletDir); + + // see how near this bullet passed by player in a single player game + // for multiplayer, we need to go through the list of clients. + for (int i = 1; i <= gpGlobals->maxClients; i++ ) + { + pPlayer = UTIL_PlayerByIndex( i ); + + if ( !pPlayer ) + continue; + + // Don't hear one's own bullets + if( pPlayer->edict() == pShooter ) + continue; + + vecPlayerPath = pPlayer->EarPosition() - vecSrc; + flDist = DotProduct( vecPlayerPath, vecBulletDir ); + vecNearestPoint = vecSrc + vecBulletDir * flDist; + // FIXME: minus m_vecViewOffset? + flBulletDist = ( vecNearestPoint - pPlayer->EarPosition() ).Length(); + } +} + +//----------------------------------------------------------------------------- +// Hits triggers with raycasts +//----------------------------------------------------------------------------- +class CTriggerTraceEnum : public IEntityEnumerator +{ +public: + CTriggerTraceEnum( Ray_t *pRay, const CTakeDamageInfo &info, const Vector& dir, int contentsMask ) : + m_info( info ), m_VecDir(dir), m_ContentsMask(contentsMask), m_pRay(pRay) + { + } + + virtual bool EnumEntity( IHandleEntity *pHandleEntity ) + { + trace_t tr; + + CBaseEntity *pEnt = gEntList.GetBaseEntity( pHandleEntity->GetRefEHandle() ); + + // Done to avoid hitting an entity that's both solid & a trigger. + if ( pEnt->IsSolid() ) + return true; + + enginetrace->ClipRayToEntity( *m_pRay, m_ContentsMask, pHandleEntity, &tr ); + if (tr.fraction < 1.0f) + { + pEnt->DispatchTraceAttack( m_info, m_VecDir, &tr ); + ApplyMultiDamage(); + } + + return true; + } + +private: + Vector m_VecDir; + int m_ContentsMask; + Ray_t *m_pRay; + CTakeDamageInfo m_info; +}; + +void CBaseEntity::TraceAttackToTriggers( const CTakeDamageInfo &info, const Vector& start, const Vector& end, const Vector& dir ) +{ + Ray_t ray; + ray.Init( start, end ); + + CTriggerTraceEnum triggerTraceEnum( &ray, info, dir, MASK_SHOT ); + enginetrace->EnumerateEntities( ray, true, &triggerTraceEnum ); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : const char +//----------------------------------------------------------------------------- +const char *CAI_BaseNPC::GetTracerType( void ) +{ + if ( GetActiveWeapon() ) + { + return GetActiveWeapon()->GetTracerType(); + } + + return BaseClass::GetTracerType(); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : &vecTracerSrc - +// &tr - +// iTracerType - +//----------------------------------------------------------------------------- +void CAI_BaseNPC::MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType ) +{ + if ( GetActiveWeapon() ) + { + GetActiveWeapon()->MakeTracer( vecTracerSrc, tr, iTracerType ); + return; + } + + BaseClass::MakeTracer( vecTracerSrc, tr, iTracerType ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::FireBullets( const FireBulletsInfo_t &info ) +{ +#ifdef HL2_DLL + // If we're shooting at a bullseye, become perfectly accurate if the bullseye demands it + if ( GetEnemy() && GetEnemy()->Classify() == CLASS_BULLSEYE ) + { + CNPC_Bullseye *pBullseye = dynamic_cast(GetEnemy()); + if ( pBullseye && pBullseye->UsePerfectAccuracy() ) + { + FireBulletsInfo_t accurateInfo = info; + accurateInfo.m_vecSpread = vec3_origin; + BaseClass::FireBullets( accurateInfo ); + return; + } + } +#endif + + BaseClass::FireBullets( info ); +} + + +//----------------------------------------------------------------------------- +// Shot statistics +//----------------------------------------------------------------------------- +void CBaseEntity::UpdateShotStatistics( const trace_t &tr ) +{ + if ( ai_shot_stats.GetBool() ) + { + CAI_BaseNPC *pNpc = MyNPCPointer(); + if ( pNpc ) + { + pNpc->m_TotalShots++; + if ( tr.m_pEnt == pNpc->GetEnemy() ) + { + pNpc->m_TotalHits++; + } + } + } +} + + +//----------------------------------------------------------------------------- +// Handle shot entering water +//----------------------------------------------------------------------------- +void CBaseEntity::HandleShotImpactingGlass( const FireBulletsInfo_t &info, + const trace_t &tr, const Vector &vecDir, ITraceFilter *pTraceFilter ) +{ + // Move through the glass until we're at the other side + Vector testPos = tr.endpos + ( vecDir * MAX_GLASS_PENETRATION_DEPTH ); + + CEffectData data; + + data.m_vNormal = tr.plane.normal; + data.m_vOrigin = tr.endpos; + + DispatchEffect( "GlassImpact", data ); + + trace_t penetrationTrace; + + // Re-trace as if the bullet had passed right through + UTIL_TraceLine( testPos, tr.endpos, MASK_SHOT, pTraceFilter, &penetrationTrace ); + + // See if we found the surface again + if ( penetrationTrace.startsolid || tr.fraction == 0.0f || penetrationTrace.fraction == 1.0f ) + return; + + //FIXME: This is technically frustrating MultiDamage, but multiple shots hitting multiple targets in one call + // would do exactly the same anyway... + + // Impact the other side (will look like an exit effect) + DoImpactEffect( penetrationTrace, GetAmmoDef()->DamageType(info.m_iAmmoType) ); + + data.m_vNormal = penetrationTrace.plane.normal; + data.m_vOrigin = penetrationTrace.endpos; + + DispatchEffect( "GlassImpact", data ); + + // Refire the round, as if starting from behind the glass + FireBulletsInfo_t behindGlassInfo; + behindGlassInfo.m_iShots = 1; + behindGlassInfo.m_vecSrc = penetrationTrace.endpos; + behindGlassInfo.m_vecDirShooting = vecDir; + behindGlassInfo.m_vecSpread = vec3_origin; + behindGlassInfo.m_flDistance = info.m_flDistance*( 1.0f - tr.fraction ); + behindGlassInfo.m_iAmmoType = info.m_iAmmoType; + behindGlassInfo.m_iTracerFreq = info.m_iTracerFreq; + behindGlassInfo.m_flDamage = info.m_flDamage; + behindGlassInfo.m_pAttacker = info.m_pAttacker ? info.m_pAttacker : this; + behindGlassInfo.m_nFlags = info.m_nFlags; + + FireBullets( behindGlassInfo ); +} + + +//----------------------------------------------------------------------------- +// Computes the tracer start position +//----------------------------------------------------------------------------- +#define SHOT_UNDERWATER_BUBBLE_DIST 400 + +void CBaseEntity::CreateBubbleTrailTracer( const Vector &vecShotSrc, const Vector &vecShotEnd, const Vector &vecShotDir ) +{ + int nBubbles; + Vector vecBubbleEnd; + float flLengthSqr = vecShotSrc.DistToSqr( vecShotEnd ); + if ( flLengthSqr > SHOT_UNDERWATER_BUBBLE_DIST * SHOT_UNDERWATER_BUBBLE_DIST ) + { + VectorMA( vecShotSrc, SHOT_UNDERWATER_BUBBLE_DIST, vecShotDir, vecBubbleEnd ); + nBubbles = WATER_BULLET_BUBBLES_PER_INCH * SHOT_UNDERWATER_BUBBLE_DIST; + } + else + { + float flLength = sqrt(flLengthSqr) - 0.1f; + nBubbles = WATER_BULLET_BUBBLES_PER_INCH * flLength; + VectorMA( vecShotSrc, flLength, vecShotDir, vecBubbleEnd ); + } + + Vector vecTracerSrc; + ComputeTracerStartPosition( vecShotSrc, &vecTracerSrc ); + UTIL_BubbleTrail( vecTracerSrc, vecBubbleEnd, nBubbles ); +} + + +//========================================================= +//========================================================= +void CAI_BaseNPC::MakeDamageBloodDecal ( int cCount, float flNoise, trace_t *ptr, Vector vecDir ) +{ + // make blood decal on the wall! + trace_t Bloodtr; + Vector vecTraceDir; + int i; + + if ( !IsAlive() ) + { + // dealing with a dead npc. + if ( m_iMaxHealth <= 0 ) + { + // no blood decal for a npc that has already decalled its limit. + return; + } + else + { + m_iMaxHealth -= 1; + } + } + + for ( i = 0 ; i < cCount ; i++ ) + { + vecTraceDir = vecDir; + + vecTraceDir.x += random->RandomFloat( -flNoise, flNoise ); + vecTraceDir.y += random->RandomFloat( -flNoise, flNoise ); + vecTraceDir.z += random->RandomFloat( -flNoise, flNoise ); + + AI_TraceLine( ptr->endpos, ptr->endpos + vecTraceDir * 172, MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &Bloodtr); + + if ( Bloodtr.fraction != 1.0 ) + { + UTIL_BloodDecalTrace( &Bloodtr, BloodColor() ); + } + } +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Input : &tr - +// nDamageType - +//----------------------------------------------------------------------------- +void CAI_BaseNPC::DoImpactEffect( trace_t &tr, int nDamageType ) +{ + if ( GetActiveWeapon() != NULL ) + { + GetActiveWeapon()->DoImpactEffect( tr, nDamageType ); + return; + } + + BaseClass::DoImpactEffect( tr, nDamageType ); +} + +//--------------------------------------------------------- +//--------------------------------------------------------- +#define InterruptFromCondition( iCondition ) \ + AI_RemapFromGlobal( ( AI_IdIsLocal( iCondition ) ? GetClassScheduleIdSpace()->ConditionLocalToGlobal( iCondition ) : iCondition ) ) + +void CAI_BaseNPC::SetCondition( int iCondition ) +{ + int interrupt = InterruptFromCondition( iCondition ); + + if ( interrupt == -1 ) + { + Assert(0); + return; + } + + m_Conditions.Set( interrupt ); +} + +//--------------------------------------------------------- +//--------------------------------------------------------- +bool CAI_BaseNPC::HasCondition( int iCondition ) +{ + int interrupt = InterruptFromCondition( iCondition ); + + if ( interrupt == -1 ) + { + Assert(0); + return false; + } + + bool bReturn = m_Conditions.IsBitSet(interrupt); + return (bReturn); +} + +//--------------------------------------------------------- +//--------------------------------------------------------- +bool CAI_BaseNPC::HasCondition( int iCondition, bool bUseIgnoreConditions ) +{ + if ( bUseIgnoreConditions ) + return HasCondition( iCondition ); + + int interrupt = InterruptFromCondition( iCondition ); + + if ( interrupt == -1 ) + { + Assert(0); + return false; + } + + bool bReturn = m_ConditionsPreIgnore.IsBitSet(interrupt); + return (bReturn); +} + +//--------------------------------------------------------- +//--------------------------------------------------------- +void CAI_BaseNPC::ClearCondition( int iCondition ) +{ + int interrupt = InterruptFromCondition( iCondition ); + + if ( interrupt == -1 ) + { + Assert(0); + return; + } + + m_Conditions.Clear(interrupt); +} + +//--------------------------------------------------------- +//--------------------------------------------------------- +void CAI_BaseNPC::ClearConditions( int *pConditions, int nConditions ) +{ + for ( int i = 0; i < nConditions; ++i ) + { + int iCondition = pConditions[i]; + int interrupt = InterruptFromCondition( iCondition ); + + if ( interrupt == -1 ) + { + Assert(0); + continue; + } + + m_Conditions.Clear( interrupt ); + } +} + +//--------------------------------------------------------- +//--------------------------------------------------------- +void CAI_BaseNPC::SetIgnoreConditions( int *pConditions, int nConditions ) +{ + for ( int i = 0; i < nConditions; ++i ) + { + int iCondition = pConditions[i]; + int interrupt = InterruptFromCondition( iCondition ); + + if ( interrupt == -1 ) + { + Assert(0); + continue; + } + + m_InverseIgnoreConditions.Clear( interrupt ); // clear means ignore + } +} + +void CAI_BaseNPC::ClearIgnoreConditions( int *pConditions, int nConditions ) +{ + for ( int i = 0; i < nConditions; ++i ) + { + int iCondition = pConditions[i]; + int interrupt = InterruptFromCondition( iCondition ); + + if ( interrupt == -1 ) + { + Assert(0); + continue; + } + + m_InverseIgnoreConditions.Set( interrupt ); // set means don't ignore + } +} + +//--------------------------------------------------------- +//--------------------------------------------------------- +bool CAI_BaseNPC::HasInterruptCondition( int iCondition ) +{ + if( !GetCurSchedule() ) + { + return false; + } + + int interrupt = InterruptFromCondition( iCondition ); + + if ( interrupt == -1 ) + { + Assert(0); + return false; + } + return ( m_Conditions.IsBitSet( interrupt ) && GetCurSchedule()->HasInterrupt( interrupt ) ); +} + +//--------------------------------------------------------- +//--------------------------------------------------------- +bool CAI_BaseNPC::ConditionInterruptsCurSchedule( int iCondition ) +{ + if( !GetCurSchedule() ) + { + return false; + } + + int interrupt = InterruptFromCondition( iCondition ); + + if ( interrupt == -1 ) + { + Assert(0); + return false; + } + return ( GetCurSchedule()->HasInterrupt( interrupt ) ); +} + +//--------------------------------------------------------- +//--------------------------------------------------------- +bool CAI_BaseNPC::ConditionInterruptsSchedule( int localScheduleID, int iCondition ) +{ + CAI_Schedule *pSchedule = GetSchedule( localScheduleID ); + if ( !pSchedule ) + return false; + + int interrupt = InterruptFromCondition( iCondition ); + + if ( interrupt == -1 ) + { + Assert(0); + return false; + } + return ( pSchedule->HasInterrupt( interrupt ) ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Sets the interrupt conditions for a scripted schedule +// Input : interrupt - the level of interrupt we allow +//----------------------------------------------------------------------------- +void CAI_BaseNPC::SetScriptedScheduleIgnoreConditions( Interruptability_t interrupt ) +{ + static int g_GeneralConditions[] = + { + COND_CAN_MELEE_ATTACK1, + COND_CAN_MELEE_ATTACK2, + COND_CAN_RANGE_ATTACK1, + COND_CAN_RANGE_ATTACK2, + COND_ENEMY_DEAD, + COND_HEAR_BULLET_IMPACT, + COND_HEAR_COMBAT, + COND_HEAR_DANGER, + COND_HEAR_PHYSICS_DANGER, + COND_NEW_ENEMY, + COND_PROVOKED, + COND_SEE_ENEMY, + COND_SEE_FEAR, + COND_SMELL, + }; + + static int g_DamageConditions[] = + { + COND_HEAVY_DAMAGE, + COND_LIGHT_DAMAGE, + COND_RECEIVED_ORDERS, + }; + + ClearIgnoreConditions( g_GeneralConditions, ARRAYSIZE(g_GeneralConditions) ); + ClearIgnoreConditions( g_DamageConditions, ARRAYSIZE(g_DamageConditions) ); + + if ( interrupt > GENERAL_INTERRUPTABILITY ) + SetIgnoreConditions( g_GeneralConditions, ARRAYSIZE(g_GeneralConditions) ); + + if ( interrupt > DAMAGEORDEATH_INTERRUPTABILITY ) + SetIgnoreConditions( g_DamageConditions, ARRAYSIZE(g_DamageConditions) ); +} + +//----------------------------------------------------------------------------- +// Returns whether we currently have any interrupt conditions that would +// interrupt the given schedule. +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::HasConditionsToInterruptSchedule( int nLocalScheduleID ) +{ + CAI_Schedule *pSchedule = GetSchedule( nLocalScheduleID ); + if ( !pSchedule ) + return false; + + CAI_ScheduleBits bitsMask; + pSchedule->GetInterruptMask( &bitsMask ); + + CAI_ScheduleBits bitsOut; + AccessConditionBits().And( bitsMask, &bitsOut ); + + return !bitsOut.IsAllClear(); +} + + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::IsCustomInterruptConditionSet( int nCondition ) +{ + int interrupt = InterruptFromCondition( nCondition ); + + if ( interrupt == -1 ) + { + Assert(0); + return false; + } + + return m_CustomInterruptConditions.IsBitSet( interrupt ); +} + +//----------------------------------------------------------------------------- +// Purpose: Sets a flag in the custom interrupt flags, translating the condition +// to the proper global space, if necessary +//----------------------------------------------------------------------------- +void CAI_BaseNPC::SetCustomInterruptCondition( int nCondition ) +{ + int interrupt = InterruptFromCondition( nCondition ); + + if ( interrupt == -1 ) + { + Assert(0); + return; + } + + m_CustomInterruptConditions.Set( interrupt ); +} + +//----------------------------------------------------------------------------- +// Purpose: Clears a flag in the custom interrupt flags, translating the condition +// to the proper global space, if necessary +//----------------------------------------------------------------------------- +void CAI_BaseNPC::ClearCustomInterruptCondition( int nCondition ) +{ + int interrupt = InterruptFromCondition( nCondition ); + + if ( interrupt == -1 ) + { + Assert(0); + return; + } + + m_CustomInterruptConditions.Clear( interrupt ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Clears all the custom interrupt flags. +//----------------------------------------------------------------------------- +void CAI_BaseNPC::ClearCustomInterruptConditions() +{ + m_CustomInterruptConditions.ClearAll(); +} + + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::SetDistLook( float flDistLook ) +{ + m_pSenses->SetDistLook( flDistLook ); +} + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::QueryHearSound( CSound *pSound ) +{ + if ( pSound->SoundContext() & SOUND_CONTEXT_COMBINE_ONLY ) + return false; + + if ( pSound->SoundContext() & SOUND_CONTEXT_ALLIES_ONLY ) + { + if ( !IsPlayerAlly() ) + return false; + } + + if ( pSound->IsSoundType( SOUND_PLAYER ) && GetState() == NPC_STATE_IDLE && !FVisible( pSound->GetSoundReactOrigin() ) ) + { + // NPC's that are IDLE should disregard player movement sounds if they can't see them. + // This does not affect them hearing the player's weapon. + // !!!BUGBUG - this probably makes NPC's not hear doors opening, because doors opening put SOUND_PLAYER + // in the world, but the door's model will block the FVisible() trace and this code will then + // deduce that the sound can not be heard + return false; + } + + // Disregard footsteps from our own class type + if ( pSound->IsSoundType( SOUND_COMBAT ) && pSound->SoundChannel() == SOUNDENT_CHANNEL_NPC_FOOTSTEP ) + { + if ( pSound->m_hOwner && pSound->m_hOwner->ClassMatches( m_iClassname ) ) + return false; + } + + if( ShouldIgnoreSound( pSound ) ) + return false; + + return true; +} + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::QuerySeeEntity( CBaseEntity *pEntity, bool bOnlyHateOrFearIfNPC ) +{ + if ( bOnlyHateOrFearIfNPC && pEntity->IsNPC() ) + { + Disposition_t disposition = IRelationType( pEntity ); + return ( disposition == D_HT || disposition == D_FR ); + } + return true; +} + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::OnLooked( int iDistance ) +{ + // DON'T let visibility information from last frame sit around! + static int conditionsToClear[] = + { + COND_SEE_HATE, + COND_SEE_DISLIKE, + COND_SEE_ENEMY, + COND_SEE_FEAR, + COND_SEE_NEMESIS, + COND_SEE_PLAYER, + COND_LOST_PLAYER, + COND_ENEMY_WENT_NULL, + }; + + bool bHadSeePlayer = HasCondition(COND_SEE_PLAYER); + + ClearConditions( conditionsToClear, ARRAYSIZE( conditionsToClear ) ); + + AISightIter_t iter; + CBaseEntity *pSightEnt; + + pSightEnt = GetSenses()->GetFirstSeenEntity( &iter ); + + while( pSightEnt ) + { + if ( pSightEnt->IsPlayer() ) + { + // if we see a client, remember that (mostly for scripted AI) + SetCondition(COND_SEE_PLAYER); + m_flLastSawPlayerTime = gpGlobals->curtime; + } + + Disposition_t relation = IRelationType( pSightEnt ); + + // the looker will want to consider this entity + // don't check anything else about an entity that can't be seen, or an entity that you don't care about. + if ( relation != D_NU ) + { + if ( pSightEnt == GetEnemy() ) + { + // we know this ent is visible, so if it also happens to be our enemy, store that now. + SetCondition(COND_SEE_ENEMY); + } + + // don't add the Enemy's relationship to the conditions. We only want to worry about conditions when + // we see npcs other than the Enemy. + switch ( relation ) + { + case D_HT: + { + int priority = IRelationPriority( pSightEnt ); + if (priority < 0) + { + SetCondition(COND_SEE_DISLIKE); + } + else if (priority > 10) + { + SetCondition(COND_SEE_NEMESIS); + } + else + { + SetCondition(COND_SEE_HATE); + } + UpdateEnemyMemory(pSightEnt,pSightEnt->GetAbsOrigin()); + break; + + } + case D_FR: + UpdateEnemyMemory(pSightEnt,pSightEnt->GetAbsOrigin()); + SetCondition(COND_SEE_FEAR); + break; + case D_LI: + case D_NU: + break; + default: + DevWarning( 2, "%s can't assess %s\n", GetClassname(), pSightEnt->GetClassname() ); + break; + } + } + + pSightEnt = GetSenses()->GetNextSeenEntity( &iter ); + } + + // Did we lose the player? + if ( bHadSeePlayer && !HasCondition(COND_SEE_PLAYER) ) + { + SetCondition(COND_LOST_PLAYER); + } +} + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::OnListened() +{ + AISoundIter_t iter; + + CSound *pCurrentSound; + + static int conditionsToClear[] = + { + COND_HEAR_DANGER, + COND_HEAR_COMBAT, + COND_HEAR_WORLD, + COND_HEAR_PLAYER, + COND_HEAR_THUMPER, + COND_HEAR_BUGBAIT, + COND_HEAR_PHYSICS_DANGER, + COND_HEAR_BULLET_IMPACT, + COND_HEAR_MOVE_AWAY, + + COND_NO_HEAR_DANGER, + + COND_SMELL, + }; + + ClearConditions( conditionsToClear, ARRAYSIZE( conditionsToClear ) ); + + pCurrentSound = GetSenses()->GetFirstHeardSound( &iter ); + + while ( pCurrentSound ) + { + // the npc cares about this sound, and it's close enough to hear. + int condition = COND_NONE; + + if ( pCurrentSound->FIsSound() ) + { + // this is an audible sound. + switch( pCurrentSound->SoundTypeNoContext() ) + { + case SOUND_DANGER: + if( gpGlobals->curtime > m_flIgnoreDangerSoundsUntil) + condition = COND_HEAR_DANGER; + break; + + case SOUND_THUMPER: condition = COND_HEAR_THUMPER; break; + case SOUND_BUGBAIT: condition = COND_HEAR_BUGBAIT; break; + case SOUND_COMBAT: + if ( pCurrentSound->SoundChannel() == SOUNDENT_CHANNEL_SPOOKY_NOISE ) + { + condition = COND_HEAR_SPOOKY; + } + else + { + condition = COND_HEAR_COMBAT; + } + break; + + case SOUND_WORLD: condition = COND_HEAR_WORLD; break; + case SOUND_PLAYER: condition = COND_HEAR_PLAYER; break; + case SOUND_BULLET_IMPACT: condition = COND_HEAR_BULLET_IMPACT; break; + case SOUND_PHYSICS_DANGER: condition = COND_HEAR_PHYSICS_DANGER; break; + case SOUND_DANGER_SNIPERONLY:/* silence warning */ break; + case SOUND_MOVE_AWAY: condition = COND_HEAR_MOVE_AWAY; break; + case SOUND_PLAYER_VEHICLE: condition = COND_HEAR_PLAYER; break; + + default: + DevMsg( "**ERROR: NPC %s hearing sound of unknown type %d!\n", GetClassname(), pCurrentSound->SoundType() ); + break; + } + } + else + { + // if not a sound, must be a smell - determine if it's just a scent, or if it's a food scent + condition = COND_SMELL; + } + + if ( condition != COND_NONE ) + { + SetCondition( condition ); + } + + pCurrentSound = GetSenses()->GetNextHeardSound( &iter ); + } + + if( !HasCondition( COND_HEAR_DANGER ) ) + { + SetCondition( COND_NO_HEAR_DANGER ); + } + + // Sound outputs + if ( HasCondition( COND_HEAR_WORLD ) ) + { + m_OnHearWorld.FireOutput(this, this); + } + + if ( HasCondition( COND_HEAR_PLAYER ) ) + { + m_OnHearPlayer.FireOutput(this, this); + } + + if ( HasCondition( COND_HEAR_COMBAT ) || + HasCondition( COND_HEAR_BULLET_IMPACT ) || + HasCondition( COND_HEAR_DANGER ) ) + { + m_OnHearCombat.FireOutput(this, this); + } +} + +//========================================================= +// FValidateHintType - tells use whether or not the npc cares +// about the type of Hint Node given +//========================================================= +bool CAI_BaseNPC::FValidateHintType ( CAI_Hint *pHint ) +{ + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: Override in subclasses to associate specific hint types +// with activities +//----------------------------------------------------------------------------- +Activity CAI_BaseNPC::GetHintActivity( short sHintType, Activity HintsActivity ) +{ + if ( HintsActivity != ACT_INVALID ) + return HintsActivity; + + return ACT_IDLE; +} + +//----------------------------------------------------------------------------- +// Purpose: Override in subclasses to give specific hint types delays +// before they can be used again +// Input : +// Output : +//----------------------------------------------------------------------------- +float CAI_BaseNPC::GetHintDelay( short sHintType ) +{ + return 0; +} + +//----------------------------------------------------------------------------- +// Purpose: Return incoming grenade if spotted +// Input : +// Output : +//----------------------------------------------------------------------------- +CBaseGrenade* CAI_BaseNPC::IncomingGrenade(void) +{ + int iDist; + + AIEnemiesIter_t iter; + for( AI_EnemyInfo_t *pEMemory = GetEnemies()->GetFirst(&iter); pEMemory != NULL; pEMemory = GetEnemies()->GetNext(&iter) ) + { + CBaseGrenade* pBG = dynamic_cast((CBaseEntity*)pEMemory->hEnemy); + + // Make sure this memory is for a grenade and grenade is not dead + if (!pBG || pBG->m_lifeState == LIFE_DEAD) + continue; + + // Make sure it's visible + if (!FVisible(pBG)) + continue; + + // Check if it's near me + iDist = ( pBG->GetAbsOrigin() - GetAbsOrigin() ).Length(); + if ( iDist <= NPC_GRENADE_FEAR_DIST ) + return pBG; + + // Check if it's headed towards me + Vector vGrenadeDir = GetAbsOrigin() - pBG->GetAbsOrigin(); + Vector vGrenadeVel; + pBG->GetVelocity( &vGrenadeVel, NULL ); + VectorNormalize(vGrenadeDir); + VectorNormalize(vGrenadeVel); + float flDotPr = DotProduct(vGrenadeDir, vGrenadeVel); + if (flDotPr > 0.85) + return pBG; + } + return NULL; +} + + +//----------------------------------------------------------------------------- +// Purpose: Check my physical state with the environment +// Input : +// Output : +//----------------------------------------------------------------------------- +void CAI_BaseNPC::TryRestoreHull(void) +{ + if ( IsUsingSmallHull() && GetCurSchedule() ) + { + trace_t tr; + Vector vUpBit = GetAbsOrigin(); + vUpBit.z += 1; + + AI_TraceHull( GetAbsOrigin(), vUpBit, GetHullMins(), + GetHullMaxs(), MASK_SOLID, this, COLLISION_GROUP_NONE, &tr ); + if ( !tr.startsolid && (tr.fraction == 1.0) ) + { + SetHullSizeNormal(); + } + } +} + +//========================================================= +//========================================================= +int CAI_BaseNPC::GetSoundInterests( void ) +{ + return SOUND_WORLD | SOUND_COMBAT | SOUND_PLAYER | SOUND_PLAYER_VEHICLE | + SOUND_BULLET_IMPACT; +} + +//--------------------------------------------------------- +//--------------------------------------------------------- +int CAI_BaseNPC::GetSoundPriority( CSound *pSound ) +{ + int iSoundTypeNoContext = pSound->SoundTypeNoContext(); + int iSoundContext = pSound->SoundContext(); + + if( iSoundTypeNoContext & SOUND_DANGER ) + { + return SOUND_PRIORITY_HIGHEST; + } + + if( iSoundTypeNoContext & SOUND_COMBAT ) + { + if( iSoundContext & SOUND_CONTEXT_EXPLOSION ) + { + return SOUND_PRIORITY_VERY_HIGH; + } + + return SOUND_PRIORITY_HIGH; + } + + return SOUND_PRIORITY_NORMAL; +} + +//--------------------------------------------------------- +// Return the loudest sound of this type in the sound list +//--------------------------------------------------------- +CSound *CAI_BaseNPC::GetLoudestSoundOfType( int iType ) +{ + return CSoundEnt::GetLoudestSoundOfType( iType, EarPosition() ); +} + +//========================================================= +// GetBestSound - returns a pointer to the sound the npc +// should react to. Right now responds only to nearest sound. +//========================================================= +CSound* CAI_BaseNPC::GetBestSound( int validTypes ) +{ + if ( m_pLockedBestSound->m_iType != SOUND_NONE ) + return m_pLockedBestSound; + CSound *pResult = GetSenses()->GetClosestSound( false, validTypes ); + if ( pResult == NULL) + DevMsg( "Warning: NULL Return from GetBestSound\n" ); // condition previously set now no longer true. Have seen this when play too many sounds... + return pResult; +} + +//========================================================= +// PBestScent - returns a pointer to the scent the npc +// should react to. Right now responds only to nearest scent +//========================================================= +CSound* CAI_BaseNPC::GetBestScent( void ) +{ + CSound *pResult = GetSenses()->GetClosestSound( true ); + if ( pResult == NULL) + DevMsg("Warning: NULL Return from GetBestScent\n" ); + return pResult; +} + +//----------------------------------------------------------------------------- +void CAI_BaseNPC::LockBestSound() +{ + UnlockBestSound(); + CSound *pBestSound = GetBestSound(); + if ( pBestSound ) + *m_pLockedBestSound = *pBestSound; +} + +//----------------------------------------------------------------------------- +void CAI_BaseNPC::UnlockBestSound() +{ + if ( m_pLockedBestSound->m_iType != SOUND_NONE ) + { + m_pLockedBestSound->m_iType = SOUND_NONE; + OnListened(); // reset hearing conditions + } +} + +//----------------------------------------------------------------------------- +// Purpose: Return true if the specified sound is visible. Handles sounds generated by entities correctly. +// Input : *pSound - +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::SoundIsVisible( CSound *pSound ) +{ + CBaseEntity *pBlocker = NULL; + if ( !FVisible( pSound->GetSoundReactOrigin(), MASK_BLOCKLOS, &pBlocker ) ) + { + // Is the blocker the sound owner? + if ( pBlocker && pBlocker == pSound->m_hOwner ) + return true; + + return false; + } + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: Returns true if target is in legal range of eye movements +// Input : +// Output : +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::ValidEyeTarget(const Vector &lookTargetPos) +{ + Vector vHeadDir = HeadDirection3D( ); + Vector lookTargetDir = lookTargetPos - EyePosition(); + VectorNormalize(lookTargetDir); + + // Only look if it doesn't crank my eyeballs too far + float dotPr = DotProduct(lookTargetDir, vHeadDir); + if (dotPr > 0.7) + { + return true; + } + return false; +} + + +//----------------------------------------------------------------------------- +// Purpose: Integrate head turn over time +// Input : +// Output : +//----------------------------------------------------------------------------- +void CAI_BaseNPC::SetHeadDirection( const Vector &vTargetPos, float flInterval) +{ + if (!(CapabilitiesGet() & bits_CAP_TURN_HEAD)) + return; + +#ifdef DEBUG_LOOK + // Draw line in body, head, and eye directions + Vector vEyePos = EyePosition(); + Vector vHeadDir; + HeadDirection3D(&vHeadDir); + Vector vBodyDir; + BodyDirection2D(&vBodyDir); + + //UNDONE <> + // currently eye dir just returns head dir, so use vTargetPos for now + //Vector vEyeDir; w + //EyeDirection3D(&vEyeDir); + NDebugOverlay::Line( vEyePos, vEyePos+(50*vHeadDir), 255, 0, 0, false, 0.1 ); + NDebugOverlay::Line( vEyePos, vEyePos+(50*vBodyDir), 0, 255, 0, false, 0.1 ); + NDebugOverlay::Line( vEyePos, vTargetPos, 0, 0, 255, false, 0.1 ); +#endif + + //-------------------------------------- + // Set head yaw + //-------------------------------------- + float flDesiredYaw = VecToYaw(vTargetPos - GetLocalOrigin()) - GetLocalAngles().y; + if (flDesiredYaw > 180) + flDesiredYaw -= 360; + if (flDesiredYaw < -180) + flDesiredYaw += 360; + + float iRate = 0.8; + + // Make frame rate independent + float timeToUse = flInterval; + while (timeToUse > 0) + { + m_flHeadYaw = (iRate * m_flHeadYaw) + (1-iRate)*flDesiredYaw; + timeToUse -= 0.1; + } + if (m_flHeadYaw > 360) m_flHeadYaw = 0; + + m_flHeadYaw = SetBoneController( 0, m_flHeadYaw ); + + + //-------------------------------------- + // Set head pitch + //-------------------------------------- + Vector vEyePosition = EyePosition(); + float fTargetDist = (vTargetPos - vEyePosition).Length(); + float fVertDist = vTargetPos.z - vEyePosition.z; + float flDesiredPitch = -RAD2DEG(atan(fVertDist/fTargetDist)); + + // Make frame rate independent + timeToUse = flInterval; + while (timeToUse > 0) + { + m_flHeadPitch = (iRate * m_flHeadPitch) + (1-iRate)*flDesiredPitch; + timeToUse -= 0.1; + } + if (m_flHeadPitch > 360) m_flHeadPitch = 0; + + SetBoneController( 1, m_flHeadPitch ); + +} + +//------------------------------------------------------------------------------ +// Purpose : Calculate the NPC's eye direction in 2D world space +// Input : +// Output : +//------------------------------------------------------------------------------ +Vector CAI_BaseNPC::EyeDirection2D( void ) +{ + // UNDONE + // For now just return head direction.... + return HeadDirection2D( ); +} + +//------------------------------------------------------------------------------ +// Purpose : Calculate the NPC's eye direction in 2D world space +// Input : +// Output : +//------------------------------------------------------------------------------ +Vector CAI_BaseNPC::EyeDirection3D( void ) +{ + // UNDONE //<> + // For now just return head direction.... + return HeadDirection3D( ); +} + +//------------------------------------------------------------------------------ +// Purpose : Calculate the NPC's head direction in 2D world space +// Input : +// Output : +//------------------------------------------------------------------------------ +Vector CAI_BaseNPC::HeadDirection2D( void ) +{ + // UNDONE <> + // This does not account for head rotations in the animation, + // only those done via bone controllers + + // Head yaw is in local cooridnate so it must be added to the body's yaw + QAngle bodyAngles = BodyAngles(); + float flWorldHeadYaw = m_flHeadYaw + bodyAngles.y; + + // Convert head yaw into facing direction + return UTIL_YawToVector( flWorldHeadYaw ); +} + +//------------------------------------------------------------------------------ +// Purpose : Calculate the NPC's head direction in 3D world space +// Input : +// Output : +//------------------------------------------------------------------------------ +Vector CAI_BaseNPC::HeadDirection3D( void ) +{ + Vector vHeadDirection; + + // UNDONE <> + // This does not account for head rotations in the animation, + // only those done via bone controllers + + // Head yaw is in local cooridnate so it must be added to the body's yaw + QAngle bodyAngles = BodyAngles(); + float flWorldHeadYaw = m_flHeadYaw + bodyAngles.y; + + // Convert head yaw into facing direction + AngleVectors( QAngle( m_flHeadPitch, flWorldHeadYaw, 0), &vHeadDirection ); + return vHeadDirection; +} + + +//----------------------------------------------------------------------------- +// Purpose: Look at other NPCs and clients from time to time +// Input : +// Output : +//----------------------------------------------------------------------------- +CBaseEntity *CAI_BaseNPC::EyeLookTarget( void ) +{ + if (m_flNextEyeLookTime < gpGlobals->curtime) + { + CBaseEntity* pBestEntity = NULL; + float fBestDist = MAX_COORD_RANGE; + float fTestDist; + + CBaseEntity *pEntity = NULL; + + for ( CEntitySphereQuery sphere( GetAbsOrigin(), 1024, 0 ); (pEntity = sphere.GetCurrentEntity()) != NULL; sphere.NextEntity() ) + { + if (pEntity == this) + { + continue; + } + CAI_BaseNPC *pNPC = pEntity->MyNPCPointer(); + if (pNPC || (pEntity->GetFlags() & FL_CLIENT)) + { + fTestDist = (GetAbsOrigin() - pEntity->EyePosition()).Length(); + if (fTestDist < fBestDist) + { + if (ValidEyeTarget(pEntity->EyePosition())) + { + fBestDist = fTestDist; + pBestEntity = pEntity; + } + } + } + } + if (pBestEntity) + { + m_flNextEyeLookTime = gpGlobals->curtime + random->RandomInt(1,5); + m_hEyeLookTarget = pBestEntity; + } + } + return m_hEyeLookTarget; +} + + +//----------------------------------------------------------------------------- +// Purpose: Set direction that the NPC aiming their gun +// returns true is the passed Vector is in +// the caller's forward aim cone. The dot product is performed +// in 2d, making the view cone infinitely tall. By default, the +// callers aim cone is assumed to be very narrow +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::FInAimCone( const Vector &vecSpot ) +{ + Vector los = ( vecSpot - GetAbsOrigin() ); + + // do this in 2D + los.z = 0; + VectorNormalize( los ); + + Vector facingDir = BodyDirection2D( ); + + float flDot = DotProduct( los, facingDir ); + + if (CapabilitiesGet() & bits_CAP_AIM_GUN) + { + // FIXME: query current animation for ranges + return ( flDot > DOT_30DEGREE ); + } + + if ( flDot > 0.994 )//!!!BUGBUG - magic number same as FacingIdeal(), what is this? + return true; + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: Cache whatever pose parameters we intend to use +//----------------------------------------------------------------------------- +void CAI_BaseNPC::PopulatePoseParameters( void ) +{ + m_poseAim_Pitch = LookupPoseParameter( "aim_pitch" ); + m_poseAim_Yaw = LookupPoseParameter( "aim_yaw" ); + m_poseMove_Yaw = LookupPoseParameter( "move_yaw" ); + + BaseClass::PopulatePoseParameters(); +} + +//----------------------------------------------------------------------------- +// Purpose: Set direction that the NPC aiming their gun +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::SetAim( const Vector &aimDir ) +{ + QAngle angDir; + VectorAngles( aimDir, angDir ); + float curPitch = GetPoseParameter( m_poseAim_Pitch ); + float curYaw = GetPoseParameter( m_poseAim_Yaw ); + + float newPitch; + float newYaw; + + if( GetEnemy() ) + { + // clamp and dampen movement + newPitch = curPitch + 0.8 * UTIL_AngleDiff( UTIL_ApproachAngle( angDir.x, curPitch, 20 ), curPitch ); + + float flRelativeYaw = UTIL_AngleDiff( angDir.y, GetAbsAngles().y ); + // float flNewTargetYaw = UTIL_ApproachAngle( flRelativeYaw, curYaw, 20 ); + // float newYaw = curYaw + 0.8 * UTIL_AngleDiff( flNewTargetYaw, curYaw ); + newYaw = curYaw + UTIL_AngleDiff( flRelativeYaw, curYaw ); + } + else + { + // Sweep your weapon more slowly if you're not fighting someone + newPitch = curPitch + 0.6 * UTIL_AngleDiff( UTIL_ApproachAngle( angDir.x, curPitch, 20 ), curPitch ); + + float flRelativeYaw = UTIL_AngleDiff( angDir.y, GetAbsAngles().y ); + newYaw = curYaw + 0.6 * UTIL_AngleDiff( flRelativeYaw, curYaw ); + } + + newPitch = AngleNormalize( newPitch ); + newYaw = AngleNormalize( newYaw ); + + SetPoseParameter( m_poseAim_Pitch, newPitch ); + SetPoseParameter( m_poseAim_Yaw, newYaw ); + + // Msg("yaw %.0f (%.0f %.0f)\n", newYaw, angDir.y, GetAbsAngles().y ); + + // Calculate our interaction yaw. + // If we've got a small adjustment off our abs yaw, use that. + // Otherwise, use our abs yaw. + if ( fabs(newYaw) < 20 ) + { + m_flInteractionYaw = angDir.y; + } + else + { + m_flInteractionYaw = GetAbsAngles().y; + } +} + + +void CAI_BaseNPC::RelaxAim( ) +{ + float curPitch = GetPoseParameter( m_poseAim_Pitch ); + float curYaw = GetPoseParameter( m_poseAim_Yaw ); + + // dampen existing aim + float newPitch = AngleNormalize( UTIL_ApproachAngle( 0, curPitch, 3 ) ); + float newYaw = AngleNormalize( UTIL_ApproachAngle( 0, curYaw, 2 ) ); + + SetPoseParameter( m_poseAim_Pitch, newPitch ); + SetPoseParameter( m_poseAim_Yaw, newYaw ); + // DevMsg("relax aim %.0f %0.f\n", newPitch, newYaw ); +} + +//----------------------------------------------------------------------------- +void CAI_BaseNPC::AimGun() +{ + if (GetEnemy()) + { + Vector vecShootOrigin; + + vecShootOrigin = Weapon_ShootPosition(); + Vector vecShootDir = GetShootEnemyDir( vecShootOrigin, false ); + + SetAim( vecShootDir ); + } + else + { + RelaxAim( ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Set direction that the NPC is looking +// Input : +// Output : +//----------------------------------------------------------------------------- +void CAI_BaseNPC::MaintainLookTargets ( float flInterval ) +{ + // -------------------------------------------------------- + // Try to look at enemy if I have one + // -------------------------------------------------------- + if ((CBaseEntity*)GetEnemy()) + { + if ( ValidEyeTarget(GetEnemy()->EyePosition()) ) + { + SetHeadDirection(GetEnemy()->EyePosition(),flInterval); + SetViewtarget( GetEnemy()->EyePosition() ); + return; + } + } + +#if 0 + // -------------------------------------------------------- + // First check if I've been assigned to look at an entity + // -------------------------------------------------------- + CBaseEntity *lookTarget = EyeLookTarget(); + if (lookTarget && ValidEyeTarget(lookTarget->EyePosition())) + { + SetHeadDirection(lookTarget->EyePosition(),flInterval); + SetViewtarget( lookTarget->EyePosition() ); + return; + } +#endif + + // -------------------------------------------------------- + // If I'm moving, look at my target position + // -------------------------------------------------------- + if (GetNavigator()->IsGoalActive() && ValidEyeTarget(GetNavigator()->GetCurWaypointPos())) + { + SetHeadDirection(GetNavigator()->GetCurWaypointPos(),flInterval); + SetViewtarget( GetNavigator()->GetCurWaypointPos() ); + return; + } + + + // ------------------------------------- + // If I hear a combat sounds look there + // ------------------------------------- + if ( HasCondition(COND_HEAR_COMBAT) || HasCondition(COND_HEAR_DANGER) ) + { + CSound *pSound = GetBestSound(); + + if ( pSound && pSound->IsSoundType(SOUND_COMBAT | SOUND_DANGER) ) + { + if (ValidEyeTarget( pSound->GetSoundOrigin() )) + { + SetHeadDirection(pSound->GetSoundOrigin(),flInterval); + SetViewtarget( pSound->GetSoundOrigin() ); + return; + } + } + } + + // ------------------------------------- + // Otherwise just look around randomly + // ------------------------------------- + + // Check that look target position is still valid + if (m_flNextEyeLookTime > gpGlobals->curtime) + { + if (!ValidEyeTarget(m_vEyeLookTarget)) + { + // Force choosing of new look target + m_flNextEyeLookTime = 0; + } + } + + if (m_flNextEyeLookTime < gpGlobals->curtime) + { + Vector vBodyDir = BodyDirection2D( ); + + /* + Vector lookSpread = Vector(0.82,0.82,0.22); + float x = random->RandomFloat(-0.5,0.5) + random->RandomFloat(-0.5,0.5); + float y = random->RandomFloat(-0.5,0.5) + random->RandomFloat(-0.5,0.5); + float z = random->RandomFloat(-0.5,0.5) + random->RandomFloat(-0.5,0.5); + + QAngle angles; + VectorAngles( vBodyDir, angles ); + Vector forward, right, up; + AngleVectors( angles, &forward, &right, &up ); + + Vector vecDir = vBodyDir + (x * lookSpread.x * forward) + (y * lookSpread.y * right) + (z * lookSpread.z * up); + float lookDist = random->RandomInt(50,2000); + m_vEyeLookTarget = EyePosition() + lookDist*vecDir; + */ + m_vEyeLookTarget = EyePosition() + 500*vBodyDir; + m_flNextEyeLookTime = gpGlobals->curtime + 0.5; // random->RandomInt(1,5); + } + SetHeadDirection(m_vEyeLookTarget,flInterval); + + // ---------------------------------------------------- + // Integrate eye turn in frame rate independent manner + // ---------------------------------------------------- + float timeToUse = flInterval; + while (timeToUse > 0) + { + m_vCurEyeTarget = ((1 - m_flEyeIntegRate) * m_vCurEyeTarget + m_flEyeIntegRate * m_vEyeLookTarget); + timeToUse -= 0.1; + } + SetViewtarget( m_vCurEyeTarget ); +} + + +//----------------------------------------------------------------------------- +// Let the motor deal with turning presentation issues +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::MaintainTurnActivity( ) +{ + // Don't bother if we're in a vehicle + if ( IsInAVehicle() ) + return; + + AI_PROFILE_SCOPE( CAI_BaseNPC_MaintainTurnActivity ); + GetMotor()->MaintainTurnActivity( ); +} + + +//----------------------------------------------------------------------------- +// Here's where all motion occurs +//----------------------------------------------------------------------------- +void CAI_BaseNPC::PerformMovement() +{ + // don't bother to move if the npc isn't alive + if (!IsAlive()) + return; + + AI_PROFILE_SCOPE(CAI_BaseNPC_PerformMovement); + g_AIMoveTimer.Start(); + + float flInterval = ( m_flTimeLastMovement != FLT_MAX ) ? gpGlobals->curtime - m_flTimeLastMovement : 0.1; + + m_pNavigator->Move( ROUND_TO_TICKS( flInterval ) ); + m_flTimeLastMovement = gpGlobals->curtime; + + g_AIMoveTimer.End(); + +} + +//----------------------------------------------------------------------------- +// Updates to npc after movement is completed +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::PostMovement() +{ + AI_PROFILE_SCOPE( CAI_BaseNPC_PostMovement ); + + InvalidateBoneCache(); + + if ( GetModelPtr() && GetModelPtr()->SequencesAvailable() ) + { + float flInterval = GetAnimTimeInterval(); + + if ( CapabilitiesGet() & bits_CAP_AIM_GUN ) + { + AI_PROFILE_SCOPE( CAI_BaseNPC_PM_AimGun ); + AimGun(); + } + else + { + // NPCs with bits_CAP_AIM_GUN update this in SetAim, called by AimGun. + m_flInteractionYaw = GetAbsAngles().y; + } + + // set look targets for npcs with animated faces + if ( CapabilitiesGet() & bits_CAP_ANIMATEDFACE ) + { + AI_PROFILE_SCOPE( CAI_BaseNPC_PM_MaintainLookTargets ); + MaintainLookTargets(flInterval); + } + } + + { + AI_PROFILE_SCOPE( CAI_BaseNPC_PM_MaintainTurnActivity ); + // update turning as needed + MaintainTurnActivity( ); + } +} + + +//----------------------------------------------------------------------------- + +float g_AINextDisabledMessageTime; +extern bool IsInCommentaryMode( void ); + +bool CAI_BaseNPC::PreThink( void ) +{ + // ---------------------------------------------------------- + // Skip AI if its been disabled or networks haven't been + // loaded, and put a warning message on the screen + // + // Don't do this if the convar wants it hidden + // ---------------------------------------------------------- + if ( (CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI || !g_pAINetworkManager->NetworksLoaded()) ) + { + if ( gpGlobals->curtime >= g_AINextDisabledMessageTime && !IsInCommentaryMode() ) + { + g_AINextDisabledMessageTime = gpGlobals->curtime + 0.5f; + + hudtextparms_s tTextParam; + tTextParam.x = 0.7; + tTextParam.y = 0.65; + tTextParam.effect = 0; + tTextParam.r1 = 255; + tTextParam.g1 = 255; + tTextParam.b1 = 255; + tTextParam.a1 = 255; + tTextParam.r2 = 255; + tTextParam.g2 = 255; + tTextParam.b2 = 255; + tTextParam.a2 = 255; + tTextParam.fadeinTime = 0; + tTextParam.fadeoutTime = 0; + tTextParam.holdTime = 0.6; + tTextParam.fxTime = 0; + tTextParam.channel = 1; + UTIL_HudMessageAll( tTextParam, "A.I. Disabled...\n" ); + } + SetActivity( ACT_IDLE ); + return false; + } + + // -------------------------------------------------------- + // If debug stepping + // -------------------------------------------------------- + if (CAI_BaseNPC::m_nDebugBits & bits_debugStepAI) + { + if (m_nDebugCurIndex >= CAI_BaseNPC::m_nDebugPauseIndex) + { + if (!GetNavigator()->IsGoalActive()) + { + m_flPlaybackRate = 0; + } + return false; + } + else + { + m_flPlaybackRate = 1; + } + } + + if ( m_hOpeningDoor.Get() && AIIsDebuggingDoors( this ) ) + { + NDebugOverlay::Line( EyePosition(), m_hOpeningDoor->WorldSpaceCenter(), 255, 255, 255, false, .1 ); + } + + return true; +} + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::RunAnimation( void ) +{ + VPROF_BUDGET( "CAI_BaseNPC_RunAnimation", VPROF_BUDGETGROUP_SERVER_ANIM ); + + if ( !GetModelPtr() ) + return; + + float flInterval = GetAnimTimeInterval(); + + StudioFrameAdvance( ); // animate + + if ((CAI_BaseNPC::m_nDebugBits & bits_debugStepAI) && !GetNavigator()->IsGoalActive()) + { + flInterval = 0; + } + + // start or end a fidget + // This needs a better home -- switching animations over time should be encapsulated on a per-activity basis + // perhaps MaintainActivity() or a ShiftAnimationOverTime() or something. + if ( m_NPCState != NPC_STATE_SCRIPT && m_NPCState != NPC_STATE_DEAD && m_Activity == ACT_IDLE && IsActivityFinished() ) + { + int iSequence; + + // FIXME: this doesn't reissue a translation, so if the idle activity translation changes over time, it'll never get reset + if ( SequenceLoops() ) + { + // animation does loop, which means we're playing subtle idle. Might need to fidget. + iSequence = SelectWeightedSequence ( m_translatedActivity ); + } + else + { + // animation that just ended doesn't loop! That means we just finished a fidget + // and should return to our heaviest weighted idle (the subtle one) + iSequence = SelectHeaviestSequence ( m_translatedActivity ); + } + if ( iSequence != ACTIVITY_NOT_AVAILABLE ) + { + ResetSequence( iSequence ); // Set to new anim (if it's there) + + //Adrian: Basically everywhere else in the AI code this variable gets set to whatever our sequence is. + //But here it doesn't and not setting it causes any animation set through here to be stomped by the + //ideal sequence before it has a chance of playing out (since there's code that reselects the ideal + //sequence if it doesn't match the current one). + if ( hl2_episodic.GetBool() ) + { + m_nIdealSequence = iSequence; + } + } + } + + DispatchAnimEvents( this ); +} + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::PostRun( void ) +{ + AI_PROFILE_SCOPE(CAI_BaseNPC_PostRun); + + g_AIPostRunTimer.Start(); + + if ( !IsMoving() ) + { + if ( GetIdealActivity() == ACT_WALK || + GetIdealActivity() == ACT_RUN || + GetIdealActivity() == ACT_WALK_AIM || + GetIdealActivity() == ACT_RUN_AIM ) + { + PostRunStopMoving(); + } + } + + RunAnimation(); + + // update slave items (weapons) + Weapon_FrameUpdate(); + + g_AIPostRunTimer.End(); +} + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::PostRunStopMoving() +{ + DbgNavMsg1( this, "NPC %s failed to stop properly, slamming activity\n", GetDebugName() ); + if ( !GetNavigator()->SetGoalFromStoppingPath() ) + SetIdealActivity( GetStoppedActivity() ); // This is to prevent running in place +} + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::ShouldAlwaysThink() +{ + // @TODO (toml 07-08-03): This needs to be beefed up. + // There are simple cases already seen where an AI can briefly leave + // the PVS while navigating to the player. Perhaps should incorporate a heuristic taking into + // account mode, enemy, last time saw player, player range etc. For example, if enemy is player, + // and player is within 100 feet, and saw the player within the past 15 seconds, keep running... + return HasSpawnFlags(SF_NPC_ALWAYSTHINK); +} + + +//----------------------------------------------------------------------------- +// Purpose: Return true if the Player should be running the auto-move-out-of-way +// avoidance code, which also means that the NPC shouldn't care about running into the Player. +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::ShouldPlayerAvoid( void ) +{ + if ( GetState() == NPC_STATE_SCRIPT ) + return true; + + if ( IsInAScript() ) + return true; + + if ( IsInLockedScene() == true ) + return true; + + if ( HasSpawnFlags( SF_NPC_ALTCOLLISION ) ) + return true; + + return false; +} + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::UpdateEfficiency( bool bInPVS ) +{ + // Sleeping NPCs always dormant + if ( GetSleepState() != AISS_AWAKE ) + { + SetEfficiency( AIE_DORMANT ); + return; + } + + m_bInChoreo = ( GetState() == NPC_STATE_SCRIPT || IsCurSchedule( SCHED_SCENE_GENERIC, false ) ); + + if ( !ShouldUseEfficiency() ) + { + SetEfficiency( AIE_NORMAL ); + SetMoveEfficiency( AIME_NORMAL ); + return; + } + + //--------------------------------- + + CBasePlayer *pPlayer = AI_GetSinglePlayer(); + static Vector vPlayerEyePosition; + static Vector vPlayerForward; + static int iPrevFrame = -1; + if ( gpGlobals->framecount != iPrevFrame ) + { + iPrevFrame = gpGlobals->framecount; + if ( pPlayer ) + { + pPlayer->EyePositionAndVectors( &vPlayerEyePosition, &vPlayerForward, NULL, NULL ); + } + } + + Vector vToNPC = GetAbsOrigin() - vPlayerEyePosition; + float playerDist = VectorNormalize( vToNPC ); + bool bPlayerFacing; + + bool bClientPVSExpanded = UTIL_ClientPVSIsExpanded(); + + if ( pPlayer ) + { + bPlayerFacing = ( bClientPVSExpanded || ( bInPVS && vPlayerForward.Dot( vToNPC ) > 0 ) ); + } + else + { + playerDist = 0; + bPlayerFacing = true; + } + + //--------------------------------- + + bool bInVisibilityPVS = ( bClientPVSExpanded && UTIL_FindClientInVisibilityPVS( edict() ) != NULL ); + + //--------------------------------- + + if ( ( bInPVS && ( bPlayerFacing || playerDist < 25*12 ) ) || bClientPVSExpanded ) + { + SetMoveEfficiency( AIME_NORMAL ); + } + else + { + SetMoveEfficiency( AIME_EFFICIENT ); + } + + //--------------------------------- + + if ( !IsRetail() && ai_efficiency_override.GetInt() > AIE_NORMAL && ai_efficiency_override.GetInt() <= AIE_DORMANT ) + { + SetEfficiency( (AI_Efficiency_t)ai_efficiency_override.GetInt() ); + return; + } + + //--------------------------------- + + // Some conditions will always force normal + if ( gpGlobals->curtime - GetLastAttackTime() < .15 ) + { + SetEfficiency( AIE_NORMAL ); + return; + } + + bool bFramerateOk = ( gpGlobals->frametime < ai_frametime_limit.GetFloat() ); + + if ( m_bForceConditionsGather || + gpGlobals->curtime - GetLastAttackTime() < .2 || + gpGlobals->curtime - m_flLastDamageTime < .2 || + ( GetState() < NPC_STATE_IDLE || GetState() > NPC_STATE_SCRIPT ) || + ( ( bInPVS || bInVisibilityPVS ) && + ( ( GetTask() && !TaskIsRunning() ) || + GetTaskInterrupt() > 0 || + m_bInChoreo ) ) ) + { + SetEfficiency( ( bFramerateOk ) ? AIE_NORMAL : AIE_EFFICIENT ); + return; + } + + AI_Efficiency_t minEfficiency; + + if ( !ShouldDefaultEfficient() ) + { + minEfficiency = ( bFramerateOk ) ? AIE_NORMAL : AIE_EFFICIENT; + } + else + { + minEfficiency = ( bFramerateOk ) ? AIE_EFFICIENT : AIE_VERY_EFFICIENT; + } + + // Stay normal if there's any chance of a relevant danger sound + bool bPotentialDanger = false; + + if ( GetSoundInterests() & SOUND_DANGER ) + { + int iSound = CSoundEnt::ActiveList(); + + while ( iSound != SOUNDLIST_EMPTY ) + { + CSound *pCurrentSound = CSoundEnt::SoundPointerForIndex( iSound ); + + float hearingSensitivity = HearingSensitivity(); + Vector vEarPosition = EarPosition(); + + if ( pCurrentSound && (SOUND_DANGER & pCurrentSound->SoundType()) ) + { + float flHearDistanceSq = pCurrentSound->Volume() * hearingSensitivity; + flHearDistanceSq *= flHearDistanceSq; + if ( pCurrentSound->GetSoundOrigin().DistToSqr( vEarPosition ) <= flHearDistanceSq ) + { + bPotentialDanger = true; + break; + } + } + + iSound = pCurrentSound->NextSound(); + } + } + + if ( bPotentialDanger ) + { + SetEfficiency( minEfficiency ); + return; + } + + //--------------------------------- + + if ( !pPlayer ) + { + // No heuristic currently for dedicated servers + SetEfficiency( minEfficiency ); + return; + } + + enum + { + DIST_NEAR, + DIST_MID, + DIST_FAR + }; + + int range; + if ( bInPVS ) + { + if ( playerDist < 15*12 ) + { + SetEfficiency( minEfficiency ); + return; + } + + range = ( playerDist < 50*12 ) ? DIST_NEAR : + ( playerDist < 200*12 ) ? DIST_MID : DIST_FAR; + } + else + { + range = ( playerDist < 25*12 ) ? DIST_NEAR : + ( playerDist < 100*12 ) ? DIST_MID : DIST_FAR; + } + + // Efficiency mappings + int state = GetState(); + if (state == NPC_STATE_SCRIPT ) // Treat script as alert. Already confirmed not in PVS + state = NPC_STATE_ALERT; + + static AI_Efficiency_t mappings[] = + { + // Idle + // In PVS + // Facing + AIE_NORMAL, + AIE_EFFICIENT, + AIE_EFFICIENT, + // Not facing + AIE_EFFICIENT, + AIE_EFFICIENT, + AIE_VERY_EFFICIENT, + // Not in PVS + AIE_VERY_EFFICIENT, + AIE_SUPER_EFFICIENT, + AIE_SUPER_EFFICIENT, + // Alert + // In PVS + // Facing + AIE_NORMAL, + AIE_EFFICIENT, + AIE_EFFICIENT, + // Not facing + AIE_NORMAL, + AIE_EFFICIENT, + AIE_EFFICIENT, + // Not in PVS + AIE_EFFICIENT, + AIE_VERY_EFFICIENT, + AIE_SUPER_EFFICIENT, + // Combat + // In PVS + // Facing + AIE_NORMAL, + AIE_NORMAL, + AIE_EFFICIENT, + // Not facing + AIE_NORMAL, + AIE_EFFICIENT, + AIE_EFFICIENT, + // Not in PVS + AIE_NORMAL, + AIE_EFFICIENT, + AIE_VERY_EFFICIENT, + }; + + static const int stateBase[] = { 0, 9, 18 }; + const int NOT_FACING_OFFSET = 3; + const int NO_PVS_OFFSET = 6; + + int iStateOffset = stateBase[state - NPC_STATE_IDLE] ; + int iFacingOffset = (!bInPVS || bPlayerFacing) ? 0 : NOT_FACING_OFFSET; + int iPVSOffset = (bInPVS) ? 0 : NO_PVS_OFFSET; + int iMapping = iStateOffset + iPVSOffset + iFacingOffset + range; + + Assert( iMapping < ARRAYSIZE( mappings ) ); + + AI_Efficiency_t efficiency = mappings[iMapping]; + + //--------------------------------- + + AI_Efficiency_t maxEfficiency = AIE_SUPER_EFFICIENT; + if ( bInVisibilityPVS && state >= NPC_STATE_ALERT ) + { + maxEfficiency = AIE_EFFICIENT; + } + else if ( bInVisibilityPVS || HasCondition( COND_SEE_PLAYER ) ) + { + maxEfficiency = AIE_VERY_EFFICIENT; + } + + //--------------------------------- + + SetEfficiency( clamp( efficiency, minEfficiency, maxEfficiency ) ); +} + + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::UpdateSleepState( bool bInPVS ) +{ + if ( GetSleepState() > AISS_AWAKE ) + { + CBasePlayer *pLocalPlayer = AI_GetSinglePlayer(); + if ( !pLocalPlayer ) + { + if ( gpGlobals->maxClients > 1 ) + { + Wake(); + } + else + { + Warning( "CAI_BaseNPC::UpdateSleepState called with NULL pLocalPlayer\n" ); + } + return; + } + + if ( m_flWakeRadius > .1 && !(pLocalPlayer->GetFlags() & FL_NOTARGET) && ( pLocalPlayer->GetAbsOrigin() - GetAbsOrigin() ).LengthSqr() <= Square(m_flWakeRadius) ) + Wake(); + else if ( GetSleepState() == AISS_WAITING_FOR_PVS ) + { + if ( bInPVS ) + Wake(); + } + else if ( GetSleepState() == AISS_WAITING_FOR_THREAT ) + { + if ( HasCondition( COND_LIGHT_DAMAGE ) || HasCondition( COND_HEAVY_DAMAGE ) ) + Wake(); + else + { + if ( bInPVS ) + { + for (int i = 1; i <= gpGlobals->maxClients; i++ ) + { + CBasePlayer *pPlayer = UTIL_PlayerByIndex( i ); + if ( pPlayer && !(pPlayer->GetFlags() & FL_NOTARGET) && pPlayer->FVisible( this ) ) + Wake(); + } + } + + // Should check for visible danger sounds + if ( (GetSoundInterests() & SOUND_DANGER) && !(HasSpawnFlags(SF_NPC_WAIT_TILL_SEEN)) ) + { + int iSound = CSoundEnt::ActiveList(); + + while ( iSound != SOUNDLIST_EMPTY ) + { + CSound *pCurrentSound = CSoundEnt::SoundPointerForIndex( iSound ); + Assert( pCurrentSound ); + + if ( (pCurrentSound->SoundType() & SOUND_DANGER) && + GetSenses()->CanHearSound( pCurrentSound ) && + SoundIsVisible( pCurrentSound )) + { + Wake(); + break; + } + + iSound = pCurrentSound->NextSound(); + } + } + } + } + } + else + { + // NPC is awake + // Don't let an NPC sleep if they're running a script! + if( !IsInAScript() && m_NPCState != NPC_STATE_SCRIPT ) + { + if( HasSleepFlags(AI_SLEEP_FLAG_AUTO_PVS) ) + { + if( !HasCondition(COND_IN_PVS) ) + { + SetSleepState( AISS_WAITING_FOR_PVS ); + Sleep(); + } + } + if( HasSleepFlags(AI_SLEEP_FLAG_AUTO_PVS_AFTER_PVS) ) + { + if( HasCondition(COND_IN_PVS) ) + { + // OK, we're in the player's PVS. Now switch to regular old AUTO_PVS sleep rules. + AddSleepFlags(AI_SLEEP_FLAG_AUTO_PVS); + RemoveSleepFlags(AI_SLEEP_FLAG_AUTO_PVS_AFTER_PVS); + } + } + } + } +} + +//----------------------------------------------------------------------------- + +struct AIRebalanceInfo_t +{ + CAI_BaseNPC * pNPC; + int iNextThinkTick; + bool bInPVS; + float dotPlayer; + float distPlayer; +}; + +int __cdecl ThinkRebalanceCompare( const AIRebalanceInfo_t *pLeft, const AIRebalanceInfo_t *pRight ) +{ + int base = pLeft->iNextThinkTick - pRight->iNextThinkTick; + if ( base != 0 ) + return base; + + if ( !pLeft->bInPVS && !pRight->bInPVS ) + return 0; + + if ( !pLeft->bInPVS ) + return 1; + + if ( !pRight->bInPVS ) + return -1; + + if ( pLeft->dotPlayer < 0 && pRight->dotPlayer < 0 ) + return 0; + + if ( pLeft->dotPlayer < 0 ) + return 1; + + if ( pRight->dotPlayer < 0 ) + return -1; + + const float NEAR_PLAYER = 50*12; + + if ( pLeft->distPlayer < NEAR_PLAYER && pRight->distPlayer >= NEAR_PLAYER ) + return -1; + + if ( pRight->distPlayer < NEAR_PLAYER && pLeft->distPlayer >= NEAR_PLAYER ) + return 1; + + if ( pLeft->dotPlayer > pRight->dotPlayer ) + return -1; + + if ( pLeft->dotPlayer < pRight->dotPlayer ) + return 1; + + return 0; +} + +inline bool CAI_BaseNPC::CanThinkRebalance() +{ + if ( m_pfnThink != (BASEPTR)&CAI_BaseNPC::CallNPCThink ) + { + return false; + } + + if ( m_bInChoreo ) + { + return false; + } + + if ( m_NPCState == NPC_STATE_DEAD ) + { + return false; + } + + if ( GetSleepState() != AISS_AWAKE ) + { + return false; + } + + if ( !m_bUsingStandardThinkTime /*&& m_iFrameBlocked == -1 */ ) + { + return false; + } + + return true; +} + +void CAI_BaseNPC::RebalanceThinks() +{ + bool bDebugThinkTicks = ai_debug_think_ticks.GetBool(); + if ( bDebugThinkTicks ) + { + static int iPrevTick; + static int nThinksInTick; + static int nRebalanceableThinksInTick; + + if ( gpGlobals->tickcount != iPrevTick ) + { + DevMsg( "NPC per tick is %d [%d] (tick %d, frame %d)\n", nRebalanceableThinksInTick, nThinksInTick, iPrevTick, gpGlobals->framecount ); + iPrevTick = gpGlobals->tickcount; + nThinksInTick = 0; + nRebalanceableThinksInTick = 0; + } + nThinksInTick++; + if ( CanThinkRebalance() ) + nRebalanceableThinksInTick++; + } + + if ( ShouldRebalanceThinks() && gpGlobals->tickcount >= gm_iNextThinkRebalanceTick ) + { + AI_PROFILE_SCOPE(AI_Think_Rebalance ); + + static CUtlVector rebalanceCandidates( 16, 64 ); + gm_iNextThinkRebalanceTick = gpGlobals->tickcount + TIME_TO_TICKS( random->RandomFloat( 3, 5) ); + + int i; + + CBasePlayer *pPlayer = AI_GetSinglePlayer(); + Vector vPlayerForward; + Vector vPlayerEyePosition; + + vPlayerForward.Init(); + vPlayerEyePosition.Init(); + + if ( pPlayer ) + { + pPlayer->EyePositionAndVectors( &vPlayerEyePosition, &vPlayerForward, NULL, NULL ); + } + + int iTicksPer10Hz = TIME_TO_TICKS( .1 ); + int iMinTickRebalance = gpGlobals->tickcount - 1; // -1 needed for alternate ticks + int iMaxTickRebalance = gpGlobals->tickcount + iTicksPer10Hz; + + for ( i = 0; i < g_AI_Manager.NumAIs(); i++ ) + { + CAI_BaseNPC *pCandidate = g_AI_Manager.AccessAIs()[i]; + if ( pCandidate->CanThinkRebalance() && + ( pCandidate->GetNextThinkTick() >= iMinTickRebalance && + pCandidate->GetNextThinkTick() < iMaxTickRebalance ) ) + { + int iInfo = rebalanceCandidates.AddToTail(); + + rebalanceCandidates[iInfo].pNPC = pCandidate; + rebalanceCandidates[iInfo].iNextThinkTick = pCandidate->GetNextThinkTick(); + + if ( pCandidate->IsFlaggedEfficient() ) + { + rebalanceCandidates[iInfo].bInPVS = false; + } + else if ( pPlayer ) + { + Vector vToCandidate = pCandidate->EyePosition() - vPlayerEyePosition; + rebalanceCandidates[iInfo].bInPVS = ( UTIL_FindClientInPVS( pCandidate->edict() ) != NULL ); + rebalanceCandidates[iInfo].distPlayer = VectorNormalize( vToCandidate ); + rebalanceCandidates[iInfo].dotPlayer = vPlayerForward.Dot( vToCandidate ); + } + else + { + rebalanceCandidates[iInfo].bInPVS = true; + rebalanceCandidates[iInfo].dotPlayer = 1; + rebalanceCandidates[iInfo].distPlayer = 0; + } + } + else if ( bDebugThinkTicks ) + DevMsg( " Ignoring %d\n", pCandidate->GetNextThinkTick() ); + } + + if ( rebalanceCandidates.Count() ) + { + rebalanceCandidates.Sort( ThinkRebalanceCompare ); + + int iMaxThinkersPerTick = ceil( (float)( rebalanceCandidates.Count() + 1 ) / (float)iTicksPer10Hz ); // +1 to account for "this" + + int iCurTickDistributing = MIN( gpGlobals->tickcount, rebalanceCandidates[0].iNextThinkTick ); + int iRemainingThinksToDistribute = iMaxThinkersPerTick - 1; // Start with one fewer first time because "this" is + // always gets a slot in the current tick to avoid complications + // in the calculation of "last think" + + if ( bDebugThinkTicks ) + { + DevMsg( "Rebalance %d!\n", rebalanceCandidates.Count() + 1 ); + DevMsg( " Distributing %d\n", iCurTickDistributing ); + } + + for ( i = 0; i < rebalanceCandidates.Count(); i++ ) + { + if ( iRemainingThinksToDistribute == 0 || rebalanceCandidates[i].iNextThinkTick > iCurTickDistributing ) + { + if ( rebalanceCandidates[i].iNextThinkTick <= iCurTickDistributing ) + { + iCurTickDistributing = iCurTickDistributing + 1; + } + else + { + iCurTickDistributing = rebalanceCandidates[i].iNextThinkTick; + } + + if ( bDebugThinkTicks ) + DevMsg( " Distributing %d\n", iCurTickDistributing ); + + iRemainingThinksToDistribute = iMaxThinkersPerTick; + } + + if ( rebalanceCandidates[i].pNPC->GetNextThinkTick() != iCurTickDistributing ) + { + if ( bDebugThinkTicks ) + DevMsg( " Bumping %d to %d\n", rebalanceCandidates[i].pNPC->GetNextThinkTick(), iCurTickDistributing ); + + rebalanceCandidates[i].pNPC->SetNextThink( TICKS_TO_TIME( iCurTickDistributing ) ); + } + else if ( bDebugThinkTicks ) + { + DevMsg( " Leaving %d\n", rebalanceCandidates[i].pNPC->GetNextThinkTick() ); + } + + iRemainingThinksToDistribute--; + } + } + + rebalanceCandidates.RemoveAll(); + + if ( bDebugThinkTicks ) + { + DevMsg( "New distribution is:\n"); + for ( i = 0; i < g_AI_Manager.NumAIs(); i++ ) + { + DevMsg( " %d\n", g_AI_Manager.AccessAIs()[i]->GetNextThinkTick() ); + } + } + + Assert( GetNextThinkTick() == TICK_NEVER_THINK ); // never change this objects tick + } +} + +static float g_NpcTimeThisFrame; +static float g_StartTimeCurThink; + +bool CAI_BaseNPC::PreNPCThink() +{ + static int iPrevFrame = -1; + static float frameTimeLimit = FLT_MAX; + static const ConVar *pHostTimescale; + + if ( frameTimeLimit == FLT_MAX ) + { + pHostTimescale = cvar->FindVar( "host_timescale" ); + } + + bool bUseThinkLimits = ( !m_bInChoreo && ShouldUseFrameThinkLimits() ); + +#ifdef _DEBUG + const float NPC_THINK_LIMIT = 30.0 / 1000.0; +#else + const float NPC_THINK_LIMIT = ( !IsXbox() ) ? (10.0 / 1000.0) : (12.5 / 1000.0); +#endif + + g_StartTimeCurThink = 0; + + if ( bUseThinkLimits && VCRGetMode() == VCR_Disabled ) + { + if ( m_iFrameBlocked == gpGlobals->framecount ) + { + DbgFrameLimitMsg( "Stalled %d (%d)\n", this, gpGlobals->framecount ); + SetNextThink( gpGlobals->curtime ); + return false; + } + else if ( gpGlobals->framecount != iPrevFrame ) + { + DbgFrameLimitMsg( "--- FRAME: %d (%d)\n", this, gpGlobals->framecount ); + float timescale = pHostTimescale->GetFloat(); + if ( timescale < 1 ) + timescale = 1; + + iPrevFrame = gpGlobals->framecount; + frameTimeLimit = NPC_THINK_LIMIT * timescale; + g_NpcTimeThisFrame = 0; + } + else + { + if ( g_NpcTimeThisFrame > NPC_THINK_LIMIT ) + { + float timeSinceLastRealThink = gpGlobals->curtime - m_flLastRealThinkTime; + // Don't bump anyone more that a quarter second + if ( timeSinceLastRealThink <= .25 ) + { + DbgFrameLimitMsg( "Bumped %d (%d)\n", this, gpGlobals->framecount ); + m_iFrameBlocked = gpGlobals->framecount; + SetNextThink( gpGlobals->curtime ); + return false; + } + else + { + DbgFrameLimitMsg( "(Over %d )\n", this ); + } + } + } + + DbgFrameLimitMsg( "Running %d (%d)\n", this, gpGlobals->framecount ); + g_StartTimeCurThink = engine->Time(); + + m_iFrameBlocked = -1; + m_nLastThinkTick = TIME_TO_TICKS( m_flLastRealThinkTime ); + } + + return true; +} + +void CAI_BaseNPC::PostNPCThink( void ) +{ + if ( g_StartTimeCurThink != 0.0 && VCRGetMode() == VCR_Disabled ) + { + g_NpcTimeThisFrame += engine->Time() - g_StartTimeCurThink; + } +} + +void CAI_BaseNPC::CallNPCThink( void ) +{ + RebalanceThinks(); + + //--------------------------------- + + m_bUsingStandardThinkTime = false; + + //--------------------------------- + + if ( !PreNPCThink() ) + { + return; + } + + // reduce cache queries by locking model in memory + MDLCACHE_CRITICAL_SECTION(); + + this->NPCThink(); + + m_flLastRealThinkTime = gpGlobals->curtime; + + PostNPCThink(); +} + +bool NPC_CheckBrushExclude( CBaseEntity *pEntity, CBaseEntity *pBrush ) +{ + CAI_BaseNPC *pNPC = pEntity->MyNPCPointer(); + + if ( pNPC ) + { + return pNPC->GetMoveProbe()->ShouldBrushBeIgnored( pBrush ); + } + + return false; +} + +class CTraceFilterPlayerAvoidance : public CTraceFilterEntitiesOnly +{ +public: + CTraceFilterPlayerAvoidance( const CBaseEntity *pEntity ) { m_pIgnore = pEntity; } + + virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask ) + { + CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity ); + + if ( m_pIgnore == pEntity ) + return false; + + if ( pEntity->IsPlayer() ) + return true; + + return false; + } +private: + + const CBaseEntity *m_pIgnore; +}; + +void CAI_BaseNPC::GetPlayerAvoidBounds( Vector *pMins, Vector *pMaxs ) +{ + *pMins = WorldAlignMins(); + *pMaxs = WorldAlignMaxs(); +} + +ConVar ai_debug_avoidancebounds( "ai_debug_avoidancebounds", "0" ); + +void CAI_BaseNPC::SetPlayerAvoidState( void ) +{ + bool bShouldPlayerAvoid = false; + Vector vNothing; + + GetSequenceLinearMotion( GetSequence(), &vNothing ); + bool bIsMoving = ( IsMoving() || ( vNothing != vec3_origin ) ); + + //If we are coming out of a script, check if we are stuck inside the player. + if ( m_bPerformAvoidance || ( ShouldPlayerAvoid() && bIsMoving ) ) + { + trace_t trace; + Vector vMins, vMaxs; + + GetPlayerAvoidBounds( &vMins, &vMaxs ); + + CBasePlayer *pLocalPlayer = AI_GetSinglePlayer(); + + if ( pLocalPlayer ) + { + bShouldPlayerAvoid = IsBoxIntersectingBox( GetAbsOrigin() + vMins, GetAbsOrigin() + vMaxs, + pLocalPlayer->GetAbsOrigin() + pLocalPlayer->WorldAlignMins(), pLocalPlayer->GetAbsOrigin() + pLocalPlayer->WorldAlignMaxs() ); + } + + if ( ai_debug_avoidancebounds.GetBool() ) + { + int iRed = ( bShouldPlayerAvoid == true ) ? 255 : 0; + + NDebugOverlay::Box( GetAbsOrigin(), vMins, vMaxs, iRed, 0, 255, 64, 0.1 ); + } + } + + m_bPlayerAvoidState = ShouldPlayerAvoid(); + m_bPerformAvoidance = bShouldPlayerAvoid; + + if ( GetCollisionGroup() == COLLISION_GROUP_NPC || GetCollisionGroup() == COLLISION_GROUP_NPC_ACTOR ) + { + if ( m_bPerformAvoidance == true ) + { + SetCollisionGroup( COLLISION_GROUP_NPC_ACTOR ); + } + else + { + SetCollisionGroup( COLLISION_GROUP_NPC ); + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: Enables player avoidance when the player's vphysics shadow penetrates our vphysics shadow. This can +// happen when the player is hit by a combine ball, which pushes them into an adjacent npc. Subclasses should +// override this if it causes problems, but in general this will solve cases of the player getting stuck in +// the NPC from being pushed. +//----------------------------------------------------------------------------- +void CAI_BaseNPC::PlayerPenetratingVPhysics( void ) +{ + m_bPerformAvoidance = true; +} + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::CheckPVSCondition() +{ + bool bInPVS = ( UTIL_FindClientInPVS( edict() ) != NULL ) || (UTIL_ClientPVSIsExpanded() && UTIL_FindClientInVisibilityPVS( edict() )); + + if ( bInPVS ) + SetCondition( COND_IN_PVS ); + else + ClearCondition( COND_IN_PVS ); + + return bInPVS; +} + + +//----------------------------------------------------------------------------- +// NPC Think - calls out to core AI functions and handles this +// npc's specific animation events +// + +void CAI_BaseNPC::NPCThink( void ) +{ + if ( m_bCheckContacts ) + { + CheckPhysicsContacts(); + } + + Assert( !(m_NPCState == NPC_STATE_DEAD && m_lifeState == LIFE_ALIVE) ); + + //--------------------------------- + + SetNextThink( TICK_NEVER_THINK ); + + //--------------------------------- + + bool bInPVS = CheckPVSCondition(); + + //--------------------------------- + + UpdateSleepState( bInPVS ); + + //--------------------------------- + bool bRanDecision = false; + + if ( GetEfficiency() < AIE_DORMANT && GetSleepState() == AISS_AWAKE ) + { + static CFastTimer timer; + float thinkLimit = ai_show_think_tolerance.GetFloat(); + + if ( thinkLimit > 0 ) + timer.Start(); + + if ( g_pAINetworkManager && g_pAINetworkManager->IsInitialized() ) + { + VPROF_BUDGET( "NPCs", VPROF_BUDGETGROUP_NPCS ); + + AI_PROFILE_SCOPE_BEGIN_( GetClassScheduleIdSpace()->GetClassName() ); // need to use a string stable from map load to map load + + SetPlayerAvoidState(); + + if ( PreThink() ) + { + if ( m_flNextDecisionTime <= gpGlobals->curtime ) + { + bRanDecision = true; + m_ScheduleState.bTaskRanAutomovement = false; + m_ScheduleState.bTaskUpdatedYaw = false; + RunAI(); + } + else + { + if ( m_ScheduleState.bTaskRanAutomovement ) + AutoMovement(); + if ( m_ScheduleState.bTaskUpdatedYaw ) + GetMotor()->UpdateYaw(); + } + + PostRun(); + + PerformMovement(); + + m_bIsMoving = IsMoving(); + + PostMovement(); + + SetSimulationTime( gpGlobals->curtime ); + } + else + m_flTimeLastMovement = FLT_MAX; + + AI_PROFILE_SCOPE_END(); + } + + if ( thinkLimit > 0 ) + { + timer.End(); + + float thinkTime = g_AIRunTimer.GetDuration().GetMillisecondsF(); + + if ( thinkTime > thinkLimit ) + { + int color = (int)RemapVal( thinkTime, thinkLimit, thinkLimit * 3, 96.0, 255.0 ); + if ( color > 255 ) + color = 255; + else if ( color < 96 ) + color = 96; + + Vector right; + Vector vecPoint; + + vecPoint = EyePosition() + Vector( 0, 0, 12 ); + GetVectors( NULL, &right, NULL ); + NDebugOverlay::Line( vecPoint, vecPoint + Vector( 0, 0, 64 ), color, 0, 0, false , 1.0 ); + NDebugOverlay::Line( vecPoint, vecPoint + Vector( 0, 0, 16 ) + right * 16, color, 0, 0, false , 1.0 ); + NDebugOverlay::Line( vecPoint, vecPoint + Vector( 0, 0, 16 ) - right * 16, color, 0, 0, false , 1.0 ); + } + } + } + + m_bUsingStandardThinkTime = ( GetNextThinkTick() == TICK_NEVER_THINK ); + + UpdateEfficiency( bInPVS ); + + if ( m_bUsingStandardThinkTime ) + { + static const char *ppszEfficiencies[] = + { + "AIE_NORMAL", + "AIE_EFFICIENT", + "AIE_VERY_EFFICIENT", + "AIE_SUPER_EFFICIENT", + "AIE_DORMANT", + }; + + static const char *ppszMoveEfficiencies[] = + { + "AIME_NORMAL", + "AIME_EFFICIENT", + }; + + if ( ai_debug_efficiency.GetBool() ) + DevMsg( this, "Eff: %s, Move: %s\n", ppszEfficiencies[GetEfficiency()], ppszMoveEfficiencies[GetMoveEfficiency()] ); + + static float g_DecisionIntervals[] = + { + .1, // AIE_NORMAL + .2, // AIE_EFFICIENT + .4, // AIE_VERY_EFFICIENT + .6, // AIE_SUPER_EFFICIENT + }; + + if ( bRanDecision ) + { + m_flNextDecisionTime = gpGlobals->curtime + g_DecisionIntervals[GetEfficiency()]; + } + + if ( GetMoveEfficiency() == AIME_NORMAL || GetEfficiency() == AIE_NORMAL ) + { + SetNextThink( gpGlobals->curtime + .1 ); + } + else + { + SetNextThink( gpGlobals->curtime + .2 ); + } + } + else + { + m_flNextDecisionTime = 0; + } +} + +//========================================================= +// CAI_BaseNPC - USE - will make a npc angry at whomever +// activated it. +//========================================================= +void CAI_BaseNPC::NPCUse ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) +{ + return; + + // Can't +USE NPCs running scripts + if ( GetState() == NPC_STATE_SCRIPT ) + return; + + if ( IsInAScript() ) + return; + + SetIdealState( NPC_STATE_ALERT ); +} + +//----------------------------------------------------------------------------- +// Purpose: Virtual function that allows us to have any npc ignore a set of +// shared conditions. +// +//----------------------------------------------------------------------------- +void CAI_BaseNPC::RemoveIgnoredConditions( void ) +{ + m_ConditionsPreIgnore = m_Conditions; + m_Conditions.And( m_InverseIgnoreConditions, &m_Conditions ); + + if ( m_NPCState == NPC_STATE_SCRIPT && m_hCine ) + m_hCine->RemoveIgnoredConditions(); +} + +//========================================================= +// RangeAttack1Conditions +//========================================================= +int CAI_BaseNPC::RangeAttack1Conditions ( float flDot, float flDist ) +{ + if ( flDist < 64) + { + return COND_TOO_CLOSE_TO_ATTACK; + } + else if (flDist > 784) + { + return COND_TOO_FAR_TO_ATTACK; + } + else if (flDot < 0.5) + { + return COND_NOT_FACING_ATTACK; + } + + return COND_CAN_RANGE_ATTACK1; +} + +//========================================================= +// RangeAttack2Conditions +//========================================================= +int CAI_BaseNPC::RangeAttack2Conditions ( float flDot, float flDist ) +{ + if ( flDist < 64) + { + return COND_TOO_CLOSE_TO_ATTACK; + } + else if (flDist > 512) + { + return COND_TOO_FAR_TO_ATTACK; + } + else if (flDot < 0.5) + { + return COND_NOT_FACING_ATTACK; + } + + return COND_CAN_RANGE_ATTACK2; +} + +//========================================================= +// MeleeAttack1Conditions +//========================================================= +int CAI_BaseNPC::MeleeAttack1Conditions ( float flDot, float flDist ) +{ + if ( flDist > 64) + { + return COND_TOO_FAR_TO_ATTACK; + } + else if (flDot < 0.7) + { + return 0; + } + else if (GetEnemy() == NULL) + { + return 0; + } + + // Decent fix to keep folks from kicking/punching hornets and snarks is to check the onground flag(sjb) + if ( GetEnemy()->GetFlags() & FL_ONGROUND ) + { + return COND_CAN_MELEE_ATTACK1; + } + return 0; +} + +//========================================================= +// MeleeAttack2Conditions +//========================================================= +int CAI_BaseNPC::MeleeAttack2Conditions ( float flDot, float flDist ) +{ + if ( flDist > 64) + { + return COND_TOO_FAR_TO_ATTACK; + } + else if (flDot < 0.7) + { + return 0; + } + return COND_CAN_MELEE_ATTACK2; +} + +// Get capability mask +int CAI_BaseNPC::CapabilitiesGet( void ) const +{ + int capability = m_afCapability; + if ( GetActiveWeapon() ) + { + capability |= GetActiveWeapon()->CapabilitiesGet(); + } + return capability; +} + +// Set capability mask +int CAI_BaseNPC::CapabilitiesAdd( int capability ) +{ + m_afCapability |= capability; + + return m_afCapability; +} + +// Set capability mask +int CAI_BaseNPC::CapabilitiesRemove( int capability ) +{ + m_afCapability &= ~capability; + + return m_afCapability; +} + +// Clear capability mask +void CAI_BaseNPC::CapabilitiesClear( void ) +{ + m_afCapability = 0; +} + + +//========================================================= +// ClearAttacks - clear out all attack conditions +//========================================================= +void CAI_BaseNPC::ClearAttackConditions( ) +{ + // Clear all attack conditions + ClearCondition( COND_CAN_RANGE_ATTACK1 ); + ClearCondition( COND_CAN_RANGE_ATTACK2 ); + ClearCondition( COND_CAN_MELEE_ATTACK1 ); + ClearCondition( COND_CAN_MELEE_ATTACK2 ); + ClearCondition( COND_WEAPON_HAS_LOS ); + ClearCondition( COND_WEAPON_BLOCKED_BY_FRIEND ); + ClearCondition( COND_WEAPON_PLAYER_IN_SPREAD ); // Player in shooting direction + ClearCondition( COND_WEAPON_PLAYER_NEAR_TARGET ); // Player near shooting position + ClearCondition( COND_WEAPON_SIGHT_OCCLUDED ); +} + +//========================================================= +// GatherAttackConditions - sets all of the bits for attacks that the +// npc is capable of carrying out on the passed entity. +//========================================================= + +void CAI_BaseNPC::GatherAttackConditions( CBaseEntity *pTarget, float flDist ) +{ + AI_PROFILE_SCOPE(CAI_BaseNPC_GatherAttackConditions); + + Vector vecLOS = ( pTarget->GetAbsOrigin() - GetAbsOrigin() ); + vecLOS.z = 0; + VectorNormalize( vecLOS ); + + Vector vBodyDir = BodyDirection2D( ); + float flDot = DotProduct( vecLOS, vBodyDir ); + + // we know the enemy is in front now. We'll find which attacks the npc is capable of by + // checking for corresponding Activities in the model file, then do the simple checks to validate + // those attack types. + + int capability; + Vector targetPos; + bool bWeaponHasLOS; + int condition; + + capability = CapabilitiesGet(); + + // Clear all attack conditions + AI_PROFILE_SCOPE_BEGIN( CAI_BaseNPC_GatherAttackConditions_PrimaryWeaponLOS ); + + // @TODO (toml 06-15-03): There are simple cases where + // the upper torso of the enemy is visible, and the NPC is at an angle below + // them, but the above test fails because BodyTarget returns the center of + // the target. This needs some better handling/closer evaluation + + // Try the eyes first, as likely to succeed (because can see or else wouldn't be here) thus reducing + // the odds of the need for a second trace + ClearAttackConditions(); + targetPos = pTarget->EyePosition(); + bWeaponHasLOS = CurrentWeaponLOSCondition( targetPos, true ); + + AI_PROFILE_SCOPE_END(); + + if ( !bWeaponHasLOS ) + { + AI_PROFILE_SCOPE( CAI_BaseNPC_GatherAttackConditions_SecondaryWeaponLOS ); + ClearAttackConditions( ); + targetPos = pTarget->BodyTarget( GetAbsOrigin() ); + bWeaponHasLOS = CurrentWeaponLOSCondition( targetPos, true ); + } + else + { + SetCondition( COND_WEAPON_HAS_LOS ); + } + + bool bWeaponIsReady = (GetActiveWeapon() && !IsWeaponStateChanging()); + + // FIXME: move this out of here + if ( (capability & bits_CAP_WEAPON_RANGE_ATTACK1) && bWeaponIsReady ) + { + AI_PROFILE_SCOPE( CAI_BaseNPC_GatherAttackConditions_WeaponRangeAttack1Condition ); + + condition = GetActiveWeapon()->WeaponRangeAttack1Condition(flDot, flDist); + + if ( condition == COND_NOT_FACING_ATTACK && FInAimCone( targetPos ) ) + DevMsg( "Warning: COND_NOT_FACING_ATTACK set but FInAimCone is true\n" ); + + if (condition != COND_CAN_RANGE_ATTACK1 || bWeaponHasLOS) + { + SetCondition(condition); + } + } + else if ( capability & bits_CAP_INNATE_RANGE_ATTACK1 ) + { + AI_PROFILE_SCOPE( CAI_BaseNPC_GatherAttackConditions_RangeAttack1Condition ); + + condition = RangeAttack1Conditions( flDot, flDist ); + if (condition != COND_CAN_RANGE_ATTACK1 || bWeaponHasLOS) + { + SetCondition(condition); + } + } + + if ( (capability & bits_CAP_WEAPON_RANGE_ATTACK2) && bWeaponIsReady && ( GetActiveWeapon()->CapabilitiesGet() & bits_CAP_WEAPON_RANGE_ATTACK2 ) ) + { + AI_PROFILE_SCOPE( CAI_BaseNPC_GatherAttackConditions_WeaponRangeAttack2Condition ); + + condition = GetActiveWeapon()->WeaponRangeAttack2Condition(flDot, flDist); + if (condition != COND_CAN_RANGE_ATTACK2 || bWeaponHasLOS) + { + SetCondition(condition); + } + } + else if ( capability & bits_CAP_INNATE_RANGE_ATTACK2 ) + { + AI_PROFILE_SCOPE( CAI_BaseNPC_GatherAttackConditions_RangeAttack2Condition ); + + condition = RangeAttack2Conditions( flDot, flDist ); + if (condition != COND_CAN_RANGE_ATTACK2 || bWeaponHasLOS) + { + SetCondition(condition); + } + } + + if ( (capability & bits_CAP_WEAPON_MELEE_ATTACK1) && bWeaponIsReady) + { + AI_PROFILE_SCOPE( CAI_BaseNPC_GatherAttackConditions_WeaponMeleeAttack1Condition ); + SetCondition(GetActiveWeapon()->WeaponMeleeAttack1Condition(flDot, flDist)); + } + else if ( capability & bits_CAP_INNATE_MELEE_ATTACK1 ) + { + AI_PROFILE_SCOPE( CAI_BaseNPC_GatherAttackConditions_MeleeAttack1Condition ); + SetCondition(MeleeAttack1Conditions ( flDot, flDist )); + } + + if ( (capability & bits_CAP_WEAPON_MELEE_ATTACK2) && bWeaponIsReady) + { + AI_PROFILE_SCOPE( CAI_BaseNPC_GatherAttackConditions_WeaponMeleeAttack2Condition ); + SetCondition(GetActiveWeapon()->WeaponMeleeAttack2Condition(flDot, flDist)); + } + else if ( capability & bits_CAP_INNATE_MELEE_ATTACK2 ) + { + AI_PROFILE_SCOPE( CAI_BaseNPC_GatherAttackConditions_MeleeAttack2Condition ); + SetCondition(MeleeAttack2Conditions ( flDot, flDist )); + } + + // ----------------------------------------------------------------- + // If any attacks are possible clear attack specific bits + // ----------------------------------------------------------------- + if (HasCondition(COND_CAN_RANGE_ATTACK2) || + HasCondition(COND_CAN_RANGE_ATTACK1) || + HasCondition(COND_CAN_MELEE_ATTACK2) || + HasCondition(COND_CAN_MELEE_ATTACK1) ) + { + ClearCondition(COND_TOO_CLOSE_TO_ATTACK); + ClearCondition(COND_TOO_FAR_TO_ATTACK); + ClearCondition(COND_WEAPON_BLOCKED_BY_FRIEND); + } +} + + +//========================================================= +// SetState +//========================================================= +void CAI_BaseNPC::SetState( NPC_STATE State ) +{ + NPC_STATE OldState; + + OldState = m_NPCState; + + if ( State != m_NPCState ) + { + m_flLastStateChangeTime = gpGlobals->curtime; + } + + switch( State ) + { + // Drop enemy pointers when going to idle + case NPC_STATE_IDLE: + + if ( GetEnemy() != NULL ) + { + SetEnemy( NULL ); // not allowed to have an enemy anymore. + DevMsg( 2, "Stripped\n" ); + } + break; + } + + bool fNotifyChange = false; + + if( m_NPCState != State ) + { + // Don't notify if we're changing to a state we're already in! + fNotifyChange = true; + } + + m_NPCState = State; + SetIdealState( State ); + + // Notify the character that its state has changed. + if( fNotifyChange ) + { + OnStateChange( OldState, m_NPCState ); + } +} + +bool CAI_BaseNPC::WokeThisTick() const +{ + return m_nWakeTick == gpGlobals->tickcount ? true : false; +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +void CAI_BaseNPC::Wake( bool bFireOutput ) +{ + if ( GetSleepState() != AISS_AWAKE ) + { + m_nWakeTick = gpGlobals->tickcount; + SetSleepState( AISS_AWAKE ); + RemoveEffects( EF_NODRAW ); + if ( bFireOutput ) + m_OnWake.FireOutput( this, this ); + + if ( m_bWakeSquad && GetSquad() ) + { + AISquadIter_t iter; + for ( CAI_BaseNPC *pSquadMember = GetSquad()->GetFirstMember( &iter ); pSquadMember; pSquadMember = GetSquad()->GetNextMember( &iter ) ) + { + if ( pSquadMember->IsAlive() && pSquadMember != this ) + { + pSquadMember->m_bWakeSquad = false; + pSquadMember->Wake(); + } + } + + } + } +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +void CAI_BaseNPC::Sleep() +{ + // Don't render. + AddEffects( EF_NODRAW ); + + if( GetState() == NPC_STATE_SCRIPT ) + { + Warning( "%s put to sleep while in Scripted state!\n", GetClassname() ); + } + + VacateStrategySlot(); + + // Slam my schedule. + SetSchedule( SCHED_SLEEP ); + + m_OnSleep.FireOutput( this, this ); +} + +//----------------------------------------------------------------------------- +// Sets all sensing-related conditions +//----------------------------------------------------------------------------- +void CAI_BaseNPC::PerformSensing( void ) +{ + GetSenses()->PerformSensing(); +} + + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::ClearSenseConditions( void ) +{ + static int conditionsToClear[] = + { + COND_SEE_HATE, + COND_SEE_DISLIKE, + COND_SEE_ENEMY, + COND_SEE_FEAR, + COND_SEE_NEMESIS, + COND_SEE_PLAYER, + COND_HEAR_DANGER, + COND_HEAR_COMBAT, + COND_HEAR_WORLD, + COND_HEAR_PLAYER, + COND_HEAR_THUMPER, + COND_HEAR_BUGBAIT, + COND_HEAR_PHYSICS_DANGER, + COND_HEAR_MOVE_AWAY, + COND_SMELL, + }; + + ClearConditions( conditionsToClear, ARRAYSIZE( conditionsToClear ) ); +} + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::CheckOnGround( void ) +{ + bool bScriptedWait = ( IsCurSchedule( SCHED_WAIT_FOR_SCRIPT ) || ( m_hCine && m_scriptState == CAI_BaseNPC::SCRIPT_WAIT ) ); + if ( !bScriptedWait && !HasCondition( COND_FLOATING_OFF_GROUND ) ) + { + // parented objects are never floating + if (GetMoveParent() != NULL) + return; + + // NPCs in scripts with the fly flag shouldn't fall. + // FIXME: should NPCS with FL_FLY ever fall? Doesn't seem like they should. + if ( ( GetState() == NPC_STATE_SCRIPT ) && ( GetFlags() & FL_FLY ) ) + return; + + if ( ( GetNavType() == NAV_GROUND ) && ( GetMoveType() != MOVETYPE_VPHYSICS ) && ( GetMoveType() != MOVETYPE_NONE ) ) + { + if ( m_CheckOnGroundTimer.Expired() ) + { + m_CheckOnGroundTimer.Set(0.5); + + // check a shrunk box centered around the foot + Vector maxs = WorldAlignMaxs(); + Vector mins = WorldAlignMins(); + + if ( mins != maxs ) // some NPCs have no hull, so mins == maxs == vec3_origin + { + maxs -= Vector( 0.0f, 0.0f, 0.2f ); + + Vector vecStart = GetAbsOrigin() + Vector( 0, 0, .1f ); + Vector vecDown = GetAbsOrigin(); + vecDown.z -= 4.0; + + trace_t trace; + m_pMoveProbe->TraceHull( vecStart, vecDown, mins, maxs, MASK_NPCSOLID, &trace ); + + if (trace.fraction == 1.0) + { + SetCondition( COND_FLOATING_OFF_GROUND ); + SetGroundEntity( NULL ); + } + else + { + if ( trace.startsolid && trace.m_pEnt->GetMoveType() == MOVETYPE_VPHYSICS && + trace.m_pEnt->VPhysicsGetObject() && trace.m_pEnt->VPhysicsGetObject()->GetMass() < VPHYSICS_LARGE_OBJECT_MASS ) + { + // stuck inside a small physics object? + m_CheckOnGroundTimer.Set(0.1f); + NPCPhysics_CreateSolver( this, trace.m_pEnt, true, 0.25f ); + if ( VPhysicsGetObject() ) + { + VPhysicsGetObject()->RecheckContactPoints(); + } + } + // Check to see if someone changed the ground on us... + if ( trace.m_pEnt && trace.m_pEnt != GetGroundEntity() ) + { + SetGroundEntity( trace.m_pEnt ); + } + } + } + } + } + } + else + { + // parented objects are never floating + if ( bScriptedWait || GetMoveParent() != NULL || (GetFlags() & FL_ONGROUND ) || GetNavType() != NAV_GROUND ) + { + ClearCondition( COND_FLOATING_OFF_GROUND ); + } + } + +} + +void CAI_BaseNPC::NotifyPushMove() +{ + // don't recheck ground when I'm being push-moved + m_CheckOnGroundTimer.Set( 0.5f ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::CanFlinch( void ) +{ + if ( IsCurSchedule( SCHED_BIG_FLINCH ) ) + return false; + + if ( m_flNextFlinchTime >= gpGlobals->curtime ) + return false; + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::CheckFlinches( void ) +{ + // If we're currently flinching, don't allow gesture flinches to be overlaid + if ( IsCurSchedule( SCHED_BIG_FLINCH ) ) + { + ClearCondition( COND_LIGHT_DAMAGE ); + ClearCondition( COND_HEAVY_DAMAGE ); + } + + // If we've taken heavy damage, try to do a full schedule flinch + if ( HasCondition(COND_HEAVY_DAMAGE) ) + { + // If we've already flinched recently, gesture flinch instead. + if ( HasMemory(bits_MEMORY_FLINCHED) ) + { + // Clear the heavy damage condition so we don't interrupt schedules + // when we play a gesture flinch because we recently did a full flinch. + // Prevents the player from stun-locking enemies, even though they don't full flinch. + ClearCondition( COND_HEAVY_DAMAGE ); + } + else if ( !HasInterruptCondition(COND_HEAVY_DAMAGE) ) + { + // If we have taken heavy damage, but the current schedule doesn't + // break on that, resort to just playing a gesture flinch. + PlayFlinchGesture(); + } + + // Otherwise, do nothing. The heavy damage will interrupt our schedule and we'll flinch. + } + else if ( HasCondition( COND_LIGHT_DAMAGE ) ) + { + // If we have taken light damage play gesture flinches + PlayFlinchGesture(); + } + + // If it's been a while since we did a full flinch, forget that we flinched so we'll flinch fully again + if ( HasMemory(bits_MEMORY_FLINCHED) && gpGlobals->curtime > m_flNextFlinchTime ) + { + Forget(bits_MEMORY_FLINCHED); + } +} + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::GatherConditions( void ) +{ + m_bConditionsGathered = true; + g_AIConditionsTimer.Start(); + + if( gpGlobals->curtime > m_flTimePingEffect && m_flTimePingEffect > 0.0f ) + { + // Turn off the pinging. + DispatchUpdateTransmitState(); + m_flTimePingEffect = 0.0f; + } + + if ( m_NPCState != NPC_STATE_NONE && m_NPCState != NPC_STATE_DEAD ) + { + if ( FacingIdeal() ) + Forget( bits_MEMORY_TURNING ); + + bool bForcedGather = m_bForceConditionsGather; + m_bForceConditionsGather = false; + + if ( m_pfnThink != (BASEPTR)&CAI_BaseNPC::CallNPCThink ) + { + if ( UTIL_FindClientInPVS( edict() ) != NULL ) + SetCondition( COND_IN_PVS ); + else + ClearCondition( COND_IN_PVS ); + } + + // Sample the environment. Do this unconditionally if there is a player in this + // npc's PVS. NPCs in COMBAT state are allowed to simulate when there is no player in + // the same PVS. This is so that any fights in progress will continue even if the player leaves the PVS. + if ( !IsFlaggedEfficient() && + ( bForcedGather || + HasCondition( COND_IN_PVS ) || + ShouldAlwaysThink() || + m_NPCState == NPC_STATE_COMBAT ) ) + { + CheckOnGround(); + + if ( ShouldPlayIdleSound() ) + { + AI_PROFILE_SCOPE(CAI_BaseNPC_IdleSound); + IdleSound(); + } + + PerformSensing(); + + GetEnemies()->RefreshMemories(); + ChooseEnemy(); + + // Check to see if there is a better weapon available + if (Weapon_IsBetterAvailable()) + { + SetCondition(COND_BETTER_WEAPON_AVAILABLE); + } + + if ( GetCurSchedule() && + ( m_NPCState == NPC_STATE_IDLE || m_NPCState == NPC_STATE_ALERT) && + GetEnemy() && + !HasCondition( COND_NEW_ENEMY ) && + GetCurSchedule()->HasInterrupt( COND_NEW_ENEMY ) ) + { + // @Note (toml 05-05-04): There seems to be a case where an NPC can not respond + // to COND_NEW_ENEMY. Only evidence right now is save + // games after the fact, so for now, just patching it up + DevMsg( 2, "Had to force COND_NEW_ENEMY\n" ); + SetCondition(COND_NEW_ENEMY); + } + } + else + { + // if not done, can have problems if leave PVS in same frame heard/saw things, + // since only PerformSensing clears conditions + ClearSenseConditions(); + } + + // do these calculations if npc has an enemy. + if ( GetEnemy() != NULL ) + { + if ( !IsFlaggedEfficient() ) + { + GatherEnemyConditions( GetEnemy() ); + m_flLastEnemyTime = gpGlobals->curtime; + } + else + { + SetEnemy( NULL ); + } + } + + // do these calculations if npc has a target + if ( GetTarget() != NULL ) + { + CheckTarget( GetTarget() ); + } + + CheckAmmo(); + + CheckFlinches(); + + CheckSquad(); + } + else + ClearCondition( COND_IN_PVS ); + + g_AIConditionsTimer.End(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::PrescheduleThink( void ) +{ +#ifdef HL2_EPISODIC + CheckForScriptedNPCInteractions(); +#endif + + // If we use weapons, and our desired weapon state is not the current, fix it + if( (CapabilitiesGet() & bits_CAP_USE_WEAPONS) && (m_iDesiredWeaponState == DESIREDWEAPONSTATE_HOLSTERED || m_iDesiredWeaponState == DESIREDWEAPONSTATE_UNHOLSTERED || m_iDesiredWeaponState == DESIREDWEAPONSTATE_HOLSTERED_DESTROYED ) ) + { + if ( IsAlive() && !IsInAScript() ) + { + if ( !IsCurSchedule( SCHED_MELEE_ATTACK1, false ) && !IsCurSchedule( SCHED_MELEE_ATTACK2, false ) && + !IsCurSchedule( SCHED_RANGE_ATTACK1, false ) && !IsCurSchedule( SCHED_RANGE_ATTACK2, false ) ) + { + if ( m_iDesiredWeaponState == DESIREDWEAPONSTATE_HOLSTERED || m_iDesiredWeaponState == DESIREDWEAPONSTATE_HOLSTERED_DESTROYED ) + { + HolsterWeapon(); + } + else if ( m_iDesiredWeaponState == DESIREDWEAPONSTATE_UNHOLSTERED ) + { + UnholsterWeapon(); + } + } + } + else + { + // Throw away the request + m_iDesiredWeaponState = DESIREDWEAPONSTATE_IGNORE; + } + } +} + +//----------------------------------------------------------------------------- +// Main entry point for processing AI +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::RunAI( void ) +{ + AI_PROFILE_SCOPE(CAI_BaseNPC_RunAI); + g_AIRunTimer.Start(); + + if( ai_debug_squads.GetBool() ) + { + if( IsInSquad() && GetSquad() && !CAI_Squad::IsSilentMember(this ) && ( GetSquad()->IsLeader( this ) || GetSquad()->NumMembers() == 1 ) ) + { + AISquadIter_t iter; + CAI_Squad *pSquad = GetSquad(); + + Vector right; + Vector vecPoint; + + vecPoint = EyePosition() + Vector( 0, 0, 12 ); + GetVectors( NULL, &right, NULL ); + NDebugOverlay::Line( vecPoint, vecPoint + Vector( 0, 0, 64 ), 0, 255, 0, false , 0.1 ); + NDebugOverlay::Line( vecPoint, vecPoint + Vector( 0, 0, 32 ) + right * 32, 0, 255, 0, false , 0.1 ); + NDebugOverlay::Line( vecPoint, vecPoint + Vector( 0, 0, 32 ) - right * 32, 0, 255, 0, false , 0.1 ); + + for ( CAI_BaseNPC *pSquadMember = pSquad->GetFirstMember( &iter, false ); pSquadMember; pSquadMember = pSquad->GetNextMember( &iter, false ) ) + { + if ( pSquadMember != this ) + NDebugOverlay::Line( EyePosition(), pSquadMember->EyePosition(), 0, + CAI_Squad::IsSilentMember(pSquadMember) ? 127 : 255, 0, false , 0.1 ); + } + } + } + + if( ai_debug_loners.GetBool() && !IsInSquad() && AI_IsSinglePlayer() ) + { + Vector right; + Vector vecPoint; + + vecPoint = EyePosition() + Vector( 0, 0, 12 ); + + UTIL_GetLocalPlayer()->GetVectors( NULL, &right, NULL ); + + NDebugOverlay::Line( vecPoint, vecPoint + Vector( 0, 0, 64 ), 255, 0, 0, false , 0.1 ); + NDebugOverlay::Line( vecPoint, vecPoint + Vector( 0, 0, 32 ) + right * 32, 255, 0, 0, false , 0.1 ); + NDebugOverlay::Line( vecPoint, vecPoint + Vector( 0, 0, 32 ) - right * 32, 255, 0, 0, false , 0.1 ); + } + +#ifdef _DEBUG + m_bSelected = ( (m_debugOverlays & OVERLAY_NPC_SELECTED_BIT) != 0 ); +#endif + + m_bConditionsGathered = false; + m_bSkippedChooseEnemy = false; + + if ( g_pDeveloper->GetInt() && !GetNavigator()->IsOnNetwork() ) + { + AddTimedOverlay( "NPC w/no reachable nodes!", 5 ); + } + + AI_PROFILE_SCOPE_BEGIN(CAI_BaseNPC_RunAI_GatherConditions); + GatherConditions(); + RemoveIgnoredConditions(); + AI_PROFILE_SCOPE_END(); + + if ( !m_bConditionsGathered ) + m_bConditionsGathered = true; // derived class didn't call to base + + TryRestoreHull(); + + g_AIPrescheduleThinkTimer.Start(); + + AI_PROFILE_SCOPE_BEGIN(CAI_RunAI_PrescheduleThink); + PrescheduleThink(); + AI_PROFILE_SCOPE_END(); + + g_AIPrescheduleThinkTimer.End(); + + MaintainSchedule(); + + PostscheduleThink(); + + ClearTransientConditions(); + + g_AIRunTimer.End(); +} + +//----------------------------------------------------------------------------- +void CAI_BaseNPC::ClearTransientConditions() +{ + // if the npc didn't use these conditions during the above call to MaintainSchedule() + // we throw them out cause we don't want them sitting around through the lifespan of a schedule + // that doesn't use them. + ClearCondition( COND_LIGHT_DAMAGE ); + ClearCondition( COND_HEAVY_DAMAGE ); + ClearCondition( COND_PHYSICS_DAMAGE ); + ClearCondition( COND_PLAYER_PUSHING ); +} + + +//----------------------------------------------------------------------------- +// Selecting the idle ideal state +//----------------------------------------------------------------------------- +NPC_STATE CAI_BaseNPC::SelectIdleIdealState() +{ + // IDLE goes to ALERT upon hearing a sound + // IDLE goes to ALERT upon being injured + // IDLE goes to ALERT upon seeing food + // IDLE goes to COMBAT upon sighting an enemy + if ( HasCondition(COND_NEW_ENEMY) || + HasCondition(COND_SEE_ENEMY) ) + { + // new enemy! This means an idle npc has seen someone it dislikes, or + // that a npc in combat has found a more suitable target to attack + return NPC_STATE_COMBAT; + } + + // Set our ideal yaw if we've taken damage + if ( HasCondition(COND_LIGHT_DAMAGE) || + HasCondition(COND_HEAVY_DAMAGE) || + (!GetEnemy() && gpGlobals->curtime - GetEnemies()->LastTimeSeen( AI_UNKNOWN_ENEMY ) < TIME_CARE_ABOUT_DAMAGE ) ) + { + Vector vecEnemyLKP; + + // Fill in where we're trying to look + if ( GetEnemy() ) + { + vecEnemyLKP = GetEnemyLKP(); + } + else + { + if ( GetEnemies()->Find( AI_UNKNOWN_ENEMY ) ) + { + vecEnemyLKP = GetEnemies()->LastKnownPosition( AI_UNKNOWN_ENEMY ); + } + else + { + // Don't have an enemy, so face the direction the last attack came from (don't face north) + vecEnemyLKP = WorldSpaceCenter() + ( g_vecAttackDir * 128 ); + } + } + + // Set the ideal + GetMotor()->SetIdealYawToTarget( vecEnemyLKP ); + + return NPC_STATE_ALERT; + } + + if ( HasCondition(COND_HEAR_DANGER) || + HasCondition(COND_HEAR_COMBAT) || + HasCondition(COND_HEAR_WORLD) || + HasCondition(COND_HEAR_PLAYER) || + HasCondition(COND_HEAR_THUMPER) || + HasCondition(COND_HEAR_BULLET_IMPACT) ) + { + // Interrupted by a sound. So make our ideal yaw the + // source of the sound! + CSound *pSound; + + pSound = GetBestSound(); + Assert( pSound != NULL ); + if ( pSound ) + { + // BRJ 1/7/04: This code used to set the ideal yaw. + // It's really side-effecty to set the yaw here. + // That is now done by the FACE_BESTSOUND schedule. + // Revert this change if it causes problems. + GetMotor()->SetIdealYawToTarget( pSound->GetSoundReactOrigin() ); + if ( pSound->IsSoundType( SOUND_COMBAT | SOUND_DANGER | SOUND_BULLET_IMPACT ) ) + { + return NPC_STATE_ALERT; + } + } + } + + if ( HasInterruptCondition(COND_SMELL) ) + { + return NPC_STATE_ALERT; + } + + return NPC_STATE_INVALID; +} + + +//----------------------------------------------------------------------------- +// Selecting the alert ideal state +//----------------------------------------------------------------------------- +NPC_STATE CAI_BaseNPC::SelectAlertIdealState() +{ + // ALERT goes to IDLE upon becoming bored + // ALERT goes to COMBAT upon sighting an enemy + if ( HasCondition(COND_NEW_ENEMY) || + HasCondition(COND_SEE_ENEMY) || + GetEnemy() != NULL ) + { + return NPC_STATE_COMBAT; + } + + // Set our ideal yaw if we've taken damage + if ( HasCondition(COND_LIGHT_DAMAGE) || + HasCondition(COND_HEAVY_DAMAGE) || + (!GetEnemy() && gpGlobals->curtime - GetEnemies()->LastTimeSeen( AI_UNKNOWN_ENEMY ) < TIME_CARE_ABOUT_DAMAGE ) ) + { + Vector vecEnemyLKP; + + // Fill in where we're trying to look + if ( GetEnemy() ) + { + vecEnemyLKP = GetEnemyLKP(); + } + else + { + if ( GetEnemies()->Find( AI_UNKNOWN_ENEMY ) ) + { + vecEnemyLKP = GetEnemies()->LastKnownPosition( AI_UNKNOWN_ENEMY ); + } + else + { + // Don't have an enemy, so face the direction the last attack came from (don't face north) + vecEnemyLKP = WorldSpaceCenter() + ( g_vecAttackDir * 128 ); + } + } + + // Set the ideal + GetMotor()->SetIdealYawToTarget( vecEnemyLKP ); + + return NPC_STATE_ALERT; + } + + if ( HasCondition(COND_HEAR_DANGER) || + HasCondition(COND_HEAR_COMBAT) ) + { + CSound *pSound = GetBestSound(); + AssertOnce( pSound != NULL ); + + if ( pSound ) + { + GetMotor()->SetIdealYawToTarget( pSound->GetSoundReactOrigin() ); + } + + return NPC_STATE_ALERT; + } + + if ( ShouldGoToIdleState() ) + { + return NPC_STATE_IDLE; + } + + return NPC_STATE_INVALID; +} + + +//----------------------------------------------------------------------------- +// Selecting the alert ideal state +//----------------------------------------------------------------------------- +NPC_STATE CAI_BaseNPC::SelectScriptIdealState() +{ + if ( HasCondition(COND_TASK_FAILED) || + HasCondition(COND_LIGHT_DAMAGE) || + HasCondition(COND_HEAVY_DAMAGE) ) + { + ExitScriptedSequence(); // This will set the ideal state + } + + if ( m_IdealNPCState == NPC_STATE_IDLE ) + { + // Exiting a script. Select the ideal state assuming we were idle now. + m_NPCState = NPC_STATE_IDLE; + NPC_STATE eIdealState = SelectIdealState(); + m_NPCState = NPC_STATE_SCRIPT; + return eIdealState; + } + + return NPC_STATE_INVALID; +} + + +//----------------------------------------------------------------------------- +// Purpose: Surveys the Conditions information available and finds the best +// new state for a npc. +// +// NOTICE the CAI_BaseNPC implementation of this function does not care about +// private conditions! +// +// Output : NPC_STATE - the suggested ideal state based on current conditions. +//----------------------------------------------------------------------------- +NPC_STATE CAI_BaseNPC::SelectIdealState( void ) +{ + // dvs: FIXME: lots of side effecty code in here!! this function should ONLY return an ideal state! + + // --------------------------- + // Do some squad stuff first + // --------------------------- + if (m_pSquad) + { + switch( m_NPCState ) + { + case NPC_STATE_IDLE: + case NPC_STATE_ALERT: + if ( HasCondition ( COND_NEW_ENEMY ) ) + { + m_pSquad->SquadNewEnemy( GetEnemy() ); + } + break; + } + } + + // --------------------------- + // Set ideal state + // --------------------------- + switch ( m_NPCState ) + { + case NPC_STATE_IDLE: + { + NPC_STATE nState = SelectIdleIdealState(); + if ( nState != NPC_STATE_INVALID ) + return nState; + } + break; + + case NPC_STATE_ALERT: + { + NPC_STATE nState = SelectAlertIdealState(); + if ( nState != NPC_STATE_INVALID ) + return nState; + } + break; + + case NPC_STATE_COMBAT: + // COMBAT goes to ALERT upon death of enemy + { + if ( GetEnemy() == NULL ) + { + DevWarning( 2, "***Combat state with no enemy!\n" ); + return NPC_STATE_ALERT; + } + break; + } + case NPC_STATE_SCRIPT: + { + NPC_STATE nState = SelectScriptIdealState(); + if ( nState != NPC_STATE_INVALID ) + return nState; + } + break; + + case NPC_STATE_DEAD: + return NPC_STATE_DEAD; + } + + // The best ideal state is the current ideal state. + return m_IdealNPCState; +} + +//------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ +void CAI_BaseNPC::GiveWeapon( string_t iszWeaponName ) +{ + CBaseCombatWeapon *pWeapon = Weapon_Create( STRING(iszWeaponName) ); + if ( !pWeapon ) + { + Warning( "Couldn't create weapon %s to give NPC %s.\n", STRING(iszWeaponName), STRING(GetEntityName()) ); + return; + } + + // If I have a weapon already, drop it + if ( GetActiveWeapon() ) + { + Weapon_Drop( GetActiveWeapon() ); + } + + // If I have a name, make my weapon match it with "_weapon" appended + if ( GetEntityName() != NULL_STRING ) + { + pWeapon->SetName( AllocPooledString(UTIL_VarArgs("%s_weapon", STRING(GetEntityName()) )) ); + } + + Weapon_Equip( pWeapon ); + + // Handle this case + OnGivenWeapon( pWeapon ); +} + +//----------------------------------------------------------------------------- +// Rather specific function that tells us if an NPC is in the process of +// moving to a weapon with the intent to pick it up. +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::IsMovingToPickupWeapon() +{ + return IsCurSchedule( SCHED_NEW_WEAPON ); +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::ShouldLookForBetterWeapon() +{ + if( m_flNextWeaponSearchTime > gpGlobals->curtime ) + return false; + + if( !(CapabilitiesGet() & bits_CAP_USE_WEAPONS) ) + return false; + + // Already armed and currently fighting. Don't try to upgrade. + if( GetActiveWeapon() && m_NPCState == NPC_STATE_COMBAT ) + return false; + + if( IsMovingToPickupWeapon() ) + return false; + + if( !IsPlayerAlly() && GetActiveWeapon() ) + return false; + + if( IsInAScript() ) + return false; + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: Check if a better weapon is available. +// For now check if there is a weapon and I don't have one. In +// the future +// UNDONE: actually rate the weapons based on there strength +// Input : +// Output : +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::Weapon_IsBetterAvailable() +{ + if( m_iszPendingWeapon != NULL_STRING ) + { + // Some weapon is reserved for us. + return true; + } + + if( ShouldLookForBetterWeapon() ) + { + if( GetActiveWeapon() ) + { + m_flNextWeaponSearchTime = gpGlobals->curtime + 2; + } + else + { + if( IsInPlayerSquad() ) + { + // Look for a weapon frequently. + m_flNextWeaponSearchTime = gpGlobals->curtime + 1; + } + else + { + m_flNextWeaponSearchTime = gpGlobals->curtime + 2; + } + } + + if ( Weapon_FindUsable( WEAPON_SEARCH_DELTA ) ) + { + return true; + } + } + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: Returns true is weapon has a line of sight. If bSetConditions is +// true, also sets LOC conditions +// Input : +// Output : +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::WeaponLOSCondition(const Vector &ownerPos, const Vector &targetPos, bool bSetConditions ) +{ +#if 0 + // @TODO (toml 03-07-04): this code might be better (not tested) + Vector vecLocalRelativePosition; + VectorITransform( npcOwner->Weapon_ShootPosition(), npcOwner->EntityToWorldTransform(), vecLocalRelativePosition ); + + // Compute desired test transform + + // Compute desired x axis + Vector xaxis; + VectorSubtract( targetPos, ownerPos, xaxis ); + + // FIXME: Insert angle test here? + float flAngle = acos( xaxis.z / xaxis.Length() ); + + xaxis.z = 0.0f; + float flLength = VectorNormalize( xaxis ); + if ( flLength < 1e-3 ) + return false; + + Vector yaxis( -xaxis.y, xaxis.x, 0.0f ); + + matrix3x4_t losTestToWorld; + MatrixInitialize( losTestToWorld, ownerPos, xaxis, yaxis, zaxis ); + + Vector barrelPos; + VectorTransform( vecLocalRelativePosition, losTestToWorld, barrelPos ); + +#endif + + bool bHaveLOS = true; + + if (GetActiveWeapon()) + { + bHaveLOS = GetActiveWeapon()->WeaponLOSCondition(ownerPos, targetPos, bSetConditions); + } + else if (CapabilitiesGet() & bits_CAP_INNATE_RANGE_ATTACK1) + { + bHaveLOS = InnateWeaponLOSCondition(ownerPos, targetPos, bSetConditions); + } + else + { + if (bSetConditions) + { + SetCondition( COND_NO_WEAPON ); + } + bHaveLOS = false; + } + // ------------------------------------------- + // Check for friendly fire with the player + // ------------------------------------------- + if ( CapabilitiesGet() & ( bits_CAP_NO_HIT_PLAYER | bits_CAP_NO_HIT_SQUADMATES ) ) + { + float spread = 0.92f; + if ( GetActiveWeapon() ) + { + Vector vSpread = GetAttackSpread( GetActiveWeapon() ); + if ( vSpread.x > VECTOR_CONE_15DEGREES.x ) + spread = FastCos( asin(vSpread.x) ); + else // too much error because using point not box + spread = 0.99145f; // "15 degrees" + } + if ( CapabilitiesGet() & bits_CAP_NO_HIT_PLAYER) + { + // Check shoot direction relative to player + if (PlayerInSpread( ownerPos, targetPos, spread, 8*12 )) + { + if (bSetConditions) + { + SetCondition( COND_WEAPON_PLAYER_IN_SPREAD ); + } + bHaveLOS = false; + } + /* For grenades etc. check that player is clear? + // Check player position also + if (PlayerInRange( targetPos, 100 )) + { + SetCondition( COND_WEAPON_PLAYER_NEAR_TARGET ); + } + */ + } + + if ( bHaveLOS ) + { + if ( ( CapabilitiesGet() & bits_CAP_NO_HIT_SQUADMATES) && m_pSquad && GetEnemy() ) + { + if ( IsSquadmateInSpread( ownerPos, targetPos, spread, 8*12 ) ) + { + SetCondition( COND_WEAPON_BLOCKED_BY_FRIEND ); + bHaveLOS = false; + } + } + } + } + return bHaveLOS; +} + +//----------------------------------------------------------------------------- +// Purpose: Check the innate weapon LOS for an owner at an arbitrary position +// If bSetConditions is true, LOS related conditions will also be set +// Input : +// Output : +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::InnateWeaponLOSCondition( const Vector &ownerPos, const Vector &targetPos, bool bSetConditions ) +{ + // -------------------- + // Check for occlusion + // -------------------- + // Base class version assumes innate weapon position is at eye level + Vector barrelPos = ownerPos + GetViewOffset(); + trace_t tr; + AI_TraceLine( barrelPos, targetPos, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr); + + if ( tr.fraction == 1.0 ) + { + return true; + } + + CBaseEntity *pHitEntity = tr.m_pEnt; + + // Translate a hit vehicle into its passenger if found + if ( GetEnemy() != NULL ) + { + CBaseCombatCharacter *pCCEnemy = GetEnemy()->MyCombatCharacterPointer(); + if ( pCCEnemy != NULL && pCCEnemy->IsInAVehicle() ) + { + // Ok, player in vehicle, check if vehicle is target we're looking at, fire if it is + // Also, check to see if the owner of the entity is the vehicle, in which case it's valid too. + // This catches vehicles that use bone followers. + CBaseEntity *pVehicleEnt = pCCEnemy->GetVehicleEntity(); + if ( pHitEntity == pVehicleEnt || pHitEntity->GetOwnerEntity() == pVehicleEnt ) + return true; + } + } + + if ( pHitEntity == GetEnemy() ) + { + return true; + } + else if ( pHitEntity && pHitEntity->MyCombatCharacterPointer() ) + { + if (IRelationType( pHitEntity ) == D_HT) + { + return true; + } + else if (bSetConditions) + { + SetCondition(COND_WEAPON_BLOCKED_BY_FRIEND); + } + } + else if (bSetConditions) + { + SetCondition(COND_WEAPON_SIGHT_OCCLUDED); + SetEnemyOccluder(tr.m_pEnt); + } + + return false; +} + +//========================================================= +// CanCheckAttacks - prequalifies a npc to do more fine +// checking of potential attacks. +//========================================================= +bool CAI_BaseNPC::FCanCheckAttacks( void ) +{ + // Not allowed to check attacks while climbing or jumping + // Otherwise schedule is interrupted while on ladder/etc + // which is NOT a legal place to attack from + if ( GetNavType() == NAV_CLIMB || GetNavType() == NAV_JUMP ) + return false; + + if ( HasCondition(COND_SEE_ENEMY) && !HasCondition( COND_ENEMY_TOO_FAR)) + { + return true; + } + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: Return dist. to enemy (closest of origin/head/feet) +// Input : +// Output : +//----------------------------------------------------------------------------- +float CAI_BaseNPC::EnemyDistance( CBaseEntity *pEnemy ) +{ + Vector enemyDelta = pEnemy->WorldSpaceCenter() - WorldSpaceCenter(); + + // NOTE: We ignore rotation for computing height. Assume it isn't an effect + // we care about, so we simply use OBBSize().z for height. + // Otherwise you'd do this: + // pEnemy->CollisionProp()->WorldSpaceSurroundingBounds( &enemyMins, &enemyMaxs ); + // float enemyHeight = enemyMaxs.z - enemyMins.z; + + float enemyHeight = pEnemy->CollisionProp()->OBBSize().z; + float myHeight = CollisionProp()->OBBSize().z; + + // max distance our centers can be apart with the boxes still overlapping + float flMaxZDist = ( enemyHeight + myHeight ) * 0.5f; + + // see if the enemy is closer to my head, feet or in between + if ( enemyDelta.z > flMaxZDist ) + { + // enemy feet above my head, compute distance from my head to his feet + enemyDelta.z -= flMaxZDist; + } + else if ( enemyDelta.z < -flMaxZDist ) + { + // enemy head below my feet, return distance between my feet and his head + enemyDelta.z += flMaxZDist; + } + else + { + // boxes overlap in Z, no delta + enemyDelta.z = 0; + } + + return enemyDelta.Length(); +} + +//----------------------------------------------------------------------------- + +float CAI_BaseNPC::GetReactionDelay( CBaseEntity *pEnemy ) +{ + return ( m_NPCState == NPC_STATE_ALERT || m_NPCState == NPC_STATE_COMBAT ) ? + ai_reaction_delay_alert.GetFloat() : + ai_reaction_delay_idle.GetFloat(); +} + +//----------------------------------------------------------------------------- +// Purpose: Update information on my enemy +// Input : +// Output : Returns true is new enemy, false is known enemy +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::UpdateEnemyMemory( CBaseEntity *pEnemy, const Vector &position, CBaseEntity *pInformer ) +{ + bool firstHand = ( pInformer == NULL || pInformer == this ); + + AI_PROFILE_SCOPE(CAI_BaseNPC_UpdateEnemyMemory); + + if ( GetEnemies() ) + { + // If the was eluding me and allow the NPC to play a sound + if (GetEnemies()->HasEludedMe(pEnemy)) + { + FoundEnemySound(); + } + float reactionDelay = ( !pInformer || pInformer == this ) ? GetReactionDelay( pEnemy ) : 0.0; + bool result = GetEnemies()->UpdateMemory(GetNavigator()->GetNetwork(), pEnemy, position, reactionDelay, firstHand); + + if ( !firstHand && pEnemy && result && GetState() == NPC_STATE_IDLE ) // if it's a new potential enemy + ForceDecisionThink(); + + if ( firstHand && pEnemy && m_pSquad ) + { + m_pSquad->UpdateEnemyMemory( this, pEnemy, position ); + } + return result; + } + return true; +} + + +//----------------------------------------------------------------------------- +// Purpose: Remembers the thing my enemy is hiding behind. Called when either +// COND_ENEMY_OCCLUDED or COND_WEAPON_SIGHT_OCCLUDED is set. +//----------------------------------------------------------------------------- +void CAI_BaseNPC::SetEnemyOccluder(CBaseEntity *pBlocker) +{ + m_hEnemyOccluder = pBlocker; +} + + +//----------------------------------------------------------------------------- +// Purpose: Gets the thing my enemy is hiding behind (assuming they are hiding). +//----------------------------------------------------------------------------- +CBaseEntity *CAI_BaseNPC::GetEnemyOccluder(void) +{ + return m_hEnemyOccluder.Get(); +} + + +//----------------------------------------------------------------------------- +// Purpose: part of the Condition collection process +// gets and stores data and conditions pertaining to a npc's +// enemy. +// @TODO (toml 07-27-03): this should become subservient to the senses. right +// now, it yields different result +// Input : +// Output : +//----------------------------------------------------------------------------- +void CAI_BaseNPC::GatherEnemyConditions( CBaseEntity *pEnemy ) +{ + AI_PROFILE_SCOPE(CAI_BaseNPC_GatherEnemyConditions); + + ClearCondition( COND_ENEMY_FACING_ME ); + ClearCondition( COND_BEHIND_ENEMY ); + + // --------------------------- + // Set visibility conditions + // --------------------------- + if ( HasCondition( COND_NEW_ENEMY ) || GetSenses()->GetTimeLastUpdate( GetEnemy() ) == gpGlobals->curtime ) + { + AI_PROFILE_SCOPE_BEGIN(CAI_BaseNPC_GatherEnemyConditions_Visibility); + + ClearCondition( COND_HAVE_ENEMY_LOS ); + ClearCondition( COND_ENEMY_OCCLUDED ); + + CBaseEntity *pBlocker = NULL; + SetEnemyOccluder(NULL); + + bool bSensesDidSee = GetSenses()->DidSeeEntity( pEnemy ); + + if ( !bSensesDidSee && ( ( EnemyDistance( pEnemy ) >= GetSenses()->GetDistLook() ) || !FVisible( pEnemy, MASK_BLOCKLOS, &pBlocker ) ) ) + { + // No LOS to enemy + SetEnemyOccluder(pBlocker); + SetCondition( COND_ENEMY_OCCLUDED ); + ClearCondition( COND_SEE_ENEMY ); + + if (HasMemory( bits_MEMORY_HAD_LOS )) + { + AI_PROFILE_SCOPE(CAI_BaseNPC_GatherEnemyConditions_Outputs); + // Send output event + if (GetEnemy()->IsPlayer()) + { + m_OnLostPlayerLOS.FireOutput( GetEnemy(), this ); + } + m_OnLostEnemyLOS.FireOutput( GetEnemy(), this ); + } + Forget( bits_MEMORY_HAD_LOS ); + } + else + { + // Have LOS but may not be in view cone + SetCondition( COND_HAVE_ENEMY_LOS ); + + if ( bSensesDidSee ) + { + // Have LOS and in view cone + SetCondition( COND_SEE_ENEMY ); + } + else + { + ClearCondition( COND_SEE_ENEMY ); + } + + if (!HasMemory( bits_MEMORY_HAD_LOS )) + { + AI_PROFILE_SCOPE(CAI_BaseNPC_GatherEnemyConditions_Outputs); + // Send output event + EHANDLE hEnemy; + hEnemy.Set( GetEnemy() ); + + if (GetEnemy()->IsPlayer()) + { + m_OnFoundPlayer.Set(hEnemy, this, this); + m_OnFoundEnemy.Set(hEnemy, this, this); + } + else + { + m_OnFoundEnemy.Set(hEnemy, this, this); + } + } + Remember( bits_MEMORY_HAD_LOS ); + } + + AI_PROFILE_SCOPE_END(); + } + + // ------------------- + // If enemy is dead + // ------------------- + if ( !pEnemy->IsAlive() ) + { + SetCondition( COND_ENEMY_DEAD ); + ClearCondition( COND_SEE_ENEMY ); + ClearCondition( COND_ENEMY_OCCLUDED ); + return; + } + + float flDistToEnemy = EnemyDistance(pEnemy); + + AI_PROFILE_SCOPE_BEGIN(CAI_BaseNPC_GatherEnemyConditions_SeeEnemy); + + if ( HasCondition( COND_SEE_ENEMY ) ) + { + // Trail the enemy a bit if he's moving + if (pEnemy->GetSmoothedVelocity() != vec3_origin) + { + Vector vTrailPos = pEnemy->GetAbsOrigin() - pEnemy->GetSmoothedVelocity() * random->RandomFloat( -0.05, 0 ); + UpdateEnemyMemory(pEnemy,vTrailPos); + } + else + { + UpdateEnemyMemory(pEnemy,pEnemy->GetAbsOrigin()); + } + + // If it's not an NPC, assume it can't see me + if ( pEnemy->MyCombatCharacterPointer() && pEnemy->MyCombatCharacterPointer()->FInViewCone ( this ) ) + { + SetCondition ( COND_ENEMY_FACING_ME ); + ClearCondition ( COND_BEHIND_ENEMY ); + } + else + { + ClearCondition( COND_ENEMY_FACING_ME ); + SetCondition ( COND_BEHIND_ENEMY ); + } + } + else if ( (!HasCondition(COND_ENEMY_OCCLUDED) && !HasCondition(COND_SEE_ENEMY)) && ( flDistToEnemy <= 256 ) ) + { + // if the enemy is not occluded, and unseen, that means it is behind or beside the npc. + // if the enemy is near enough the npc, we go ahead and let the npc know where the + // enemy is. Send the enemy in as the informer so this knowledge will be regarded as + // secondhand so that the NPC doesn't + UpdateEnemyMemory( pEnemy, pEnemy->GetAbsOrigin(), pEnemy ); + } + + AI_PROFILE_SCOPE_END(); + + float tooFar = m_flDistTooFar; + if ( GetActiveWeapon() && HasCondition(COND_SEE_ENEMY) ) + { + tooFar = MAX( m_flDistTooFar, GetActiveWeapon()->m_fMaxRange1 ); + } + + if ( flDistToEnemy >= tooFar ) + { + // enemy is very far away from npc + SetCondition( COND_ENEMY_TOO_FAR ); + } + else + { + ClearCondition( COND_ENEMY_TOO_FAR ); + } + + if ( FCanCheckAttacks() ) + { + // This may also call SetEnemyOccluder! + GatherAttackConditions( GetEnemy(), flDistToEnemy ); + } + else + { + ClearAttackConditions(); + } + + // If my enemy has moved significantly, or if the enemy has changed update my path + UpdateEnemyPos(); + + // If my target entity has moved significantly, update my path + // This is an odd place to put this, but where else should it go? + UpdateTargetPos(); + + // ---------------------------------------------------------------------------- + // Check if enemy is reachable via the node graph unless I'm not on a network + // ---------------------------------------------------------------------------- + if (GetNavigator()->IsOnNetwork()) + { + // Note that unreachablity times out + if (IsUnreachable(GetEnemy())) + { + SetCondition(COND_ENEMY_UNREACHABLE); + } + } + + //----------------------------------------------------------------------- + // If I haven't seen the enemy in a while he may have eluded me + //----------------------------------------------------------------------- + if (gpGlobals->curtime - GetEnemyLastTimeSeen() > 8) + { + //----------------------------------------------------------------------- + // I'm at last known position at enemy isn't in sight then has eluded me + // ---------------------------------------------------------------------- + Vector flEnemyLKP = GetEnemyLKP(); + if (((flEnemyLKP - GetAbsOrigin()).Length2D() < 48) && + !HasCondition(COND_SEE_ENEMY)) + { + MarkEnemyAsEluded(); + } + //------------------------------------------------------------------- + // If enemy isn't reachable, I can see last known position and enemy + // isn't there, then he has eluded me + // ------------------------------------------------------------------ + if (!HasCondition(COND_SEE_ENEMY) && HasCondition(COND_ENEMY_UNREACHABLE)) + { + if ( !FVisible( flEnemyLKP ) ) + { + MarkEnemyAsEluded(); + } + } + } +} + + +//----------------------------------------------------------------------------- +// In the case of goaltype enemy, update the goal position +//----------------------------------------------------------------------------- +float CAI_BaseNPC::GetGoalRepathTolerance( CBaseEntity *pGoalEnt, GoalType_t type, const Vector &curGoal, const Vector &curTargetPos ) +{ + float distToGoal = ( GetAbsOrigin() - curTargetPos ).Length() - GetNavigator()->GetArrivalDistance(); + float distMoved1Sec = GetSmoothedVelocity().Length(); + float result = 120; // FIXME: why 120? + + if (distMoved1Sec > 0.0) + { + float t = distToGoal / distMoved1Sec; + + result = clamp( 120.f * t, 0.f, 120.f ); + // Msg("t %.2f : d %.0f (%.0f)\n", t, result, distMoved1Sec ); + } + + if ( !pGoalEnt->IsPlayer() ) + result *= 1.20; + + return result; +} + +//----------------------------------------------------------------------------- +// In the case of goaltype enemy, update the goal position +//----------------------------------------------------------------------------- +void CAI_BaseNPC::UpdateEnemyPos() +{ + // Don't perform path recomputations during a climb or a jump + if ( !GetNavigator()->IsInterruptable() ) + return; + + if ( m_AnyUpdateEnemyPosTimer.Expired() && m_UpdateEnemyPosTimer.Expired() ) + { + // FIXME: does GetGoalRepathTolerance() limit re-routing enough to remove this? + // m_UpdateEnemyPosTimer.Set( 0.5, 1.0 ); + + // If my enemy has moved significantly, or if the enemy has changed update my path + if ( GetNavigator()->GetGoalType() == GOALTYPE_ENEMY ) + { + if (m_hEnemy != GetNavigator()->GetGoalTarget()) + { + GetNavigator()->SetGoalTarget( m_hEnemy, vec3_origin ); + } + else + { + Vector vEnemyLKP = GetEnemyLKP(); + TranslateNavGoal( GetEnemy(), vEnemyLKP ); + float tolerance = GetGoalRepathTolerance( GetEnemy(), GOALTYPE_ENEMY, GetNavigator()->GetGoalPos(), vEnemyLKP); + if ( (GetNavigator()->GetGoalPos() - vEnemyLKP).Length() > tolerance ) + { + // FIXME: when fleeing crowds, won't this severely limit the effectiveness of each individual? Shouldn't this be a mutex that's held for some period so that at least one attacker is effective? + m_AnyUpdateEnemyPosTimer.Set( 0.1 ); // FIXME: what's a reasonable interval? + if ( !GetNavigator()->RefindPathToGoal( false ) ) + { + TaskFail( FAIL_NO_ROUTE ); + } + } + } + } + } +} + + +//----------------------------------------------------------------------------- +// In the case of goaltype targetent, update the goal position +//----------------------------------------------------------------------------- +void CAI_BaseNPC::UpdateTargetPos() +{ + // BRJ 10/7/02 + // FIXME: make this check time based instead of distance based! + + // Don't perform path recomputations during a climb or a jump + if ( !GetNavigator()->IsInterruptable() ) + return; + + // If my target entity has moved significantly, or has changed, update my path + // This is an odd place to put this, but where else should it go? + if ( GetNavigator()->GetGoalType() == GOALTYPE_TARGETENT ) + { + if (m_hTargetEnt != GetNavigator()->GetGoalTarget()) + { + GetNavigator()->SetGoalTarget( m_hTargetEnt, vec3_origin ); + } + else if ( GetNavigator()->GetGoalFlags() & AIN_UPDATE_TARGET_POS ) + { + if ( GetTarget() == NULL || (GetNavigator()->GetGoalPos() - GetTarget()->GetAbsOrigin()).Length() > GetGoalRepathTolerance( GetTarget(), GOALTYPE_TARGETENT, GetNavigator()->GetGoalPos(), GetTarget()->GetAbsOrigin()) ) + { + if ( !GetNavigator()->RefindPathToGoal( false ) ) + { + TaskFail( FAIL_NO_ROUTE ); + } + } + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: part of the Condition collection process +// gets and stores data and conditions pertaining to a npc's +// enemy. +// Input : +// Output : +//----------------------------------------------------------------------------- +void CAI_BaseNPC::CheckTarget( CBaseEntity *pTarget ) +{ + AI_PROFILE_SCOPE(CAI_Enemies_CheckTarget); + + ClearCondition ( COND_HAVE_TARGET_LOS ); + ClearCondition ( COND_TARGET_OCCLUDED ); + + // --------------------------- + // Set visibility conditions + // --------------------------- + if ( ( EnemyDistance( pTarget ) >= GetSenses()->GetDistLook() ) || !FVisible( pTarget ) ) + { + // No LOS to target + SetCondition( COND_TARGET_OCCLUDED ); + } + else + { + // Have LOS (may not be in view cone) + SetCondition( COND_HAVE_TARGET_LOS ); + } + + UpdateTargetPos(); +} + +//----------------------------------------------------------------------------- +// Purpose: Creates a bullseye of limited lifespan at the provided position +// Input : vecOrigin - Where to create the bullseye +// duration - The lifespan of the bullseye +// Output : A BaseNPC pointer to the bullseye +// +// NOTES : It is the caller's responsibility to set up relationships with +// this bullseye! +//----------------------------------------------------------------------------- +CAI_BaseNPC *CAI_BaseNPC::CreateCustomTarget( const Vector &vecOrigin, float duration ) +{ +#ifdef HL2_DLL + CNPC_Bullseye *pTarget = (CNPC_Bullseye*)CreateEntityByName( "npc_bullseye" ); + + ASSERT( pTarget != NULL ); + + // Build a nonsolid bullseye and place it in the desired location + // The bullseye must take damage or the SetHealth 0 call will not be able + pTarget->AddSpawnFlags( SF_BULLSEYE_NONSOLID ); + pTarget->SetAbsOrigin( vecOrigin ); + pTarget->Spawn(); + + // Set it up to remove itself, unless told to be infinite (-1) + if( duration > -1 ) + { + variant_t value; + value.SetFloat(0); + g_EventQueue.AddEvent( pTarget, "SetHealth", value, duration, this, this ); + } + + return pTarget; +#else + return NULL; +#endif// HL2_DLL +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : eNewActivity - +// Output : Activity +//----------------------------------------------------------------------------- +Activity CAI_BaseNPC::NPC_TranslateActivity( Activity eNewActivity ) +{ + Assert( eNewActivity != ACT_INVALID ); + + if (eNewActivity == ACT_RANGE_ATTACK1) + { + if ( IsCrouching() ) + { + eNewActivity = ACT_RANGE_ATTACK1_LOW; + } + } + else if (eNewActivity == ACT_RELOAD) + { + if (IsCrouching()) + { + eNewActivity = ACT_RELOAD_LOW; + } + } + else if ( eNewActivity == ACT_IDLE ) + { + if ( IsCrouching() ) + { + eNewActivity = ACT_CROUCHIDLE; + } + } + // ==== + // HACK : LEIPZIG 06 - The underlying problem is that the AR2 and SMG1 cannot map IDLE_ANGRY to a crouched equivalent automatically + // which causes the character to pop up and down in their idle state of firing while crouched. -- jdw + else if ( eNewActivity == ACT_IDLE_ANGRY_SMG1 ) + { + if ( IsCrouching() ) + { + eNewActivity = ACT_RANGE_AIM_LOW; + } + } + // ==== + + if (CapabilitiesGet() & bits_CAP_DUCK) + { + if (eNewActivity == ACT_RELOAD) + { + return GetReloadActivity(GetHintNode()); + } + else if ((eNewActivity == ACT_COVER ) || + (eNewActivity == ACT_IDLE && HasMemory(bits_MEMORY_INCOVER))) + { + Activity nCoverActivity = GetCoverActivity(GetHintNode()); + // --------------------------------------------------------------- + // Some NPCs don't have a cover activity defined so just use idle + // --------------------------------------------------------------- + if (SelectWeightedSequence( nCoverActivity ) == ACTIVITY_NOT_AVAILABLE) + { + nCoverActivity = ACT_IDLE; + } + + return nCoverActivity; + } + } + return eNewActivity; +} + + +//----------------------------------------------------------------------------- + +Activity CAI_BaseNPC::TranslateActivity( Activity idealActivity, Activity *pIdealWeaponActivity ) +{ + const int MAX_TRIES = 5; + int count = 0; + + bool bIdealWeaponRequired = false; + Activity idealWeaponActivity; + Activity baseTranslation; + bool bWeaponRequired = false; + Activity weaponTranslation; + Activity last; + Activity current; + + idealWeaponActivity = Weapon_TranslateActivity( idealActivity, &bIdealWeaponRequired ); + if ( pIdealWeaponActivity ) + *pIdealWeaponActivity = idealWeaponActivity; + + baseTranslation = idealActivity; + weaponTranslation = idealActivity; + last = idealActivity; + while ( count++ < MAX_TRIES ) + { + current = NPC_TranslateActivity( last ); + if ( current != last ) + baseTranslation = current; + + weaponTranslation = Weapon_TranslateActivity( current, &bWeaponRequired ); + + if ( weaponTranslation == last ) + break; + + last = weaponTranslation; + } + AssertMsg( count < MAX_TRIES, "Circular activity translation!" ); + + if ( last == ACT_SCRIPT_CUSTOM_MOVE ) + return ACT_SCRIPT_CUSTOM_MOVE; + + if ( HaveSequenceForActivity( weaponTranslation ) ) + return weaponTranslation; + + if ( bWeaponRequired ) + { + // only complain about an activity once + static CUtlVector< Activity > sUniqueActivities; + + if (!sUniqueActivities.Find( weaponTranslation)) + { + // FIXME: warning + DevWarning( "%s missing activity \"%s\" needed by weapon\"%s\"\n", + GetClassname(), GetActivityName( weaponTranslation ), GetActiveWeapon()->GetClassname() ); + + sUniqueActivities.AddToTail( weaponTranslation ); + } + } + + if ( baseTranslation != weaponTranslation && HaveSequenceForActivity( baseTranslation ) ) + return baseTranslation; + + if ( idealWeaponActivity != baseTranslation && HaveSequenceForActivity( idealWeaponActivity ) ) + return idealActivity; + + if ( idealActivity != idealWeaponActivity && HaveSequenceForActivity( idealActivity ) ) + return idealActivity; + + Assert( !HaveSequenceForActivity( idealActivity ) ); + if ( idealActivity == ACT_RUN ) + { + idealActivity = ACT_WALK; + } + else if ( idealActivity == ACT_WALK ) + { + idealActivity = ACT_RUN; + } + + return idealActivity; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : NewActivity - +// iSequence - +// translatedActivity - +// weaponActivity - +//----------------------------------------------------------------------------- +void CAI_BaseNPC::ResolveActivityToSequence(Activity NewActivity, int &iSequence, Activity &translatedActivity, Activity &weaponActivity) +{ + AI_PROFILE_SCOPE( CAI_BaseNPC_ResolveActivityToSequence ); + + iSequence = ACTIVITY_NOT_AVAILABLE; + + translatedActivity = TranslateActivity( NewActivity, &weaponActivity ); + + if ( NewActivity == ACT_SCRIPT_CUSTOM_MOVE ) + { + iSequence = GetScriptCustomMoveSequence(); + } + else + { + iSequence = SelectWeightedSequence( translatedActivity ); + + if ( iSequence == ACTIVITY_NOT_AVAILABLE ) + { + static CAI_BaseNPC *pLastWarn; + static Activity lastWarnActivity; + static float timeLastWarn; + + if ( ( pLastWarn != this && lastWarnActivity != translatedActivity ) || gpGlobals->curtime - timeLastWarn > 5.0 ) + { + DevWarning( "%s:%s:%s has no sequence for act:%s\n", GetClassname(), GetDebugName(), STRING( GetModelName() ), ActivityList_NameForIndex(translatedActivity) ); + pLastWarn = this; + lastWarnActivity = translatedActivity; + timeLastWarn = gpGlobals->curtime; + } + + if ( translatedActivity == ACT_RUN ) + { + translatedActivity = ACT_WALK; + iSequence = SelectWeightedSequence( translatedActivity ); + } + } + } + + if ( iSequence == ACT_INVALID ) + { + // Abject failure. Use sequence zero. + iSequence = 0; + } +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Input : NewActivity - +// iSequence - +// translatedActivity - +// weaponActivity - +//----------------------------------------------------------------------------- +extern ConVar ai_sequence_debug; + +void CAI_BaseNPC::SetActivityAndSequence(Activity NewActivity, int iSequence, Activity translatedActivity, Activity weaponActivity) +{ + m_translatedActivity = translatedActivity; + + if (ai_sequence_debug.GetBool() == true && (m_debugOverlays & OVERLAY_NPC_SELECTED_BIT)) + { + DevMsg("SetActivityAndSequence : %s: %s:%s -> %s:%s / %s:%s\n", GetClassname(), + GetActivityName(GetActivity()), GetSequenceName(GetSequence()), + GetActivityName(NewActivity), GetSequenceName(iSequence), + GetActivityName(translatedActivity), GetActivityName(weaponActivity) ); + + } + + // Set to the desired anim, or default anim if the desired is not present + if ( iSequence > ACTIVITY_NOT_AVAILABLE ) + { + if ( GetSequence() != iSequence || !SequenceLoops() ) + { + // + // Don't reset frame between movement phased animations + if (!IsActivityMovementPhased( m_Activity ) || + !IsActivityMovementPhased( NewActivity )) + { + SetCycle( 0 ); + } + } + + ResetSequence( iSequence ); + Weapon_SetActivity( weaponActivity, SequenceDuration( iSequence ) ); + } + else + { + // Not available try to get default anim + ResetSequence( 0 ); + } + + // Set the view position based on the current activity + SetViewOffset( EyeOffset(m_translatedActivity) ); + + if (m_Activity != NewActivity) + { + OnChangeActivity(NewActivity); + } + + // NOTE: We DO NOT write the translated activity here. + // This is to abstract the activity translation from the AI code. + // As far as the code is concerned, a translation is merely a new set of sequences + // that should be regarded as the activity in question. + + // Go ahead and set this so it doesn't keep trying when the anim is not present + m_Activity = NewActivity; + + // this cannot be called until m_Activity stores NewActivity! + GetMotor()->RecalculateYawSpeed(); +} + + +//----------------------------------------------------------------------------- +// Purpose: Sets the activity to the desired activity immediately, skipping any +// transition sequences. +// Input : NewActivity - +//----------------------------------------------------------------------------- +void CAI_BaseNPC::SetActivity( Activity NewActivity ) +{ + // If I'm already doing the NewActivity I can bail. + // FIXME: Should this be based on the current translated activity and ideal translated activity (calculated below)? + // The old code only cared about the logical activity, not translated. + + if (m_Activity == NewActivity) + { + return; + } + + // Don't do this if I'm playing a transition, unless it's ACT_RESET. + if ( NewActivity != ACT_RESET && m_Activity == ACT_TRANSITION && m_IdealActivity != ACT_DO_NOT_DISTURB ) + { + return; + } + + if (ai_sequence_debug.GetBool() == true && (m_debugOverlays & OVERLAY_NPC_SELECTED_BIT)) + { + DevMsg("SetActivity : %s: %s -> %s\n", GetClassname(), GetActivityName(GetActivity()), GetActivityName(NewActivity)); + } + + if ( !GetModelPtr() ) + return; + + // In case someone calls this with something other than the ideal activity. + m_IdealActivity = NewActivity; + + // Resolve to ideals and apply directly, skipping transitions. + ResolveActivityToSequence(m_IdealActivity, m_nIdealSequence, m_IdealTranslatedActivity, m_IdealWeaponActivity); + + //DevMsg("%s: SLAM %s -> %s\n", GetClassname(), GetSequenceName(GetSequence()), GetSequenceName(m_nIdealSequence)); + + SetActivityAndSequence(m_IdealActivity, m_nIdealSequence, m_IdealTranslatedActivity, m_IdealWeaponActivity); +} + + +//----------------------------------------------------------------------------- +// Purpose: Sets the activity that we would like to transition toward. +// Input : NewActivity - +//----------------------------------------------------------------------------- +void CAI_BaseNPC::SetIdealActivity( Activity NewActivity ) +{ + // ignore if it's an ACT_TRANSITION, it means somewhere we're setting IdealActivity with a bogus intermediate value + if (NewActivity == ACT_TRANSITION) + { + Assert( 0 ); + return; + } + + if (ai_sequence_debug.GetBool() == true && (m_debugOverlays & OVERLAY_NPC_SELECTED_BIT)) + { + DevMsg("SetIdealActivity : %s: %s -> %s\n", GetClassname(), GetActivityName(GetActivity()), GetActivityName(NewActivity)); + } + + + if (NewActivity == ACT_RESET) + { + // They probably meant to call SetActivity(ACT_RESET)... we'll fix it for them. + SetActivity(ACT_RESET); + return; + } + + m_IdealActivity = NewActivity; + + if( NewActivity == ACT_DO_NOT_DISTURB ) + { + // Don't resolve anything! Leave it the way the user has it right now. + return; + } + + if ( !GetModelPtr() ) + return; + + // Perform translation in case we need to change sequences within a single activity, + // such as between a standing idle and a crouching idle. + ResolveActivityToSequence(m_IdealActivity, m_nIdealSequence, m_IdealTranslatedActivity, m_IdealWeaponActivity); +} + + +//----------------------------------------------------------------------------- +// Purpose: Moves toward the ideal activity through any transition sequences. +//----------------------------------------------------------------------------- +void CAI_BaseNPC::AdvanceToIdealActivity(void) +{ + // If there is a transition sequence between the current sequence and the ideal sequence... + int nNextSequence = FindTransitionSequence(GetSequence(), m_nIdealSequence, NULL); + if (nNextSequence != -1) + { + // We found a transition sequence or possibly went straight to + // the ideal sequence. + if (nNextSequence != m_nIdealSequence) + { +// DevMsg("%s: TRANSITION %s -> %s -> %s\n", GetClassname(), GetSequenceName(GetSequence()), GetSequenceName(nNextSequence), GetSequenceName(m_nIdealSequence)); + + Activity eWeaponActivity = ACT_TRANSITION; + Activity eTranslatedActivity = ACT_TRANSITION; + + // Figure out if the transition sequence has an associated activity that + // we can use for our weapon. Do activity translation also. + Activity eTransitionActivity = GetSequenceActivity(nNextSequence); + if (eTransitionActivity != ACT_INVALID) + { + int nDiscard; + ResolveActivityToSequence(eTransitionActivity, nDiscard, eTranslatedActivity, eWeaponActivity); + } + + // Set activity and sequence to the transition stuff. Set the activity to ACT_TRANSITION + // so we know we're in a transition. + SetActivityAndSequence(ACT_TRANSITION, nNextSequence, eTranslatedActivity, eWeaponActivity); + } + else + { + //DevMsg("%s: IDEAL %s -> %s\n", GetClassname(), GetSequenceName(GetSequence()), GetSequenceName(m_nIdealSequence)); + + // Set activity and sequence to the ideal stuff that was set up in MaintainActivity. + SetActivityAndSequence(m_IdealActivity, m_nIdealSequence, m_IdealTranslatedActivity, m_IdealWeaponActivity); + } + } + // Else go straight there to the ideal activity. + else + { + //DevMsg("%s: Unable to get from sequence %s to %s!\n", GetClassname(), GetSequenceName(GetSequence()), GetSequenceName(m_nIdealSequence)); + SetActivity(m_IdealActivity); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Tries to achieve our ideal animation state, playing any transition +// sequences that we need to play to get there. +//----------------------------------------------------------------------------- +void CAI_BaseNPC::MaintainActivity(void) +{ + AI_PROFILE_SCOPE( CAI_BaseNPC_MaintainActivity ); + + if ( m_lifeState == LIFE_DEAD ) + { + // Don't maintain activities if we're daid. + // Blame Speyrer + return; + } + + if ((GetState() == NPC_STATE_SCRIPT)) + { + // HACK: finish any transitions we might be playing before we yield control to the script + if (GetActivity() != ACT_TRANSITION) + { + // Our animation state is being controlled by a script. + return; + } + } + + if( m_IdealActivity == ACT_DO_NOT_DISTURB || !GetModelPtr() ) + { + return; + } + + // We may have work to do if we aren't playing our ideal activity OR if we + // aren't playing our ideal sequence. + if ((GetActivity() != m_IdealActivity) || (GetSequence() != m_nIdealSequence)) + { + if (ai_sequence_debug.GetBool() == true && (m_debugOverlays & OVERLAY_NPC_SELECTED_BIT)) + { + DevMsg("MaintainActivity %s : %s:%s -> %s:%s\n", GetClassname(), + GetActivityName(GetActivity()), GetSequenceName(GetSequence()), + GetActivityName(m_IdealActivity), GetSequenceName(m_nIdealSequence)); + } + + bool bAdvance = false; + + // If we're in a transition activity, see if we are done with the transition. + if (GetActivity() == ACT_TRANSITION) + { + // If the current sequence is finished, try to go to the next one + // closer to our ideal sequence. + if (IsSequenceFinished()) + { + bAdvance = true; + } + // Else a transition sequence is in progress, do nothing. + } + // Else get a specific sequence for the activity and try to transition to that. + else + { + // Save off a target sequence and translated activities to apply when we finish + // playing all the transitions and finally arrive at our ideal activity. + ResolveActivityToSequence(m_IdealActivity, m_nIdealSequence, m_IdealTranslatedActivity, m_IdealWeaponActivity); + bAdvance = true; + } + + if (bAdvance) + { + // Try to go to the next sequence closer to our ideal sequence. + AdvanceToIdealActivity(); + } + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Returns true if our ideal activity has finished playing. +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::IsActivityFinished( void ) +{ + return (IsSequenceFinished() && (GetSequence() == m_nIdealSequence)); +} + +//----------------------------------------------------------------------------- +// Purpose: Checks to see if the activity is one of the standard phase-matched movement activities +// Input : activity +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::IsActivityMovementPhased( Activity activity ) +{ + switch( activity ) + { + case ACT_WALK: + case ACT_WALK_AIM: + case ACT_WALK_CROUCH: + case ACT_WALK_CROUCH_AIM: + case ACT_RUN: + case ACT_RUN_AIM: + case ACT_RUN_CROUCH: + case ACT_RUN_CROUCH_AIM: + case ACT_RUN_PROTECTED: + return true; + } + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::OnChangeActivity( Activity eNewActivity ) +{ + if ( eNewActivity == ACT_RUN || + eNewActivity == ACT_RUN_AIM || + eNewActivity == ACT_WALK ) + { + Stand(); + } +} + +//========================================================= +// SetSequenceByName +//========================================================= +void CAI_BaseNPC::SetSequenceByName( const char *szSequence ) +{ + int iSequence = LookupSequence( szSequence ); + + if ( iSequence > ACTIVITY_NOT_AVAILABLE ) + SetSequenceById( iSequence ); + else + { + DevWarning( 2, "%s has no sequence %s to match request\n", GetClassname(), szSequence ); + SetSequence( 0 ); // Set to the reset anim (if it's there) + } +} + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::SetSequenceById( int iSequence ) +{ + // Set to the desired anim, or default anim if the desired is not present + if ( iSequence > ACTIVITY_NOT_AVAILABLE ) + { + if ( GetSequence() != iSequence || !SequenceLoops() ) + { + SetCycle( 0 ); + } + + ResetSequence( iSequence ); // Set to the reset anim (if it's there) + GetMotor()->RecalculateYawSpeed(); + } + else + { + // Not available try to get default anim + DevWarning( 2, "%s invalid sequence requested\n", GetClassname() ); + SetSequence( 0 ); // Set to the reset anim (if it's there) + } +} + +//----------------------------------------------------------------------------- +// Purpose: Returns the target entity +// Input : +// Output : +//----------------------------------------------------------------------------- +CBaseEntity *CAI_BaseNPC::GetNavTargetEntity(void) +{ + if ( GetNavigator()->GetGoalType() == GOALTYPE_ENEMY ) + return m_hEnemy; + else if ( GetNavigator()->GetGoalType() == GOALTYPE_TARGETENT ) + return m_hTargetEnt; + return NULL; +} + + +//----------------------------------------------------------------------------- +// Purpose: returns zero if the caller can jump from +// vecStart to vecEnd ignoring collisions with pTarget +// +// if the throw fails, returns the distance +// that can be travelled before an obstacle is hit +//----------------------------------------------------------------------------- +#include "ai_initutils.h" +//#define _THROWDEBUG +float CAI_BaseNPC::ThrowLimit( const Vector &vecStart, + const Vector &vecEnd, + float fGravity, + float fArcSize, + const Vector &mins, + const Vector &maxs, + CBaseEntity *pTarget, + Vector *jumpVel, + CBaseEntity **pBlocker) +{ + // Get my jump velocity + Vector rawJumpVel = CalcThrowVelocity(vecStart, vecEnd, fGravity, fArcSize); + *jumpVel = rawJumpVel; + Vector vecFrom = vecStart; + + // Calculate the total time of the jump minus a tiny fraction + float jumpTime = (vecStart - vecEnd).Length2D()/rawJumpVel.Length2D(); + float timeStep = jumpTime / 10.0; + + Vector gravity = Vector(0,0,fGravity); + + // this loop takes single steps to the goal. + for (float flTime = 0 ; flTime < jumpTime-0.1 ; flTime += timeStep ) + { + // Calculate my position after the time step (average velocity over this time step) + Vector nextPos = vecFrom + (rawJumpVel - 0.5 * gravity * timeStep) * timeStep; + + // If last time step make next position the target position + if ((flTime + timeStep) > jumpTime) + { + nextPos = vecEnd; + } + + trace_t tr; + AI_TraceHull( vecFrom, nextPos, mins, maxs, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr ); + + if (tr.startsolid || tr.fraction < 1.0) + { + CBaseEntity *pEntity = tr.m_pEnt; + + // If we hit the target we are good to go! + if (pEntity == pTarget) + { + return 0; + } + +#ifdef _THROWDEBUG + NDebugOverlay::Line( vecFrom, nextPos, 255, 0, 0, true, 1.0 ); +#endif + // ---------------------------------------------------------- + // If blocked by an npc remember + // ---------------------------------------------------------- + *pBlocker = pEntity; + + // Return distance sucessfully traveled before block encountered + return ((tr.endpos - vecStart).Length()); + } +#ifdef _THROWDEBUG + else + { + NDebugOverlay::Line( vecFrom, nextPos, 255, 255, 255, true, 1.0 ); + } +#endif + + + rawJumpVel = rawJumpVel - gravity * timeStep; + vecFrom = nextPos; + } + return 0; +} + + + +//----------------------------------------------------------------------------- +// Purpose: Called to initialize or re-initialize the vphysics hull when the size +// of the NPC changes +//----------------------------------------------------------------------------- +void CAI_BaseNPC::SetupVPhysicsHull() +{ + if ( GetMoveType() == MOVETYPE_VPHYSICS || GetMoveType() == MOVETYPE_NONE ) + return; + + if ( VPhysicsGetObject() ) + { + // Disable collisions to get + VPhysicsGetObject()->EnableCollisions(false); + VPhysicsDestroyObject(); + } + VPhysicsInitShadow( true, false ); + IPhysicsObject *pPhysObj = VPhysicsGetObject(); + if ( pPhysObj ) + { + float mass = Studio_GetMass(GetModelPtr()); + if ( mass > 0 ) + { + pPhysObj->SetMass( mass ); + } +#if _DEBUG + else + { + DevMsg("Warning: %s has no physical mass\n", STRING(GetModelName())); + } +#endif + IPhysicsShadowController *pController = pPhysObj->GetShadowController(); + float avgsize = (WorldAlignSize().x + WorldAlignSize().y) * 0.5; + pController->SetTeleportDistance( avgsize * 0.5 ); + m_bCheckContacts = true; + } +} + + +// Check for problematic physics objects resting on this NPC. +// They can screw up his navigation, so attach a controller to +// help separate the NPC & physics when you encounter these. +ConVar ai_auto_contact_solver( "ai_auto_contact_solver", "1" ); +void CAI_BaseNPC::CheckPhysicsContacts() +{ + if ( gpGlobals->frametime <= 0.0f || !ai_auto_contact_solver.GetBool() ) + return; + + m_bCheckContacts = false; + if ( GetMoveType() == MOVETYPE_STEP && VPhysicsGetObject()) + { + IPhysicsObject *pPhysics = VPhysicsGetObject(); + IPhysicsFrictionSnapshot *pSnapshot = pPhysics->CreateFrictionSnapshot(); + CBaseEntity *pGroundEntity = GetGroundEntity(); + float heightCheck = GetAbsOrigin().z + GetHullMaxs().z; + Vector npcVel; + pPhysics->GetVelocity( &npcVel, NULL ); + CBaseEntity *pOtherEntity = NULL; + bool createSolver = false; + float solverTime = 0.0f; + while ( pSnapshot->IsValid() ) + { + IPhysicsObject *pOther = pSnapshot->GetObject(1); + pOtherEntity = static_cast(pOther->GetGameData()); + + if ( pOtherEntity && pGroundEntity != pOtherEntity ) + { + float otherMass = PhysGetEntityMass(pOtherEntity); + + if ( pOtherEntity->GetMoveType() == MOVETYPE_VPHYSICS && pOther->IsMoveable() && + otherMass < VPHYSICS_LARGE_OBJECT_MASS && !pOtherEntity->GetServerVehicle() ) + { + m_bCheckContacts = true; + Vector vel, point; + pOther->GetVelocity( &vel, NULL ); + pSnapshot->GetContactPoint( point ); + + // compare the relative velocity + vel -= npcVel; + + // slow moving object probably won't clear itself. + // Either set ignore, or disable collisions entirely + if ( vel.LengthSqr() < 5.0f*5.0f ) + { + float topdist = fabs(point.z-heightCheck); + // 4 seconds to ignore this for nav + solverTime = 4.0f; + if ( topdist < 2.0f ) + { + // Resting on my head so disable collisions for a bit + solverTime = 0.5f; // UNDONE: Tune + if ( pOther->GetGameFlags() & FVPHYSICS_PLAYER_HELD ) + { + // player is being a monkey + solverTime = 0.25f; + } + + //Msg("Dropping %s from %s\n", pOtherEntity->GetClassname(), GetClassname() ); + Assert( !NPCPhysics_SolverExists(this, pOtherEntity) ); + createSolver = true; + break; + } + } + } + } + pSnapshot->NextFrictionData(); + } + pPhysics->DestroyFrictionSnapshot( pSnapshot ); + if ( createSolver ) + { + // turn collisions back on once we've been separated for enough time + NPCPhysics_CreateSolver( this, pOtherEntity, true, solverTime ); + pPhysics->RecheckContactPoints(); + } + } +} + +void CAI_BaseNPC::StartTouch( CBaseEntity *pOther ) +{ + BaseClass::StartTouch(pOther); + + if ( pOther->GetMoveType() == MOVETYPE_VPHYSICS ) + { + m_bCheckContacts = true; + } +} + +//----------------------------------------------------------------------------- +// Purpose: To be called instead of UTIL_SetSize, so pathfinding hull +// and actual hull agree +// Input : +// Output : +//----------------------------------------------------------------------------- +void CAI_BaseNPC::SetHullSizeNormal( bool force ) +{ + if ( m_fIsUsingSmallHull || force ) + { + // Find out what the height difference will be between the versions and adjust our bbox accordingly to keep us level + const float flScale = GetModelScale(); + Vector vecMins = ( GetHullMins() * flScale ); + Vector vecMaxs = ( GetHullMaxs() * flScale ); + + UTIL_SetSize( this, vecMins, vecMaxs ); + + m_fIsUsingSmallHull = false; + if ( VPhysicsGetObject() ) + { + SetupVPhysicsHull(); + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: To be called instead of UTIL_SetSize, so pathfinding hull +// and actual hull agree +// Input : +// Output : +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::SetHullSizeSmall( bool force ) +{ + if ( !m_fIsUsingSmallHull || force ) + { + UTIL_SetSize(this, NAI_Hull::SmallMins(GetHullType()),NAI_Hull::SmallMaxs(GetHullType())); + m_fIsUsingSmallHull = true; + if ( VPhysicsGetObject() ) + { + SetupVPhysicsHull(); + } + } + return true; +} + +//----------------------------------------------------------------------------- +// Checks to see that the nav hull is valid for the NPC +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::IsNavHullValid() const +{ + Assert( GetSolid() != SOLID_BSP ); + + Vector hullMin = GetHullMins(); + Vector hullMax = GetHullMaxs(); + Vector vecMins, vecMaxs; + if ( GetSolid() == SOLID_BBOX ) + { + vecMins = WorldAlignMins(); + vecMaxs = WorldAlignMaxs(); + } + else if ( GetSolid() == SOLID_VPHYSICS ) + { + Assert( VPhysicsGetObject() ); + const CPhysCollide *pPhysCollide = VPhysicsGetObject()->GetCollide(); + physcollision->CollideGetAABB( &vecMins, &vecMaxs, pPhysCollide, GetAbsOrigin(), GetAbsAngles() ); + vecMins -= GetAbsOrigin(); + vecMaxs -= GetAbsOrigin(); + } + else + { + vecMins = hullMin; + vecMaxs = hullMax; + } + + if ( (hullMin.x > vecMins.x) || (hullMax.x < vecMaxs.x) || + (hullMin.y > vecMins.y) || (hullMax.y < vecMaxs.y) || + (hullMin.z > vecMins.z) || (hullMax.z < vecMaxs.z) ) + { + return false; + } + + return true; +} + + +//========================================================= +// NPCInit - after a npc is spawned, it needs to +// be dropped into the world, checked for mobility problems, +// and put on the proper path, if any. This function does +// all of those things after the npc spawns. Any +// initialization that should take place for all npcs +// goes here. +//========================================================= +void CAI_BaseNPC::NPCInit ( void ) +{ + if (!g_pGameRules->FAllowNPCs()) + { + UTIL_Remove( this ); + return; + } + + if( IsWaitingToRappel() ) + { + // If this guy's supposed to rappel, keep him from + // falling to the ground when he spawns. + AddFlag( FL_FLY ); + } + +#ifdef _DEBUG + // Make sure that the bounding box is appropriate for the hull size... + // FIXME: We can't test vphysics objects because NPCInit occurs before VPhysics is set up + if ( GetSolid() != SOLID_VPHYSICS && !IsSolidFlagSet(FSOLID_NOT_SOLID) ) + { + if ( !IsNavHullValid() ) + { + Warning("NPC Entity %s (%d) has a bounding box which extends outside its nav box!\n", + STRING(m_iClassname), entindex() ); + } + } +#endif + + // Set fields common to all npcs + AddFlag( FL_AIMTARGET | FL_NPC ); + AddSolidFlags( FSOLID_NOT_STANDABLE ); + + m_flOriginalYaw = GetAbsAngles().y; + + SetBlocksLOS( false ); + + SetGravity(1.0); // Don't change + m_takedamage = DAMAGE_YES; + GetMotor()->SetIdealYaw( GetLocalAngles().y ); + m_iMaxHealth = m_iHealth; + m_lifeState = LIFE_ALIVE; + SetIdealState( NPC_STATE_IDLE );// Assume npc will be idle, until proven otherwise + SetIdealActivity( ACT_IDLE ); + SetActivity( ACT_IDLE ); + +#ifdef HL1_DLL + SetDeathPose( ACT_INVALID ); +#endif + + ClearCommandGoal(); + + ClearSchedule( "Initializing NPC" ); + GetNavigator()->ClearGoal(); + InitBoneControllers( ); // FIX: should be done in Spawn + if ( GetModelPtr() ) + { + ResetActivityIndexes(); + ResetEventIndexes(); + } + + SetHintNode( NULL ); + + m_afMemory = MEMORY_CLEAR; + + SetEnemy( NULL ); + + m_flDistTooFar = 1024.0; + SetDistLook( 2048.0 ); + + if ( HasSpawnFlags( SF_NPC_LONG_RANGE ) ) + { + m_flDistTooFar = 1e9f; + SetDistLook( 6000.0 ); + } + + // Clear conditions + m_Conditions.ClearAll(); + + // set eye position + SetDefaultEyeOffset(); + + // Only give weapon of allowed to have one + if (CapabilitiesGet() & bits_CAP_USE_WEAPONS) + { // Does this npc spawn with a weapon + if ( m_spawnEquipment != NULL_STRING && strcmp(STRING(m_spawnEquipment), "0")) + { + CBaseCombatWeapon *pWeapon = Weapon_Create( STRING(m_spawnEquipment) ); + if ( pWeapon ) + { + // If I have a name, make my weapon match it with "_weapon" appended + if ( GetEntityName() != NULL_STRING ) + { + pWeapon->SetName( AllocPooledString(UTIL_VarArgs("%s_weapon", STRING(GetEntityName()))) ); + } + + if ( GetEffects() & EF_NOSHADOW ) + { + // BUGBUG: if this NPC drops this weapon it will forevermore have no shadow + pWeapon->AddEffects( EF_NOSHADOW ); + } + + Weapon_Equip( pWeapon ); + } + } + } + + // Robin: Removed this, since it stomps the weapon's settings, and it's stomped + // by OnUpdateShotRegulator() as soon as they finish firing the first time. + //GetShotRegulator()->SetParameters( 2, 6, 0.3f, 0.8f ); + + SetUse ( &CAI_BaseNPC::NPCUse ); + + // NOTE: Can't call NPC Init Think directly... logic changed about + // what time it is when worldspawn happens.. + + // We must put off the rest of our initialization + // until we're sure everything else has had a chance to spawn. Otherwise + // we may try to reference entities that haven't spawned yet.(sjb) + SetThink( &CAI_BaseNPC::NPCInitThink ); + SetNextThink( gpGlobals->curtime + 0.01f ); + + ForceGatherConditions(); + + // HACKHACK: set up a pre idle animation + // NOTE: Must do this before CreateVPhysics() so bone followers have the correct initial positions. + if ( HasSpawnFlags( SF_NPC_WAIT_FOR_SCRIPT ) ) + { + const char *pStartSequence = CAI_ScriptedSequence::GetSpawnPreIdleSequenceForScript( this ); + if ( pStartSequence ) + { + SetSequence( LookupSequence( pStartSequence ) ); + } + } + + CreateVPhysics(); + + if ( HasSpawnFlags( SF_NPC_START_EFFICIENT ) ) + { + SetEfficiency( AIE_EFFICIENT ); + } + + m_bFadeCorpse = ShouldFadeOnDeath(); + + m_GiveUpOnDeadEnemyTimer.Set( 0.75, 2.0 ); + + m_flTimeLastMovement = FLT_MAX; + + m_flIgnoreDangerSoundsUntil = 0; + + SetDeathPose( ACT_INVALID ); + SetDeathPoseFrame( 0 ); + + m_EnemiesSerialNumber = -1; +} + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::CreateVPhysics() +{ + if ( IsAlive() && !VPhysicsGetObject() ) + { + SetupVPhysicsHull(); + } + return true; +} + + +//----------------------------------------------------------------------------- +// Set up the shot regulator based on the equipped weapon +//----------------------------------------------------------------------------- +void CAI_BaseNPC::OnUpdateShotRegulator( ) +{ + CBaseCombatWeapon *pWeapon = GetActiveWeapon(); + if ( !pWeapon ) + return; + + // Default values + m_ShotRegulator.SetBurstInterval( pWeapon->GetFireRate(), pWeapon->GetFireRate() ); + m_ShotRegulator.SetBurstShotCountRange( pWeapon->GetMinBurst(), pWeapon->GetMaxBurst() ); + m_ShotRegulator.SetRestInterval( pWeapon->GetMinRestTime(), pWeapon->GetMaxRestTime() ); + + // Let the behavior have a whack at it. + if ( GetRunningBehavior() ) + { + GetRunningBehavior()->OnUpdateShotRegulator(); + } +} + + +//----------------------------------------------------------------------------- +// Set up the shot regulator based on the equipped weapon +//----------------------------------------------------------------------------- +void CAI_BaseNPC::OnChangeActiveWeapon( CBaseCombatWeapon *pOldWeapon, CBaseCombatWeapon *pNewWeapon ) +{ + BaseClass::OnChangeActiveWeapon( pOldWeapon, pNewWeapon ); + + // Shot regulator code + if ( pNewWeapon ) + { + OnUpdateShotRegulator(); + m_ShotRegulator.Reset( true ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Tests to see if NPC can holster their weapon (if animation exists to holster weapon) +// Output : true if holster weapon animation exists +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::CanHolsterWeapon( void ) +{ + int seq = SelectWeightedSequence( ACT_DISARM ); + return (seq >= 0); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int CAI_BaseNPC::HolsterWeapon( void ) +{ + if ( IsWeaponHolstered() ) + return -1; + + int iHolsterGesture = FindGestureLayer( ACT_DISARM ); + if ( iHolsterGesture != -1 ) + return iHolsterGesture; + + int iLayer = AddGesture( ACT_DISARM, true ); + //iLayer = AddGesture( ACT_GESTURE_DISARM, true ); + + if (iLayer != -1) + { + // Prevent firing during the holster / unholster + float flDuration = GetLayerDuration( iLayer ); + m_ShotRegulator.FireNoEarlierThan( gpGlobals->curtime + flDuration + 0.5 ); + + if( m_iDesiredWeaponState == DESIREDWEAPONSTATE_HOLSTERED_DESTROYED ) + { + m_iDesiredWeaponState = DESIREDWEAPONSTATE_CHANGING_DESTROY; + } + else + { + m_iDesiredWeaponState = DESIREDWEAPONSTATE_CHANGING; + } + + // Make sure we don't try to reload while we're holstering + ClearCondition(COND_LOW_PRIMARY_AMMO); + ClearCondition(COND_NO_PRIMARY_AMMO); + ClearCondition(COND_NO_SECONDARY_AMMO); + } + + return iLayer; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int CAI_BaseNPC::UnholsterWeapon( void ) +{ + if ( !IsWeaponHolstered() ) + return -1; + + int iHolsterGesture = FindGestureLayer( ACT_ARM ); + if ( iHolsterGesture != -1 ) + return iHolsterGesture; + + // Deploy the first weapon you can find + for (int i = 0; i < WeaponCount(); i++) + { + if ( GetWeapon( i )) + { + SetActiveWeapon( GetWeapon(i) ); + + int iLayer = AddGesture( ACT_ARM, true ); + //iLayer = AddGesture( ACT_GESTURE_ARM, true ); + + if (iLayer != -1) + { + // Prevent firing during the holster / unholster + float flDuration = GetLayerDuration( iLayer ); + m_ShotRegulator.FireNoEarlierThan( gpGlobals->curtime + flDuration + 0.5 ); + + m_iDesiredWeaponState = DESIREDWEAPONSTATE_CHANGING; + } + + // Refill the clip + if ( GetActiveWeapon()->UsesClipsForAmmo1() ) + { + GetActiveWeapon()->m_iClip1 = GetActiveWeapon()->GetMaxClip1(); + } + + // Make sure we don't try to reload while we're unholstering + ClearCondition(COND_LOW_PRIMARY_AMMO); + ClearCondition(COND_NO_PRIMARY_AMMO); + ClearCondition(COND_NO_SECONDARY_AMMO); + + return iLayer; + } + } + + return -1; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::InputHolsterWeapon( inputdata_t &inputdata ) +{ + m_iDesiredWeaponState = DESIREDWEAPONSTATE_HOLSTERED; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::InputHolsterAndDestroyWeapon( inputdata_t &inputdata ) +{ + m_iDesiredWeaponState = DESIREDWEAPONSTATE_HOLSTERED_DESTROYED; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::InputUnholsterWeapon( inputdata_t &inputdata ) +{ + m_iDesiredWeaponState = DESIREDWEAPONSTATE_UNHOLSTERED; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::IsWeaponHolstered( void ) +{ + if( !GetActiveWeapon() ) + return true; + + if( GetActiveWeapon()->IsEffectActive(EF_NODRAW) ) + return true; + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::IsWeaponStateChanging( void ) +{ + return ( m_iDesiredWeaponState == DESIREDWEAPONSTATE_CHANGING || m_iDesiredWeaponState == DESIREDWEAPONSTATE_CHANGING_DESTROY ); +} + +//----------------------------------------------------------------------------- +// Set up the shot regulator based on the equipped weapon +//----------------------------------------------------------------------------- +void CAI_BaseNPC::OnRangeAttack1() +{ + SetLastAttackTime( gpGlobals->curtime ); + + // Houston, there is a problem! + AssertOnce( GetShotRegulator()->ShouldShoot() ); + + m_ShotRegulator.OnFiredWeapon(); + if ( m_ShotRegulator.IsInRestInterval() ) + { + OnUpdateShotRegulator(); + } + + SetNextAttack( m_ShotRegulator.NextShotTime() ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Initialze the relationship table from the keyvalues +// Input : +// Output : +//----------------------------------------------------------------------------- +void CAI_BaseNPC::InitRelationshipTable(void) +{ + AddRelationship( STRING( m_RelationshipString ), NULL ); +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::AddRelationship( const char *pszRelationship, CBaseEntity *pActivator ) +{ + // Parse the keyvalue data + char parseString[1000]; + Q_strncpy(parseString, pszRelationship, sizeof(parseString)); + + // Look for an entity string + char *entityString = strtok(parseString," "); + while (entityString) + { + // Get the disposition + char *dispositionString = strtok(NULL," "); + Disposition_t disposition = D_NU; + if ( dispositionString ) + { + if (!stricmp(dispositionString,"D_HT")) + { + disposition = D_HT; + } + else if (!stricmp(dispositionString,"D_FR")) + { + disposition = D_FR; + } + else if (!stricmp(dispositionString,"D_LI")) + { + disposition = D_LI; + } + else if (!stricmp(dispositionString,"D_NU")) + { + disposition = D_NU; + } + else + { + disposition = D_NU; + Warning( "***ERROR***\nBad relationship type (%s) to unknown entity (%s)!\n", dispositionString,entityString ); + Assert( 0 ); + return; + } + } + else + { + Warning("Can't parse relationship info (%s) - Expecting 'name [D_HT, D_FR, D_LI, D_NU] [1-99]'\n", pszRelationship ); + Assert(0); + return; + } + + // Get the priority + char *priorityString = strtok(NULL," "); + int priority = ( priorityString ) ? atoi(priorityString) : DEF_RELATIONSHIP_PRIORITY; + + bool bFoundEntity = false; + + // Try to get pointer to an entity of this name + CBaseEntity *entity = gEntList.FindEntityByName( NULL, entityString ); + while( entity ) + { + // make sure you catch all entities of this name. + bFoundEntity = true; + AddEntityRelationship(entity, disposition, priority ); + entity = gEntList.FindEntityByName( entity, entityString ); + } + + if( !bFoundEntity ) + { + // Need special condition for player as we can only have one + if (!stricmp("player", entityString) || !stricmp("!player", entityString)) + { + AddClassRelationship( CLASS_PLAYER, disposition, priority ); + } + // Otherwise try to create one too see if a valid classname and get class type + else + { + // HACKHACK: + CBaseEntity *pEntity = CanCreateEntityClass( entityString ) ? CreateEntityByName( entityString ) : NULL; + if (pEntity) + { + AddClassRelationship( pEntity->Classify(), disposition, priority ); + UTIL_RemoveImmediate(pEntity); + } + else + { + DevWarning( "Couldn't set relationship to unknown entity or class (%s)!\n", entityString ); + } + } + } + // Check for another entity in the list + entityString = strtok(NULL," "); + } +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +void CAI_BaseNPC::AddEntityRelationship( CBaseEntity *pEntity, Disposition_t nDisposition, int nPriority ) +{ +#if 0 + ForceGatherConditions(); +#endif + BaseClass::AddEntityRelationship( pEntity, nDisposition, nPriority ); +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +void CAI_BaseNPC::AddClassRelationship( Class_T nClass, Disposition_t nDisposition, int nPriority ) +{ +#if 0 + ForceGatherConditions(); +#endif + BaseClass::AddClassRelationship( nClass, nDisposition, nPriority ); +} + +//========================================================= +// NPCInitThink - Calls StartNPC. Startnpc is +// virtual, but this function cannot be +//========================================================= +void CAI_BaseNPC::NPCInitThink ( void ) +{ + // Initialize the relationship table + InitRelationshipTable(); + + StartNPC(); + + PostNPCInit(); + + if( GetSleepState() == AISS_AUTO_PVS ) + { + // This code is a bit wonky, but it makes it easier for level designers to + // select this option in Hammer. So we set a sleep flag to indicate the choice, + // and then set the sleep state to awake (normal) + AddSleepFlags( AI_SLEEP_FLAG_AUTO_PVS ); + SetSleepState( AISS_AWAKE ); + } + + if( GetSleepState() == AISS_AUTO_PVS_AFTER_PVS ) + { + AddSleepFlags( AI_SLEEP_FLAG_AUTO_PVS_AFTER_PVS ); + SetSleepState( AISS_AWAKE ); + } + + if ( GetSleepState() > AISS_AWAKE ) + { + Sleep(); + } + + m_flLastRealThinkTime = gpGlobals->curtime; +} + +//========================================================= +// StartNPC - final bit of initization before a npc +// is turned over to the AI. +//========================================================= +void CAI_BaseNPC::StartNPC( void ) +{ + // Raise npc off the floor one unit, then drop to floor + if ( (GetMoveType() != MOVETYPE_FLY) && (GetMoveType() != MOVETYPE_FLYGRAVITY) && + !(CapabilitiesGet() & bits_CAP_MOVE_FLY) && + !HasSpawnFlags( SF_NPC_FALL_TO_GROUND ) && !IsWaitingToRappel() && !GetMoveParent() ) + { + Vector origin = GetLocalOrigin(); + + if (!GetMoveProbe()->FloorPoint( origin + Vector(0, 0, 0.1), MASK_NPCSOLID, 0, -2048, &origin )) + { + Warning( "NPC %s stuck in wall--level design error at (%.2f %.2f %.2f)\n", GetClassname(), GetAbsOrigin().x, GetAbsOrigin().y, GetAbsOrigin().z ); + if ( g_pDeveloper->GetInt() > 1 ) + { + m_debugOverlays |= OVERLAY_BBOX_BIT; + } + } + + SetLocalOrigin( origin ); + } + else + { + SetGroundEntity( NULL ); + } + + if ( m_target != NULL_STRING )// this npc has a target + { + // Find the npc's initial target entity, stash it + SetGoalEnt( gEntList.FindEntityByName( NULL, m_target ) ); + + if ( !GetGoalEnt() ) + { + Warning( "ReadyNPC()--%s couldn't find target %s\n", GetClassname(), STRING(m_target)); + } + else + { + StartTargetHandling( GetGoalEnt() ); + } + } + + //SetState ( m_IdealNPCState ); + //SetActivity ( m_IdealActivity ); + + InitSquad(); + + //--------------------------------- + // + // Spread think times of simultaneously spawned NPCs so that they don't all happen at the same time + // + // Think distribution based on spawn order is: + // + // Tick offset Think time Spawn order + // 0 0 1 + // 1 0.015 13 + // 2 0.03 5 + // 3 0.045 9 + // 4 0.06 18 + // 5 0.075 3 + // 6 0.09 15 + // 7 0.105 11 + // 8 0.12 7 + // 9 0.135 17 + // 10 0.15 2 + // 11 0.165 14 + // 12 0.18 6 + // 13 0.195 19 + // 14 0.21 10 + // 15 0.225 4 + // 16 0.24 16 + // 17 0.255 12 + // 18 0.27 8 + // 19 0.285 20 + + + // If this NPC is spawning late in the game, just push through the rest of the initialization + // start thinking right now. Some spread is added to handle triggered spawns that bring + // a bunch of NPCs into the level + SetThink ( &CAI_BaseNPC::CallNPCThink ); + + if ( gm_flTimeLastSpawn != gpGlobals->curtime ) + { + gm_nSpawnedThisFrame = 0; + gm_flTimeLastSpawn = gpGlobals->curtime; + } + + static const float nextThinkTimes[20] = + { + .0, .150, .075, .225, .030, .180, .120, .270, .045, .210, .105, .255, .015, .165, .090, .240, .135, .060, .195, .285 + }; + + SetNextThink( gpGlobals->curtime + nextThinkTimes[gm_nSpawnedThisFrame % 20] ); + + gm_nSpawnedThisFrame++; + + //--------------------------------- + + m_ScriptArrivalActivity = AIN_DEF_ACTIVITY; + m_strScriptArrivalSequence = NULL_STRING; + + if ( HasSpawnFlags(SF_NPC_WAIT_FOR_SCRIPT) ) + { + SetState( NPC_STATE_IDLE ); + m_Activity = m_IdealActivity; + m_nIdealSequence = GetSequence(); + SetSchedule( SCHED_WAIT_FOR_SCRIPT ); + } +} + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::StartTargetHandling( CBaseEntity *pTargetEnt ) +{ + // set the npc up to walk a path corner path. + // !!!BUGBUG - this is a minor bit of a hack. + // JAYJAY + + // NPC will start turning towards his destination + bool bIsFlying = (GetMoveType() == MOVETYPE_FLY) || (GetMoveType() == MOVETYPE_FLYGRAVITY); + AI_NavGoal_t goal( GOALTYPE_PATHCORNER, pTargetEnt->GetAbsOrigin(), + bIsFlying ? ACT_FLY : ACT_WALK, + AIN_DEF_TOLERANCE, AIN_YAW_TO_DEST); + + SetState( NPC_STATE_IDLE ); + SetSchedule( SCHED_IDLE_WALK ); + + if ( !GetNavigator()->SetGoal( goal ) ) + { + DevWarning( 2, "Can't Create Route!\n" ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Connect my memory to the squad's +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::InitSquad( void ) +{ + // ------------------------------------------------------- + // If I form squads add me to a squad + // ------------------------------------------------------- + if (!m_pSquad && ( CapabilitiesGet() & bits_CAP_SQUAD )) + { + if ( !m_SquadName ) + { + DevMsg(2, "Found %s that isn't in a squad\n",GetClassname()); + } + else + { + m_pSquad = g_AI_SquadManager.FindCreateSquad(this, m_SquadName); + } + } + + return ( m_pSquad != NULL ); +} + +//----------------------------------------------------------------------------- +// Purpose: Get the memory for this NPC +//----------------------------------------------------------------------------- +CAI_Enemies *CAI_BaseNPC::GetEnemies( void ) +{ + return m_pEnemies; +} + +//----------------------------------------------------------------------------- +// Purpose: Remove this NPC's memory +//----------------------------------------------------------------------------- +void CAI_BaseNPC::RemoveMemory( void ) +{ + delete m_pEnemies; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::TaskComplete( bool fIgnoreSetFailedCondition ) +{ + EndTaskOverlay(); + + // Handy thing to use for debugging + //if (IsCurSchedule(SCHED_PUT_HERE) && + // GetTask()->iTask == TASK_PUT_HERE) + //{ + // int put_breakpoint_here = 5; + //} + + if ( fIgnoreSetFailedCondition || !HasCondition(COND_TASK_FAILED) ) + { + SetTaskStatus( TASKSTATUS_COMPLETE ); + } +} + +void CAI_BaseNPC::TaskMovementComplete( void ) +{ + switch( GetTaskStatus() ) + { + case TASKSTATUS_NEW: + case TASKSTATUS_RUN_MOVE_AND_TASK: + SetTaskStatus( TASKSTATUS_RUN_TASK ); + break; + + case TASKSTATUS_RUN_MOVE: + TaskComplete(); + break; + + case TASKSTATUS_RUN_TASK: + // FIXME: find out how to safely restart movement + //Warning( "Movement completed twice!\n" ); + //Assert( 0 ); + break; + + case TASKSTATUS_COMPLETE: + break; + } + + // JAY: Put this back in. + // UNDONE: Figure out how much of the timestep was consumed by movement + // this frame and restart the movement/schedule engine if necessary + if ( m_scriptState != SCRIPT_CUSTOM_MOVE_TO_MARK ) + { + SetIdealActivity( GetStoppedActivity() ); + } + + // Advance past the last node (in case there is some event at this node) + if ( GetNavigator()->IsGoalActive() ) + { + GetNavigator()->AdvancePath(); + } + + // Now clear the path, it's done. + GetNavigator()->ClearGoal(); + + OnMovementComplete(); +} + + +int CAI_BaseNPC::TaskIsRunning( void ) +{ + if ( GetTaskStatus() != TASKSTATUS_COMPLETE && + GetTaskStatus() != TASKSTATUS_RUN_MOVE ) + return 1; + + return 0; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : +// Output : +//----------------------------------------------------------------------------- +void CAI_BaseNPC::TaskFail( AI_TaskFailureCode_t code ) +{ + EndTaskOverlay(); + + // Handy tool for debugging + //if (IsCurSchedule(SCHED_PUT_NAME_HERE)) + //{ + // int put_breakpoint_here = 5; + //} + + // If in developer mode save the fail text for debug output + if (g_pDeveloper->GetInt()) + { + m_failText = TaskFailureToString( code ); + + m_interuptSchedule = NULL; + m_failedSchedule = GetCurSchedule(); + + if (m_debugOverlays & OVERLAY_TASK_TEXT_BIT) + { + DevMsg(this, AIMF_IGNORE_SELECTED, " TaskFail -> %s\n", m_failText ); + } + + ADD_DEBUG_HISTORY( HISTORY_AI_DECISIONS, UTIL_VarArgs("%s(%d): TaskFail -> %s\n", GetDebugName(), entindex(), m_failText ) ); + + //AddTimedOverlay( fail_text, 5); + } + + m_ScheduleState.taskFailureCode = code; + SetCondition(COND_TASK_FAILED); + Forget( bits_MEMORY_TURNING ); +} + +//------------------------------------------------------------------------------ +// Purpose : Remember that this entity wasn't reachable +// Input : +// Output : +//------------------------------------------------------------------------------ +void CAI_BaseNPC::RememberUnreachable(CBaseEntity *pEntity, float duration ) +{ + if ( pEntity == GetEnemy() ) + { + ForceChooseNewEnemy(); + } + + const float NPC_UNREACHABLE_TIMEOUT = ( duration > 0.0 ) ? duration : 3; + // Only add to list if not already on it + for (int i=m_UnreachableEnts.Size()-1;i>=0;i--) + { + // If record already exists just update mark time + if (pEntity == m_UnreachableEnts[i].hUnreachableEnt) + { + m_UnreachableEnts[i].fExpireTime = gpGlobals->curtime + NPC_UNREACHABLE_TIMEOUT; + m_UnreachableEnts[i].vLocationWhenUnreachable = pEntity->GetAbsOrigin(); + return; + } + } + + // Add new unreachabe entity to list + int nNewIndex = m_UnreachableEnts.AddToTail(); + m_UnreachableEnts[nNewIndex].hUnreachableEnt = pEntity; + m_UnreachableEnts[nNewIndex].fExpireTime = gpGlobals->curtime + NPC_UNREACHABLE_TIMEOUT; + m_UnreachableEnts[nNewIndex].vLocationWhenUnreachable = pEntity->GetAbsOrigin(); +} + +//------------------------------------------------------------------------------ +// Purpose : Returns true is entity was remembered as unreachable. +// After a time delay reachability is checked +// Input : +// Output : +//------------------------------------------------------------------------------ +bool CAI_BaseNPC::IsUnreachable(CBaseEntity *pEntity) +{ + float UNREACHABLE_DIST_TOLERANCE_SQ = (120*120); + + // Note that it's ok to remove elements while I'm iterating + // as long as I iterate backwards and remove them using FastRemove + for (int i=m_UnreachableEnts.Size()-1;i>=0;i--) + { + // Remove any dead elements + if (m_UnreachableEnts[i].hUnreachableEnt == NULL) + { + m_UnreachableEnts.FastRemove(i); + } + else if (pEntity == m_UnreachableEnts[i].hUnreachableEnt) + { + // Test for reachablility on any elements that have timed out + if ( gpGlobals->curtime > m_UnreachableEnts[i].fExpireTime || + pEntity->GetAbsOrigin().DistToSqr(m_UnreachableEnts[i].vLocationWhenUnreachable) > UNREACHABLE_DIST_TOLERANCE_SQ) + { + m_UnreachableEnts.FastRemove(i); + return false; + } + return true; + } + } + return false; +} + +bool CAI_BaseNPC::IsValidEnemy( CBaseEntity *pEnemy ) +{ + CAI_BaseNPC *pEnemyNPC = pEnemy->MyNPCPointer(); + if ( pEnemyNPC && pEnemyNPC->CanBeAnEnemyOf( this ) == false ) + return false; + + // Test our enemy filter + if ( m_hEnemyFilter.Get()!= NULL && m_hEnemyFilter->PassesFilter( this, pEnemy ) == false ) + return false; + + return true; +} + + +bool CAI_BaseNPC::CanBeAnEnemyOf( CBaseEntity *pEnemy ) +{ + if ( GetSleepState() > AISS_WAITING_FOR_THREAT ) + return false; + + return true; +} + + +//----------------------------------------------------------------------------- +// Purpose: Picks best enemy from my list of enemies +// Prefers reachable enemies over enemies that are unreachable, +// regardless of priority. For enemies that are both reachable or +// unreachable picks by priority. If priority is the same, picks +// by distance. +// Input : +// Output : +//----------------------------------------------------------------------------- + +CBaseEntity *CAI_BaseNPC::BestEnemy( void ) +{ + AI_PROFILE_SCOPE( CAI_BaseNPC_BestEnemy ); + // TODO - may want to consider distance, attack types, back turned, etc. + + CBaseEntity* pBestEnemy = NULL; + int iBestDistSq = MAX_COORD_RANGE * MAX_COORD_RANGE;// so first visible entity will become the closest. + int iBestPriority = -1000; + bool bBestUnreachable = true; // Forces initial check + ThreeState_t fBestSeen = TRS_NONE; + ThreeState_t fBestVisible = TRS_NONE; + int iDistSq; + bool bUnreachable = false; + + AIEnemiesIter_t iter; + + DbgEnemyMsg( this, "BestEnemy() {\n" ); + + for( AI_EnemyInfo_t *pEMemory = GetEnemies()->GetFirst(&iter); pEMemory != NULL; pEMemory = GetEnemies()->GetNext(&iter) ) + { + CBaseEntity *pEnemy = pEMemory->hEnemy; + + if (!pEnemy || !pEnemy->IsAlive()) + { + if ( pEnemy ) + DbgEnemyMsg( this, " %s rejected: dead\n", pEnemy->GetDebugName() ); + continue; + } + + if ( (pEnemy->GetFlags() & FL_NOTARGET) ) + { + DbgEnemyMsg( this, " %s rejected: no target\n", pEnemy->GetDebugName() ); + continue; + } + + if ( m_bIgnoreUnseenEnemies ) + { + const float TIME_CONSIDER_ENEMY_UNSEEN = .4; + if ( pEMemory->timeLastSeen < gpGlobals->curtime - TIME_CONSIDER_ENEMY_UNSEEN ) + { + DbgEnemyMsg( this, " %s rejected: not seen and set to ignore unseen enemies\n", pEnemy->GetDebugName() ); + continue; + } + } + + // UNDONE: Move relationship checks into IsValidEnemy? + Disposition_t relation = IRelationType( pEnemy ); + if ( (relation != D_HT && relation != D_FR) ) + { + DbgEnemyMsg( this, " %s rejected: no hate/fear\n", pEnemy->GetDebugName() ); + continue; + } + + if ( m_flAcceptableTimeSeenEnemy > 0.0 && pEMemory->timeLastSeen < m_flAcceptableTimeSeenEnemy ) + { + DbgEnemyMsg( this, " %s rejected: old\n", pEnemy->GetDebugName() ); + continue; + } + + if ( pEMemory->timeValidEnemy > gpGlobals->curtime ) + { + DbgEnemyMsg( this, " %s rejected: not yet valid\n", pEnemy->GetDebugName() ); + continue; + } + + // Skip enemies that have eluded me to prevent infinite loops + if ( pEMemory->bEludedMe ) + { + DbgEnemyMsg( this, " %s rejected: eluded\n", pEnemy->GetDebugName() ); + continue; + } + + // Skip enemies I fear that I've never seen. (usually seen through an enemy finder) + if ( relation == D_FR && !pEMemory->bUnforgettable && pEMemory->timeFirstSeen == AI_INVALID_TIME ) + { + DbgEnemyMsg( this, " %s rejected: feared, but never seen\n", pEnemy->GetDebugName() ); + continue; + } + + if ( !IsValidEnemy( pEnemy ) ) + { + DbgEnemyMsg( this, " %s rejected: not valid\n", pEnemy->GetDebugName() ); + continue; + } + + // establish the reachability of this enemy + bUnreachable = IsUnreachable(pEnemy); + + // If best is reachable and current is unreachable, skip the unreachable enemy regardless of priority + if (!bBestUnreachable && bUnreachable) + { + DbgEnemyMsg( this, " %s rejected: unreachable\n", pEnemy->GetDebugName() ); + continue; + } + + // If best is unreachable and current is reachable, always pick the current regardless of priority + if (bBestUnreachable && !bUnreachable) + { + DbgEnemyMsg( this, " %s accepted (1)\n", pEnemy->GetDebugName() ); + if ( pBestEnemy ) + DbgEnemyMsg( this, " (%s displaced)\n", pBestEnemy->GetDebugName() ); + + iBestPriority = IRelationPriority ( pEnemy ); + iBestDistSq = (pEnemy->GetAbsOrigin() - GetAbsOrigin() ).LengthSqr(); + pBestEnemy = pEnemy; + bBestUnreachable = bUnreachable; + fBestSeen = TRS_NONE; + fBestVisible = TRS_NONE; + } + // If both are unreachable or both are reachable, choose enemy based on priority and distance + else if ( IRelationPriority( pEnemy ) > iBestPriority ) + { + DbgEnemyMsg( this, " %s accepted\n", pEnemy->GetDebugName() ); + if ( pBestEnemy ) + DbgEnemyMsg( this, " (%s displaced due to priority, %d > %d )\n", pBestEnemy->GetDebugName(), IRelationPriority( pEnemy ), iBestPriority ); + // this entity is disliked MORE than the entity that we + // currently think is the best visible enemy. No need to do + // a distance check, just get mad at this one for now. + iBestPriority = IRelationPriority ( pEnemy ); + iBestDistSq = ( pEnemy->GetAbsOrigin() - GetAbsOrigin() ).LengthSqr(); + pBestEnemy = pEnemy; + bBestUnreachable = bUnreachable; + fBestSeen = TRS_NONE; + fBestVisible = TRS_NONE; + } + else if ( IRelationPriority( pEnemy ) == iBestPriority ) + { + // this entity is disliked just as much as the entity that + // we currently think is the best visible enemy, so we only + // get mad at it if it is closer. + iDistSq = ( pEnemy->GetAbsOrigin() - GetAbsOrigin() ).LengthSqr(); + + bool bAcceptCurrent = false; + bool bCloser = ( ( iBestDistSq - iDistSq ) > EnemyDistTolerance() ); + ThreeState_t fCurSeen = TRS_NONE; + ThreeState_t fCurVisible = TRS_NONE; + + // The following code is constructed in such a verbose manner to + // ensure the expensive calls only occur if absolutely needed + + // If current is farther, and best has previously been confirmed as seen or visible, move on + if ( !bCloser) + { + if ( fBestSeen == TRS_TRUE || fBestVisible == TRS_TRUE ) + { + DbgEnemyMsg( this, " %s rejected: current is closer and seen\n", pEnemy->GetDebugName() ); + continue; + } + } + + // If current is closer, and best has previously been confirmed as not seen and not visible, take it + if ( bCloser) + { + if ( fBestSeen == TRS_FALSE && fBestVisible == TRS_FALSE ) + { + bAcceptCurrent = true; + } + } + + if ( !bAcceptCurrent ) + { + // If current is closer, and seen, take it + if ( bCloser ) + { + fCurSeen = ( GetSenses()->DidSeeEntity( pEnemy ) ) ? TRS_TRUE : TRS_FALSE; + + bAcceptCurrent = ( fCurSeen == TRS_TRUE ); + } + } + + if ( !bAcceptCurrent ) + { + // If current is farther, and best is seen, move on + if ( !bCloser ) + { + if ( fBestSeen == TRS_NONE ) + { + fBestSeen = ( GetSenses()->DidSeeEntity( pBestEnemy ) ) ? TRS_TRUE : TRS_FALSE; + } + + if ( fBestSeen == TRS_TRUE ) + { + DbgEnemyMsg( this, " %s rejected: current is closer and seen\n", pEnemy->GetDebugName() ); + continue; + } + } + + // At this point, need to start performing expensive tests + if ( bCloser && fBestVisible == TRS_NONE ) + { + // Perform shortest FVisible + fCurVisible = ( ( EnemyDistance( pEnemy ) < GetSenses()->GetDistLook() ) && FVisible( pEnemy ) ) ? TRS_TRUE : TRS_FALSE; + + bAcceptCurrent = ( fCurVisible == TRS_TRUE ); + } + + // Alas, must do the most expensive comparison + if ( !bAcceptCurrent ) + { + if ( fBestSeen == TRS_NONE ) + { + fBestSeen = ( GetSenses()->DidSeeEntity( pBestEnemy ) ) ? TRS_TRUE : TRS_FALSE; + } + + if ( fBestVisible == TRS_NONE ) + { + fBestVisible = ( ( EnemyDistance( pBestEnemy ) < GetSenses()->GetDistLook() ) && FVisible( pBestEnemy ) ) ? TRS_TRUE : TRS_FALSE; + } + + if ( fCurSeen == TRS_NONE ) + { + fCurSeen = ( GetSenses()->DidSeeEntity( pEnemy ) ) ? TRS_TRUE : TRS_FALSE; + } + + if ( fCurVisible == TRS_NONE ) + { + fCurVisible = ( ( EnemyDistance( pEnemy ) < GetSenses()->GetDistLook() ) && FVisible( pEnemy ) ) ? TRS_TRUE : TRS_FALSE; + } + + bool bBestSeenOrVisible = ( fBestSeen == TRS_TRUE || fBestVisible == TRS_TRUE ); + bool bCurSeenOrVisible = ( fCurSeen == TRS_TRUE || fCurVisible == TRS_TRUE ); + + if ( !bCloser) + { + if ( bBestSeenOrVisible ) + { + DbgEnemyMsg( this, " %s rejected: current is closer and seen\n", pEnemy->GetDebugName() ); + continue; + } + else if ( !bCurSeenOrVisible ) + { + DbgEnemyMsg( this, " %s rejected: current is closer and neither is seen\n", pEnemy->GetDebugName() ); + continue; + } + } + else // Closer + { + if ( !bCurSeenOrVisible && bBestSeenOrVisible ) + { + DbgEnemyMsg( this, " %s rejected: current is father but seen\n", pEnemy->GetDebugName() ); + continue; + } + } + } + } + + DbgEnemyMsg( this, " %s accepted\n", pEnemy->GetDebugName() ); + if ( pBestEnemy ) + DbgEnemyMsg( this, " (%s displaced due to distance/visibility)\n", pBestEnemy->GetDebugName() ); + fBestSeen = fCurSeen; + fBestVisible = fCurVisible; + iBestDistSq = iDistSq; + iBestPriority = IRelationPriority ( pEnemy ); + pBestEnemy = pEnemy; + bBestUnreachable = bUnreachable; + } + else + DbgEnemyMsg( this, " %s rejected: lower priority\n", pEnemy->GetDebugName() ); + } + + DbgEnemyMsg( this, "} == %s\n", pBestEnemy->GetDebugName() ); + + return pBestEnemy; +} + +//----------------------------------------------------------------------------- +// Purpose: Given a node returns the appropriate reload activity +// Input : +// Output : +//----------------------------------------------------------------------------- +Activity CAI_BaseNPC::GetReloadActivity( CAI_Hint* pHint ) +{ + Activity nReloadActivity = ACT_RELOAD; + + if (pHint && GetEnemy()!=NULL) + { + switch (pHint->HintType()) + { + case HINT_TACTICAL_COVER_LOW: + case HINT_TACTICAL_COVER_MED: + { + if (SelectWeightedSequence( ACT_RELOAD_LOW ) != ACTIVITY_NOT_AVAILABLE) + { + Vector vEyePos = GetAbsOrigin() + EyeOffset(ACT_RELOAD_LOW); + // Check if this location will block the threat's line of sight to me + trace_t tr; + AI_TraceLOS( vEyePos, GetEnemy()->EyePosition(), this, &tr ); + if (tr.fraction != 1.0) + { + nReloadActivity = ACT_RELOAD_LOW; + } + } + break; + } + } + } + return nReloadActivity; +} + +//----------------------------------------------------------------------------- +// Purpose: Given a node returns the appropriate cover activity +// Input : +// Output : +//----------------------------------------------------------------------------- +Activity CAI_BaseNPC::GetCoverActivity( CAI_Hint *pHint ) +{ + Activity nCoverActivity = ACT_INVALID; + + // --------------------------------------------------------------- + // Check if hint node specifies different cover type + // --------------------------------------------------------------- + if (pHint) + { + switch (pHint->HintType()) + { + case HINT_TACTICAL_COVER_MED: + { + nCoverActivity = ACT_COVER_MED; + break; + } + case HINT_TACTICAL_COVER_LOW: + { + nCoverActivity = ACT_COVER_LOW; + break; + } + } + } + + if ( nCoverActivity == ACT_INVALID ) + nCoverActivity = ACT_COVER; + + return nCoverActivity; +} + +//========================================================= +// CalcIdealYaw - gets a yaw value for the caller that would +// face the supplied vector. Value is stuffed into the npc's +// ideal_yaw +//========================================================= +float CAI_BaseNPC::CalcIdealYaw( const Vector &vecTarget ) +{ + Vector vecProjection; + + // strafing npc needs to face 90 degrees away from its goal + if ( GetNavigator()->GetMovementActivity() == ACT_STRAFE_LEFT ) + { + vecProjection.x = -vecTarget.y; + vecProjection.y = vecTarget.x; + + return UTIL_VecToYaw( vecProjection - GetLocalOrigin() ); + } + else if ( GetNavigator()->GetMovementActivity() == ACT_STRAFE_RIGHT ) + { + vecProjection.x = vecTarget.y; + vecProjection.y = vecTarget.x; + + return UTIL_VecToYaw( vecProjection - GetLocalOrigin() ); + } + else + { + return UTIL_VecToYaw ( vecTarget - GetLocalOrigin() ); + } +} + +//========================================================= +// SetEyePosition +// +// queries the npc's model for $eyeposition and copies +// that vector to the npc's m_vDefaultEyeOffset and m_vecViewOffset +// +//========================================================= +void CAI_BaseNPC::SetDefaultEyeOffset ( void ) +{ + if ( GetModelPtr() ) + { + GetEyePosition( GetModelPtr(), m_vDefaultEyeOffset ); + + if ( m_vDefaultEyeOffset == vec3_origin ) + { + if ( Classify() != CLASS_NONE ) + { + DevMsg( "WARNING: %s(%s) has no eye offset in .qc!\n", GetClassname(), STRING(GetModelName()) ); + } + VectorAdd( WorldAlignMins(), WorldAlignMaxs(), m_vDefaultEyeOffset ); + m_vDefaultEyeOffset *= 0.75; + } + } + else + m_vDefaultEyeOffset = vec3_origin; + + SetViewOffset( m_vDefaultEyeOffset ); + +} + +//------------------------------------------------------------------------------ +// Purpose : Returns eye offset for an NPC for the given activity +// Input : +// Output : +//------------------------------------------------------------------------------ +Vector CAI_BaseNPC::EyeOffset( Activity nActivity ) +{ + if ( CapabilitiesGet() & bits_CAP_DUCK ) + { + if ( IsCrouchedActivity( nActivity ) ) + return GetCrouchEyeOffset(); + } + + // if the hint doesn't tell anything, assume current state + if ( IsCrouching() ) + return GetCrouchEyeOffset(); + + return m_vDefaultEyeOffset * GetModelScale(); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : Vector +//----------------------------------------------------------------------------- +Vector CAI_BaseNPC::EyePosition( void ) +{ + if ( IsCrouching() ) + return GetAbsOrigin() + GetCrouchEyeOffset(); + + return BaseClass::EyePosition(); +} + +//------------------------------------------------------------------------------ +// Purpose : +// Input : +// Output : +//------------------------------------------------------------------------------ +void CAI_BaseNPC::HandleAnimEvent( animevent_t *pEvent ) +{ + // UNDONE: Share this code into CBaseAnimating as appropriate? + switch( pEvent->event ) + { + case SCRIPT_EVENT_DEAD: + if ( m_NPCState == NPC_STATE_SCRIPT ) + { + m_lifeState = LIFE_DYING; + // Kill me now! (and fade out when CineCleanup() is called) +#if _DEBUG + DevMsg( 2, "Death event: %s\n", GetClassname() ); +#endif + m_iHealth = 0; + } +#if _DEBUG + else + DevWarning( 2, "INVALID death event:%s\n", GetClassname() ); +#endif + break; + case SCRIPT_EVENT_NOT_DEAD: + if ( m_NPCState == NPC_STATE_SCRIPT ) + { + m_lifeState = LIFE_ALIVE; + // This is for life/death sequences where the player can determine whether a character is dead or alive after the script + m_iHealth = m_iMaxHealth; + } + break; + + case SCRIPT_EVENT_SOUND: // Play a named wave file + { + EmitSound( pEvent->options ); + } + break; + + case SCRIPT_EVENT_SOUND_VOICE: + { + EmitSound( pEvent->options ); + } + break; + + case SCRIPT_EVENT_SENTENCE_RND1: // Play a named sentence group 33% of the time + if (random->RandomInt(0,2) == 0) + break; + // fall through... + case SCRIPT_EVENT_SENTENCE: // Play a named sentence group + SENTENCEG_PlayRndSz( edict(), pEvent->options, 1.0, SNDLVL_TALKING, 0, 100 ); + break; + + case SCRIPT_EVENT_FIREEVENT: + { + // + // Fire a script event. The number of the script event to fire is in the options string. + // + if ( m_hCine != NULL ) + { + m_hCine->FireScriptEvent( atoi( pEvent->options ) ); + } + else + { + // FIXME: look so see if it's playing a vcd and fire those instead + // AssertOnce( 0 ); + } + break; + } + case SCRIPT_EVENT_FIRE_INPUT: + { + variant_t emptyVariant; + this->AcceptInput( pEvent->options, this, this, emptyVariant, 0 ); + break; + } + + case SCRIPT_EVENT_NOINTERRUPT: // Can't be interrupted from now on + if ( m_hCine ) + m_hCine->AllowInterrupt( false ); + break; + + case SCRIPT_EVENT_CANINTERRUPT: // OK to interrupt now + if ( m_hCine ) + m_hCine->AllowInterrupt( true ); + break; + +#if 0 + case SCRIPT_EVENT_INAIR: // Don't engine->DropToFloor() + case SCRIPT_EVENT_ENDANIMATION: // Set ending animation sequence to + break; +#endif + case SCRIPT_EVENT_BODYGROUPON: + case SCRIPT_EVENT_BODYGROUPOFF: + case SCRIPT_EVENT_BODYGROUPTEMP: + DevMsg( "Bodygroup!\n" ); + break; + + case AE_NPC_ATTACK_BROADCAST: + break; + + case NPC_EVENT_BODYDROP_HEAVY: + if ( GetFlags() & FL_ONGROUND ) + { + EmitSound( "AI_BaseNPC.BodyDrop_Heavy" ); + } + break; + + case NPC_EVENT_BODYDROP_LIGHT: + if ( GetFlags() & FL_ONGROUND ) + { + EmitSound( "AI_BaseNPC.BodyDrop_Light" ); + } + break; + + case NPC_EVENT_SWISHSOUND: + { + // NO NPC may use this anim event unless that npc's precache precaches this sound!!! + EmitSound( "AI_BaseNPC.SwishSound" ); + break; + } + + + case NPC_EVENT_180TURN: + { + //DevMsg( "Turned!\n" ); + SetIdealActivity( ACT_IDLE ); + Forget( bits_MEMORY_TURNING ); + SetBoneController( 0, GetLocalAngles().y ); + IncrementInterpolationFrame(); + break; + } + + case NPC_EVENT_ITEM_PICKUP: + { + CBaseEntity *pPickup = NULL; + + // + // Figure out what we're supposed to pick up. + // + if ( pEvent->options && strlen( pEvent->options ) > 0 ) + { + // Pick up the weapon or item that was specified in the anim event. + pPickup = gEntList.FindEntityGenericNearest( pEvent->options, GetAbsOrigin(), 256, this ); + } + else + { + // Pick up the weapon or item that was found earlier and cached in our target pointer. + pPickup = GetTarget(); + } + + // Make sure we found something to pick up. + if ( !pPickup ) + { + TaskFail("Item no longer available!\n"); + break; + } + + // Make sure the item hasn't moved. + float flDist = ( pPickup->WorldSpaceCenter() - GetAbsOrigin() ).Length2D(); + if ( flDist > ITEM_PICKUP_TOLERANCE ) + { + TaskFail("Item has moved!\n"); + break; + } + + CBaseCombatWeapon *pWeapon = dynamic_cast( pPickup ); + if ( pWeapon ) + { + // Picking up a weapon. + CBaseCombatCharacter *pOwner = pWeapon->GetOwner(); + if ( pOwner ) + { + TaskFail( "Weapon in use by someone else" ); + } + else if ( !pWeapon ) + { + TaskFail( "Weapon doesn't exist" ); + } + else if (!Weapon_CanUse( pWeapon )) + { + TaskFail( "Can't use this weapon type" ); + } + else + { + PickupWeapon( pWeapon ); + TaskComplete(); + break; + } + } + else + { + // Picking up an item. + PickupItem( pPickup ); + TaskComplete(); + } + + break; + } + + case NPC_EVENT_WEAPON_SET_SEQUENCE_NUMBER: + { + CBaseCombatWeapon *pWeapon = GetActiveWeapon(); + if ((pWeapon) && (pEvent->options)) + { + int nSequence = atoi(pEvent->options); + if (nSequence != -1) + { + pWeapon->ResetSequence(nSequence); + } + } + break; + } + + case NPC_EVENT_WEAPON_SET_SEQUENCE_NAME: + { + CBaseCombatWeapon *pWeapon = GetActiveWeapon(); + if ((pWeapon) && (pEvent->options)) + { + int nSequence = pWeapon->LookupSequence(pEvent->options); + if (nSequence != -1) + { + pWeapon->ResetSequence(nSequence); + } + } + break; + } + + case NPC_EVENT_WEAPON_SET_ACTIVITY: + { + CBaseCombatWeapon *pWeapon = GetActiveWeapon(); + if ((pWeapon) && (pEvent->options)) + { + Activity act = (Activity)pWeapon->LookupActivity(pEvent->options); + if (act != ACT_INVALID) + { + // FIXME: where should the duration come from? normally it would come from the current sequence + Weapon_SetActivity(act, 0); + } + } + break; + } + + case NPC_EVENT_WEAPON_DROP: + { + // + // Drop our active weapon (or throw it at the specified target entity). + // + CBaseEntity *pTarget = NULL; + if (pEvent->options) + { + pTarget = gEntList.FindEntityGeneric(NULL, pEvent->options, this); + } + + if (pTarget) + { + Vector vecTargetPos = pTarget->WorldSpaceCenter(); + Weapon_Drop(GetActiveWeapon(), &vecTargetPos); + } + else + { + Weapon_Drop(GetActiveWeapon()); + } + + break; + } + + case EVENT_WEAPON_RELOAD: + { + if ( GetActiveWeapon() ) + { + GetActiveWeapon()->WeaponSound( RELOAD_NPC ); + GetActiveWeapon()->m_iClip1 = GetActiveWeapon()->GetMaxClip1(); + ClearCondition(COND_LOW_PRIMARY_AMMO); + ClearCondition(COND_NO_PRIMARY_AMMO); + ClearCondition(COND_NO_SECONDARY_AMMO); + } + break; + } + + case EVENT_WEAPON_RELOAD_SOUND: + { + if ( GetActiveWeapon() ) + { + GetActiveWeapon()->WeaponSound( RELOAD_NPC ); + } + break; + } + + case EVENT_WEAPON_RELOAD_FILL_CLIP: + { + if ( GetActiveWeapon() ) + { + GetActiveWeapon()->m_iClip1 = GetActiveWeapon()->GetMaxClip1(); + ClearCondition(COND_LOW_PRIMARY_AMMO); + ClearCondition(COND_NO_PRIMARY_AMMO); + ClearCondition(COND_NO_SECONDARY_AMMO); + } + break; + } + + case NPC_EVENT_LEFTFOOT: + case NPC_EVENT_RIGHTFOOT: + // For right now, do nothing. All functionality for this lives in individual npcs. + break; + + case NPC_EVENT_OPEN_DOOR: + { + CBasePropDoor *pDoor = (CBasePropDoor *)(CBaseEntity *)GetNavigator()->GetPath()->GetCurWaypoint()->GetEHandleData(); + if (pDoor != NULL) + { + OpenPropDoorNow( pDoor ); + } + + break; + } + + default: + if ((pEvent->type & AE_TYPE_NEWEVENTSYSTEM) && (pEvent->type & AE_TYPE_SERVER)) + { + if (pEvent->event == AE_NPC_HOLSTER) + { + // Cache off the weapon. + CBaseCombatWeapon *pWeapon = GetActiveWeapon(); + + Assert( pWeapon != NULL ); + + GetActiveWeapon()->Holster(); + SetActiveWeapon( NULL ); + + //Force the NPC to recalculate it's arrival activity since it'll most likely be wrong now that we don't have a weapon out. + GetNavigator()->SetArrivalSequence( ACT_INVALID ); + + if ( m_iDesiredWeaponState == DESIREDWEAPONSTATE_CHANGING_DESTROY ) + { + // Get rid of it! + UTIL_Remove( pWeapon ); + } + + if ( m_iDesiredWeaponState != DESIREDWEAPONSTATE_IGNORE ) + { + m_iDesiredWeaponState = DESIREDWEAPONSTATE_IGNORE; + m_Activity = ACT_RESET; + } + + return; + } + else if (pEvent->event == AE_NPC_DRAW) + { + if (GetActiveWeapon()) + { + GetActiveWeapon()->Deploy(); + + //Force the NPC to recalculate it's arrival activity since it'll most likely be wrong now. + GetNavigator()->SetArrivalSequence( ACT_INVALID ); + + if ( m_iDesiredWeaponState != DESIREDWEAPONSTATE_IGNORE ) + { + m_iDesiredWeaponState = DESIREDWEAPONSTATE_IGNORE; + m_Activity = ACT_RESET; + } + } + return; + } + else if ( pEvent->event == AE_NPC_BODYDROP_HEAVY ) + { + if ( GetFlags() & FL_ONGROUND ) + { + EmitSound( "AI_BaseNPC.BodyDrop_Heavy" ); + } + return; + } + else if ( pEvent->event == AE_NPC_LEFTFOOT || pEvent->event == AE_NPC_RIGHTFOOT ) + { + return; + } + else if ( pEvent->event == AE_NPC_RAGDOLL ) + { + // Convert to ragdoll immediately + BecomeRagdollOnClient( vec3_origin ); + return; + } + else if ( pEvent->event == AE_NPC_ADDGESTURE ) + { + Activity act = ( Activity )LookupActivity( pEvent->options ); + if (act != ACT_INVALID) + { + act = TranslateActivity( act ); + if (act != ACT_INVALID) + { + AddGesture( act ); + } + } + return; + } + else if ( pEvent->event == AE_NPC_RESTARTGESTURE ) + { + Activity act = ( Activity )LookupActivity( pEvent->options ); + if (act != ACT_INVALID) + { + act = TranslateActivity( act ); + if (act != ACT_INVALID) + { + RestartGesture( act ); + } + } + return; + } + else if ( pEvent->event == AE_NPC_WEAPON_DROP ) + { + // Drop our active weapon (or throw it at the specified target entity). + CBaseEntity *pTarget = NULL; + if (pEvent->options) + { + pTarget = gEntList.FindEntityGeneric(NULL, pEvent->options, this); + } + + if (pTarget) + { + Vector vecTargetPos = pTarget->WorldSpaceCenter(); + Weapon_Drop(GetActiveWeapon(), &vecTargetPos); + } + else + { + Weapon_Drop(GetActiveWeapon()); + } + return; + } + else if ( pEvent->event == AE_NPC_WEAPON_SET_ACTIVITY ) + { + CBaseCombatWeapon *pWeapon = GetActiveWeapon(); + if ((pWeapon) && (pEvent->options)) + { + Activity act = (Activity)pWeapon->LookupActivity(pEvent->options); + if (act == ACT_INVALID) + { + // Try and translate it + act = Weapon_TranslateActivity( (Activity)CAI_BaseNPC::GetActivityID(pEvent->options), NULL ); + } + + if (act != ACT_INVALID) + { + // FIXME: where should the duration come from? normally it would come from the current sequence + Weapon_SetActivity(act, 0); + } + } + return; + } + else if ( pEvent->event == AE_NPC_SET_INTERACTION_CANTDIE ) + { + SetInteractionCantDie( (atoi(pEvent->options) != 0) ); + return; + } + else if ( pEvent->event == AE_NPC_HURT_INTERACTION_PARTNER ) + { + // If we're currently interacting with an enemy, hurt them/me + if ( m_hInteractionPartner ) + { + CAI_BaseNPC *pTarget = NULL; + CAI_BaseNPC *pAttacker = NULL; + if ( pEvent->options ) + { + char szEventOptions[128]; + Q_strncpy( szEventOptions, pEvent->options, sizeof(szEventOptions) ); + char *pszParam = strtok( szEventOptions, " " ); + if ( pszParam ) + { + if ( !Q_strncmp( pszParam, "ME", 2 ) ) + { + pTarget = this; + pAttacker = m_hInteractionPartner; + } + else if ( !Q_strncmp( pszParam, "THEM", 4 ) ) + { + pAttacker = this; + pTarget = m_hInteractionPartner; + } + + pszParam = strtok(NULL," "); + if ( pAttacker && pTarget && pszParam ) + { + int iDamage = atoi( pszParam ); + if ( iDamage ) + { + // We've got a target, and damage. Now hurt them. + CTakeDamageInfo info; + info.SetDamage( iDamage ); + info.SetAttacker( pAttacker ); + info.SetInflictor( pAttacker ); + info.SetDamageType( DMG_GENERIC | DMG_PREVENT_PHYSICS_FORCE ); + pTarget->TakeDamage( info ); + return; + } + } + } + } + + // Bad data. Explain how to use this anim event. + const char *pName = EventList_NameForIndex( pEvent->event ); + DevWarning( 1, "Bad %s format. Should be: { AE_NPC_HURT_INTERACTION_PARTNER \" \" }\n", pName ); + return; + } + + DevWarning( "%s received AE_NPC_HURT_INTERACTION_PARTNER anim event, but it's not interacting with anything.\n", GetDebugName() ); + return; + } + } + + // FIXME: why doesn't this code pass unhandled events down to its parent? + // Came from my weapon? + //Adrian I'll clean this up once the old event system is phased out. + if ( pEvent->pSource != this || ( pEvent->type & AE_TYPE_NEWEVENTSYSTEM && pEvent->type & AE_TYPE_WEAPON ) || (pEvent->event >= EVENT_WEAPON && pEvent->event <= EVENT_WEAPON_LAST) ) + { + Weapon_HandleAnimEvent( pEvent ); + } + else + { + BaseClass::HandleAnimEvent( pEvent ); + } + break; + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Override base class to add display of routes +// Input : +// Output : Current text offset from the top +//----------------------------------------------------------------------------- +void CAI_BaseNPC::DrawDebugGeometryOverlays(void) +{ + // Handy for debug + //NDebugOverlay::Cross3D(EyePosition(),Vector(-2,-2,-2),Vector(2,2,2),0,255,0,true); + + // ------------------------------ + // Remove me if requested + // ------------------------------ + if (m_debugOverlays & OVERLAY_NPC_ZAP_BIT) + { + VacateStrategySlot(); + Weapon_Drop( GetActiveWeapon() ); + m_iHealth = 0; + SetThink( &CAI_BaseNPC::SUB_Remove ); + } + + // ------------------------------ + // properly kill an NPC. + // ------------------------------ + if (m_debugOverlays & OVERLAY_NPC_KILL_BIT) + { + CTakeDamageInfo info; + + info.SetDamage( m_iHealth ); + info.SetAttacker( this ); + info.SetInflictor( ( AI_IsSinglePlayer() ) ? (CBaseEntity *)AI_GetSinglePlayer() : (CBaseEntity *)this ); + info.SetDamageType( DMG_GENERIC ); + + m_debugOverlays &= ~OVERLAY_NPC_KILL_BIT; + TakeDamage( info ); + return; + } + + + // ------------------------------ + // Draw route if requested + // ------------------------------ + if ((m_debugOverlays & OVERLAY_NPC_ROUTE_BIT)) + { + GetNavigator()->DrawDebugRouteOverlay(); + if ( IsMoving() ) + { + float yaw = GetMotor()->GetIdealYaw(); + Vector vecYaw = UTIL_YawToVector(yaw); + NDebugOverlay::Line(WorldSpaceCenter(),WorldSpaceCenter() + vecYaw * GetHullWidth() * .5,255,255,255,true,0.0); + } + } + + if (!(CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI) && (IsCurSchedule(SCHED_FORCED_GO) || IsCurSchedule(SCHED_FORCED_GO_RUN))) + { + NDebugOverlay::Box(m_vecLastPosition, Vector(-5,-5,-5),Vector(5,5,5), 255, 0, 255, 0, 0); + NDebugOverlay::HorzArrow( GetAbsOrigin(), m_vecLastPosition, 16, 255, 0, 255, 64, true, 0 ); + } + + // ------------------------------ + // Draw red box around if selected + // ------------------------------ + if ((m_debugOverlays & OVERLAY_NPC_SELECTED_BIT) && !ai_no_select_box.GetBool()) + { + NDebugOverlay::EntityBounds(this, 255, 0, 0, 20, 0); + } + + // ------------------------------ + // Draw nearest node if selected + // ------------------------------ + if ((m_debugOverlays & OVERLAY_NPC_NEAREST_BIT)) + { + int iNodeID = GetPathfinder()->NearestNodeToNPC(); + if (iNodeID != NO_NODE) + { + NDebugOverlay::Box(GetNavigator()->GetNetwork()->AccessNodes()[iNodeID]->GetPosition(GetHullType()), Vector(-10,-10,-10),Vector(10,10,10), 255, 255, 255, 0, 0); + } + } + + // ------------------------------ + // Draw viewcone if selected + // ------------------------------ + if ((m_debugOverlays & OVERLAY_NPC_VIEWCONE_BIT)) + { + float flViewRange = acos(m_flFieldOfView); + Vector vEyeDir = EyeDirection2D( ); + Vector vLeftDir, vRightDir; + float fSin, fCos; + SinCos( flViewRange, &fSin, &fCos ); + + vLeftDir.x = vEyeDir.x * fCos - vEyeDir.y * fSin; + vLeftDir.y = vEyeDir.x * fSin + vEyeDir.y * fCos; + vLeftDir.z = vEyeDir.z; + fSin = sin(-flViewRange); + fCos = cos(-flViewRange); + vRightDir.x = vEyeDir.x * fCos - vEyeDir.y * fSin; + vRightDir.y = vEyeDir.x * fSin + vEyeDir.y * fCos; + vRightDir.z = vEyeDir.z; + + // Visualize it + NDebugOverlay::VertArrow( EyePosition(), EyePosition() + ( vLeftDir * 200 ), 64, 255, 0, 0, 50, false, 0 ); + NDebugOverlay::VertArrow( EyePosition(), EyePosition() + ( vRightDir * 200 ), 64, 255, 0, 0, 50, false, 0 ); + NDebugOverlay::VertArrow( EyePosition(), EyePosition() + ( vEyeDir * 100 ), 8, 0, 255, 0, 50, false, 0 ); + NDebugOverlay::Box(EyePosition(), -Vector(2,2,2), Vector(2,2,2), 0, 255, 0, 128, 0 ); + } + + // ---------------------------------------------- + // Draw the relationships for this NPC to others + // ---------------------------------------------- + if ( m_debugOverlays & OVERLAY_NPC_RELATION_BIT ) + { + // Show the relationships to entities around us + int r = 0; + int g = 0; + int b = 0; + + int nRelationship; + CAI_BaseNPC **ppAIs = g_AI_Manager.AccessAIs(); + + // Rate all NPCs + for ( int i = 0; i < g_AI_Manager.NumAIs(); i++ ) + { + if ( ppAIs[i] == NULL || ppAIs[i] == this ) + continue; + + // Get our relation to the target + nRelationship = IRelationType( ppAIs[i] ); + + // Get the color for the arrow + UTIL_GetDebugColorForRelationship( nRelationship, r, g, b ); + + // Draw an arrow + NDebugOverlay::HorzArrow( GetAbsOrigin(), ppAIs[i]->GetAbsOrigin(), 16, r, g, b, 64, true, 0.0f ); + } + + // Also include all players + for ( int i = 1; i <= gpGlobals->maxClients; i++ ) + { + CBasePlayer *pPlayer = UTIL_PlayerByIndex( i ); + if ( pPlayer == NULL ) + continue; + + // Get our relation to the target + nRelationship = IRelationType( pPlayer ); + + // Get the color for the arrow + UTIL_GetDebugColorForRelationship( nRelationship, r, g, b ); + + // Draw an arrow + NDebugOverlay::HorzArrow( GetAbsOrigin(), pPlayer->GetAbsOrigin(), 16, r, g, b, 64, true, 0.0f ); + } + } + + // ------------------------------ + // Draw enemies if selected + // ------------------------------ + if ((m_debugOverlays & OVERLAY_NPC_ENEMIES_BIT)) + { + AIEnemiesIter_t iter; + for( AI_EnemyInfo_t *eMemory = GetEnemies()->GetFirst(&iter); eMemory != NULL; eMemory = GetEnemies()->GetNext(&iter) ) + { + if (eMemory->hEnemy) + { + CBaseCombatCharacter *npcEnemy = (eMemory->hEnemy)->MyCombatCharacterPointer(); + if (npcEnemy) + { + float r,g,b; + char debugText[255]; + debugText[0] = NULL; + + if (npcEnemy == GetEnemy()) + { + Q_strncat(debugText,"Current Enemy", sizeof( debugText ), COPY_ALL_CHARACTERS ); + } + else if (npcEnemy == GetTarget()) + { + Q_strncat(debugText,"Current Target", sizeof( debugText ), COPY_ALL_CHARACTERS ); + } + else + { + Q_strncat(debugText,"Other Memory", sizeof( debugText ), COPY_ALL_CHARACTERS ); + } + if (IsUnreachable(npcEnemy)) + { + Q_strncat(debugText," (Unreachable)", sizeof( debugText ), COPY_ALL_CHARACTERS ); + } + if (eMemory->bEludedMe) + { + Q_strncat(debugText," (Eluded)", sizeof( debugText ), COPY_ALL_CHARACTERS ); + } + // Unreachable enemy drawn in green + if (IsUnreachable(npcEnemy)) + { + r = 0; + g = 255; + b = 0; + } + // Eluded enemy drawn in blue + else if (eMemory->bEludedMe) + { + r = 0; + g = 0; + b = 255; + } + // Current enemy drawn in red + else if (npcEnemy == GetEnemy()) + { + r = 255; + g = 0; + b = 0; + } + // Current traget drawn in magenta + else if (npcEnemy == GetTarget()) + { + r = 255; + g = 0; + b = 255; + } + // All other enemies drawn in pink + else + { + r = 255; + g = 100; + b = 100; + } + + + Vector drawPos = eMemory->vLastKnownLocation; + NDebugOverlay::Text( drawPos, debugText, false, 0.0 ); + + // If has a line on the player draw cross slightly in front so player can see + if (npcEnemy->IsPlayer() && + (eMemory->vLastKnownLocation - npcEnemy->GetAbsOrigin()).Length()<10 ) + { + Vector vEnemyFacing = npcEnemy->BodyDirection2D( ); + Vector eyePos = npcEnemy->EyePosition() + vEnemyFacing*10.0; + Vector upVec = Vector(0,0,2); + Vector sideVec; + CrossProduct( vEnemyFacing, upVec, sideVec); + NDebugOverlay::Line(eyePos+sideVec+upVec, eyePos-sideVec-upVec, r,g,b, false,0); + NDebugOverlay::Line(eyePos+sideVec-upVec, eyePos-sideVec+upVec, r,g,b, false,0); + + NDebugOverlay::Text( eyePos, debugText, false, 0.0 ); + } + else + { + NDebugOverlay::Cross3D(drawPos,NAI_Hull::Mins(npcEnemy->GetHullType()),NAI_Hull::Maxs(npcEnemy->GetHullType()),r,g,b,false,0); + } + } + } + } + } + + // ---------------------------------------------- + // Draw line to target and enemy entity if exist + // ---------------------------------------------- + if ((m_debugOverlays & OVERLAY_NPC_FOCUS_BIT)) + { + if (GetEnemy() != NULL) + { + NDebugOverlay::Line(EyePosition(),GetEnemy()->EyePosition(),255,0,0,true,0.0); + } + if (GetTarget() != NULL) + { + NDebugOverlay::Line(EyePosition(),GetTarget()->EyePosition(),0,0,255,true,0.0); + } + } + + + GetPathfinder()->DrawDebugGeometryOverlays(m_debugOverlays); + + CBaseEntity::DrawDebugGeometryOverlays(); +} + +//----------------------------------------------------------------------------- +// Purpose: Draw any debug text overlays +// Input : +// Output : Current text offset from the top +//----------------------------------------------------------------------------- +int CAI_BaseNPC::DrawDebugTextOverlays(void) +{ + int text_offset = 0; + + // --------------------- + // Print Baseclass text + // --------------------- + text_offset = BaseClass::DrawDebugTextOverlays(); + + if (m_debugOverlays & OVERLAY_NPC_SQUAD_BIT) + { + // Print health + char tempstr[512]; + Q_snprintf(tempstr,sizeof(tempstr),"Health: %i",m_iHealth.Get()); + EntityText(text_offset,tempstr,0); + text_offset++; + + // Print squad name + Q_strncpy(tempstr,"Squad: ",sizeof(tempstr)); + if (m_pSquad) + { + Q_strncat(tempstr,m_pSquad->GetName(),sizeof(tempstr), COPY_ALL_CHARACTERS); + + if( m_pSquad->GetLeader() == this ) + { + Q_strncat(tempstr," (LEADER)",sizeof(tempstr), COPY_ALL_CHARACTERS); + } + + Q_strncat(tempstr,"\n",sizeof(tempstr), COPY_ALL_CHARACTERS); + } + else + { + Q_strncat(tempstr," - \n",sizeof(tempstr), COPY_ALL_CHARACTERS); + } + EntityText(text_offset,tempstr,0); + text_offset++; + + // Print enemy name + Q_strncpy(tempstr,"Enemy: ",sizeof(tempstr)); + if (GetEnemy()) + { + if (GetEnemy()->GetEntityName() != NULL_STRING) + { + Q_strncat(tempstr,STRING(GetEnemy()->GetEntityName()),sizeof(tempstr), COPY_ALL_CHARACTERS); + Q_strncat(tempstr,"\n",sizeof(tempstr), COPY_ALL_CHARACTERS); + } + else + { + Q_strncat(tempstr,STRING(GetEnemy()->m_iClassname),sizeof(tempstr), COPY_ALL_CHARACTERS); + Q_strncat(tempstr,"\n",sizeof(tempstr), COPY_ALL_CHARACTERS); + } + } + else + { + Q_strncat(tempstr," - \n",sizeof(tempstr), COPY_ALL_CHARACTERS); + } + EntityText(text_offset,tempstr,0); + text_offset++; + + // Print slot + Q_snprintf(tempstr,sizeof(tempstr),"Slot: %s (%d)\n", + SquadSlotName(m_iMySquadSlot), m_iMySquadSlot); + EntityText(text_offset,tempstr,0); + text_offset++; + + } + + if (m_debugOverlays & OVERLAY_TEXT_BIT) + { + char tempstr[512]; + // -------------- + // Print Health + // -------------- + Q_snprintf(tempstr,sizeof(tempstr),"Health: %i (DACC:%1.2f)",m_iHealth.Get(), GetDamageAccumulator() ); + EntityText(text_offset,tempstr,0); + text_offset++; + + // -------------- + // Print State + // -------------- + static const char *pStateNames[] = { "None", "Idle", "Alert", "Combat", "Scripted", "PlayDead", "Dead" }; + if ( (int)m_NPCState < ARRAYSIZE(pStateNames) ) + { + Q_snprintf(tempstr,sizeof(tempstr),"Stat: %s, ", pStateNames[m_NPCState] ); + EntityText(text_offset,tempstr,0); + text_offset++; + } + + // ----------------- + // Start Scripting? + // ----------------- + if( IsInAScript() ) + { + Q_snprintf(tempstr,sizeof(tempstr),"STARTSCRIPTING" ); + EntityText(text_offset,tempstr,0); + text_offset++; + } + + // ----------------- + // Hint Group? + // ----------------- + if( GetHintGroup() != NULL_STRING ) + { + Q_snprintf(tempstr,sizeof(tempstr),"Hint Group: %s", STRING(GetHintGroup()) ); + EntityText(text_offset,tempstr,0); + text_offset++; + } + + // ----------------- + // Print MotionType + // ----------------- + int navTypeIndex = (int)GetNavType() + 1; + static const char *pMoveNames[] = { "None", "Ground", "Jump", "Fly", "Climb" }; + Assert( navTypeIndex >= 0 && navTypeIndex < ARRAYSIZE(pMoveNames) ); + if ( navTypeIndex < ARRAYSIZE(pMoveNames) ) + { + Q_snprintf(tempstr,sizeof(tempstr),"Move: %s, ", pMoveNames[navTypeIndex] ); + EntityText(text_offset,tempstr,0); + text_offset++; + } + + // -------------- + // Print Schedule + // -------------- + if ( GetCurSchedule() ) + { + CAI_BehaviorBase *pBehavior = GetRunningBehavior(); + if ( pBehavior ) + { + Q_snprintf(tempstr,sizeof(tempstr),"Behv: %s, ", pBehavior->GetName() ); + EntityText(text_offset,tempstr,0); + text_offset++; + } + + const char *pName = NULL; + pName = GetCurSchedule()->GetName(); + if ( !pName ) + { + pName = "Unknown"; + } + Q_snprintf(tempstr,sizeof(tempstr),"Schd: %s, ", pName ); + EntityText(text_offset,tempstr,0); + text_offset++; + + if (m_debugOverlays & OVERLAY_NPC_TASK_BIT) + { + for (int i = 0 ; i < GetCurSchedule()->NumTasks(); i++) + { + Q_snprintf(tempstr,sizeof(tempstr),"%s%s%s%s", + ((i==0) ? "Task:":" "), + ((i==GetScheduleCurTaskIndex()) ? "->" :" "), + TaskName(GetCurSchedule()->GetTaskList()[i].iTask), + ((i==GetScheduleCurTaskIndex()) ? "<-" :"")); + + EntityText(text_offset,tempstr,0); + text_offset++; + } + } + else + { + const Task_t *pTask = GetTask(); + if ( pTask ) + { + Q_snprintf(tempstr,sizeof(tempstr),"Task: %s (#%d), ", TaskName(pTask->iTask), GetScheduleCurTaskIndex() ); + } + else + { + Q_strncpy(tempstr,"Task: None",sizeof(tempstr)); + } + EntityText(text_offset,tempstr,0); + text_offset++; + } + } + + // -------------- + // Print Acitivity + // -------------- + if( m_Activity != ACT_INVALID && m_IdealActivity != ACT_INVALID && m_Activity != ACT_RESET) + { + Activity iActivity = TranslateActivity( m_Activity ); + + Activity iIdealActivity = Weapon_TranslateActivity( m_IdealActivity ); + iIdealActivity = NPC_TranslateActivity( iIdealActivity ); + + const char *pszActivity = GetActivityName( iActivity ); + const char *pszIdealActivity = GetActivityName( iIdealActivity ); + const char *pszRootActivity = GetActivityName( m_Activity ); + + Q_snprintf(tempstr,sizeof(tempstr),"Actv: %s (%s) [%s]\n", pszActivity, pszIdealActivity, pszRootActivity ); + } + else if (m_Activity == ACT_RESET) + { + Q_strncpy(tempstr,"Actv: RESET",sizeof(tempstr) ); + } + else + { + Q_strncpy(tempstr,"Actv: INVALID", sizeof(tempstr) ); + } + EntityText(text_offset,tempstr,0); + text_offset++; + + // + // Print all the current conditions. + // + if (m_debugOverlays & OVERLAY_NPC_CONDITIONS_BIT) + { + bool bHasConditions = false; + for (int i = 0; i < MAX_CONDITIONS; i++) + { + if (m_Conditions.IsBitSet(i)) + { + Q_snprintf(tempstr, sizeof(tempstr), "Cond: %s\n", ConditionName(AI_RemapToGlobal(i))); + EntityText(text_offset, tempstr, 0); + text_offset++; + bHasConditions = true; + } + } + if (!bHasConditions) + { + Q_snprintf(tempstr,sizeof(tempstr),"(no conditions)"); + EntityText(text_offset,tempstr,0); + text_offset++; + } + } + + if ( GetFlags() & FL_FLY ) + { + EntityText(text_offset,"HAS FL_FLY",0); + text_offset++; + } + + // -------------- + // Print Interrupte + // -------------- + if (m_interuptSchedule) + { + const char *pName = NULL; + pName = m_interuptSchedule->GetName(); + if ( !pName ) + { + pName = "Unknown"; + } + + Q_snprintf(tempstr,sizeof(tempstr),"Intr: %s (%s)\n", pName, m_interruptText ); + EntityText(text_offset,tempstr,0); + text_offset++; + } + + // -------------- + // Print Failure + // -------------- + if (m_failedSchedule) + { + const char *pName = NULL; + pName = m_failedSchedule->GetName(); + if ( !pName ) + { + pName = "Unknown"; + } + Q_snprintf(tempstr,sizeof(tempstr),"Fail: %s (%s)\n", pName,m_failText ); + EntityText(text_offset,tempstr,0); + text_offset++; + } + + + // ------------------------------- + // Print any important condtions + // ------------------------------- + if (HasCondition(COND_ENEMY_TOO_FAR)) + { + EntityText(text_offset,"Enemy too far to attack",0); + text_offset++; + } + if ( GetAbsVelocity() != vec3_origin || GetLocalAngularVelocity() != vec3_angle ) + { + char tmp[512]; + Q_snprintf( tmp, sizeof(tmp), "Vel %.1f %.1f %.1f Ang: %.1f %.1f %.1f\n", + GetAbsVelocity().x, GetAbsVelocity().y, GetAbsVelocity().z, + GetLocalAngularVelocity().x, GetLocalAngularVelocity().y, GetLocalAngularVelocity().z ); + EntityText(text_offset,tmp,0); + text_offset++; + } + + // ------------------------------- + // Print shot accuracy + // ------------------------------- + if ( m_LastShootAccuracy != -1 && ai_shot_stats.GetBool() ) + { + CFmtStr msg; + EntityText(text_offset,msg.sprintf("Cur Accuracy: %.1f", m_LastShootAccuracy),0); + text_offset++; + if ( m_TotalShots ) + { + EntityText(text_offset,msg.sprintf("Act Accuracy: %.1f", ((float)m_TotalHits/(float)m_TotalShots)*100.0),0); + text_offset++; + } + + if ( GetActiveWeapon() && GetEnemy() ) + { + Vector curSpread = GetAttackSpread(GetActiveWeapon(), GetEnemy()); + float curCone = RAD2DEG(asin(curSpread.x)) * 2; + float bias = GetSpreadBias( GetActiveWeapon(), GetEnemy()); + EntityText(text_offset,msg.sprintf("Cone %.1f, Bias %.2f", curCone, bias),0); + text_offset++; + } + } + + if ( GetGoalEnt() && GetNavigator()->GetGoalType() == GOALTYPE_PATHCORNER ) + { + Q_strncpy(tempstr,"Pathcorner/goal ent: ",sizeof(tempstr)); + if (GetGoalEnt()->GetEntityName() != NULL_STRING) + { + Q_strncat(tempstr,STRING(GetGoalEnt()->GetEntityName()),sizeof(tempstr), COPY_ALL_CHARACTERS); + } + else + { + Q_strncat(tempstr,STRING(GetGoalEnt()->m_iClassname),sizeof(tempstr), COPY_ALL_CHARACTERS); + } + EntityText(text_offset, tempstr, 0); + text_offset++; + } + + if ( VPhysicsGetObject() ) + { + vphysics_objectstress_t stressOut; + CalculateObjectStress( VPhysicsGetObject(), this, &stressOut ); + Q_snprintf(tempstr, sizeof(tempstr),"Stress: %.2f", stressOut.receivedStress ); + EntityText(text_offset, tempstr, 0); + text_offset++; + } + if ( m_pSquad ) + { + if( m_pSquad->IsLeader(this) ) + { + Q_snprintf(tempstr, sizeof(tempstr),"**Squad Leader**" ); + EntityText(text_offset, tempstr, 0); + text_offset++; + } + + Q_snprintf(tempstr, sizeof(tempstr), "SquadSlot:%s", GetSquadSlotDebugName( GetMyStrategySlot() ) ); + EntityText(text_offset, tempstr, 0); + text_offset++; + } + } + return text_offset; +} + + +//----------------------------------------------------------------------------- +// Purpose: Displays information in the console about the state of this npc. +//----------------------------------------------------------------------------- +void CAI_BaseNPC::ReportAIState( void ) +{ + static const char *pStateNames[] = { "None", "Idle", "Alert", "Combat", "Scripted", "PlayDead", "Dead" }; + + DevMsg( "%s: ", GetClassname() ); + if ( (int)m_NPCState < ARRAYSIZE(pStateNames) ) + DevMsg( "State: %s, ", pStateNames[m_NPCState] ); + + if( m_Activity != ACT_INVALID && m_IdealActivity != ACT_INVALID ) + { + const char *pszActivity = GetActivityName(m_Activity); + const char *pszIdealActivity = GetActivityName(m_IdealActivity); + + DevMsg( "Activity: %s - Ideal Activity: %s\n", pszActivity, pszIdealActivity ); + } + + if ( GetCurSchedule() ) + { + const char *pName = NULL; + pName = GetCurSchedule()->GetName(); + if ( !pName ) + pName = "Unknown"; + DevMsg( "Schedule %s, ", pName ); + const Task_t *pTask = GetTask(); + if ( pTask ) + DevMsg( "Task %d (#%d), ", pTask->iTask, GetScheduleCurTaskIndex() ); + } + else + DevMsg( "No Schedule, " ); + + if ( GetEnemy() != NULL ) + { + g_pEffects->Sparks( GetEnemy()->GetAbsOrigin() + Vector( 0, 0, 64 ) ); + DevMsg( "\nEnemy is %s", GetEnemy()->GetClassname() ); + } + else + DevMsg( "No enemy " ); + + if ( IsMoving() ) + { + DevMsg( " Moving " ); + if ( m_flMoveWaitFinished > gpGlobals->curtime ) + DevMsg( ": Stopped for %.2f. ", m_flMoveWaitFinished - gpGlobals->curtime ); + else if ( m_IdealActivity == GetStoppedActivity() ) + DevMsg( ": In stopped anim. " ); + } + + DevMsg( "Leader." ); + + DevMsg( "\n" ); + DevMsg( "Yaw speed:%3.1f,Health: %3d\n", GetMotor()->GetYawSpeed(), m_iHealth.Get() ); + + if ( GetGroundEntity() ) + { + DevMsg( "Groundent:%s\n\n", GetGroundEntity()->GetClassname() ); + } + else + { + DevMsg( "Groundent: NULL\n\n" ); + } +} + +//----------------------------------------------------------------------------- + +ConVar ai_report_task_timings_on_limit( "ai_report_task_timings_on_limit", "0", FCVAR_ARCHIVE ); +ConVar ai_think_limit_label( "ai_think_limit_label", "0", FCVAR_ARCHIVE ); + +void CAI_BaseNPC::ReportOverThinkLimit( float time ) +{ + DevMsg( "%s thinking for %.02fms!!! (%s); r%.2f (c%.2f, pst%.2f, ms%.2f), p-r%.2f, m%.2f\n", + GetDebugName(), time, GetCurSchedule()->GetName(), + g_AIRunTimer.GetDuration().GetMillisecondsF(), + g_AIConditionsTimer.GetDuration().GetMillisecondsF(), + g_AIPrescheduleThinkTimer.GetDuration().GetMillisecondsF(), + g_AIMaintainScheduleTimer.GetDuration().GetMillisecondsF(), + g_AIPostRunTimer.GetDuration().GetMillisecondsF(), + g_AIMoveTimer.GetDuration().GetMillisecondsF() ); + + if (ai_think_limit_label.GetBool()) + { + Vector tmp; + CollisionProp()->NormalizedToWorldSpace( Vector( 0.5f, 0.5f, 1.0f ), &tmp ); + tmp.z += 16; + + float max = -1; + const char *pszMax = "unknown"; + + if ( g_AIConditionsTimer.GetDuration().GetMillisecondsF() > max ) + { + max = g_AIConditionsTimer.GetDuration().GetMillisecondsF(); + pszMax = "Conditions"; + } + if ( g_AIPrescheduleThinkTimer.GetDuration().GetMillisecondsF() > max ) + { + max = g_AIPrescheduleThinkTimer.GetDuration().GetMillisecondsF(); + pszMax = "Pre-think"; + } + if ( g_AIMaintainScheduleTimer.GetDuration().GetMillisecondsF() > max ) + { + max = g_AIMaintainScheduleTimer.GetDuration().GetMillisecondsF(); + pszMax = "Schedule"; + } + if ( g_AIPostRunTimer.GetDuration().GetMillisecondsF() > max ) + { + max = g_AIPostRunTimer.GetDuration().GetMillisecondsF(); + pszMax = "Post-run"; + } + if ( g_AIMoveTimer.GetDuration().GetMillisecondsF() > max ) + { + max = g_AIMoveTimer.GetDuration().GetMillisecondsF(); + pszMax = "Move"; + } + NDebugOverlay::Text( tmp, (char*)(const char *)CFmtStr( "Slow %.1f, %s %.1f ", time, pszMax, max ), false, 1 ); + } + + if ( ai_report_task_timings_on_limit.GetBool() ) + DumpTaskTimings(); +} + +//----------------------------------------------------------------------------- +// Purpose: Returns whether or not this npc can play the scripted sequence or AI +// sequence that is trying to possess it. If DisregardState is set, the npc +// will be sucked into the script no matter what state it is in. ONLY +// Scripted AI ents should allow this. +// Input : fDisregardNPCState - +// interruptLevel - +// eMode - If the function returns true, eMode will be one of the following values: +// CAN_PLAY_NOW +// CAN_PLAY_ENQUEUED +// Output : +//----------------------------------------------------------------------------- +CanPlaySequence_t CAI_BaseNPC::CanPlaySequence( bool fDisregardNPCState, int interruptLevel ) +{ + CanPlaySequence_t eReturn = CAN_PLAY_NOW; + + if ( m_hCine ) + { + if ( !m_hCine->CanEnqueueAfter() ) + { + // npc is already running one scripted sequence and has an important script to play next + return CANNOT_PLAY; + } + + eReturn = CAN_PLAY_ENQUEUED; + } + + if ( !IsAlive() ) + { + // npc is dead! + return CANNOT_PLAY; + } + + // An NPC in a vehicle cannot play a scripted sequence + if ( IsInAVehicle() ) + return CANNOT_PLAY; + + if ( fDisregardNPCState ) + { + // ok to go, no matter what the npc state. (scripted AI) + + // No clue as to how to proced if they're climbing or jumping + // Assert( GetNavType() != NAV_JUMP && GetNavType() != NAV_CLIMB ); + + return eReturn; + } + + if ( m_NPCState == NPC_STATE_NONE || m_NPCState == NPC_STATE_IDLE || m_IdealNPCState == NPC_STATE_IDLE ) + { + // ok to go, but only in these states + return eReturn; + } + + if ( m_NPCState == NPC_STATE_ALERT && interruptLevel >= SS_INTERRUPT_BY_NAME ) + { + return eReturn; + } + + // unknown situation + return CANNOT_PLAY; +} + + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::SetHintGroup( string_t newGroup, bool bHintGroupNavLimiting ) +{ + string_t oldGroup = m_strHintGroup; + m_strHintGroup = newGroup; + m_bHintGroupNavLimiting = bHintGroupNavLimiting; + + if ( oldGroup != newGroup ) + OnChangeHintGroup( oldGroup, newGroup ); + +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : +// Output : +//----------------------------------------------------------------------------- +Vector CAI_BaseNPC::GetShootEnemyDir( const Vector &shootOrigin, bool bNoisy ) +{ + CBaseEntity *pEnemy = GetEnemy(); + + if ( pEnemy ) + { + Vector vecEnemyLKP = GetEnemyLKP(); + + Vector vecEnemyOffset = pEnemy->BodyTarget( shootOrigin, bNoisy ) - pEnemy->GetAbsOrigin(); + +#ifdef PORTAL + // Translate the enemy's position across the portals if it's only seen in the portal view cone + if ( !FInViewCone( vecEnemyLKP ) || !FVisible( vecEnemyLKP ) ) + { + CProp_Portal *pPortal = FInViewConeThroughPortal( vecEnemyLKP ); + if ( pPortal ) + { + UTIL_Portal_VectorTransform( pPortal->m_hLinkedPortal->MatrixThisToLinked(), vecEnemyOffset, vecEnemyOffset ); + UTIL_Portal_PointTransform( pPortal->m_hLinkedPortal->MatrixThisToLinked(), vecEnemyLKP, vecEnemyLKP ); + } + } +#endif + + Vector retval = vecEnemyOffset + vecEnemyLKP - shootOrigin; + VectorNormalize( retval ); + return retval; + } + else + { + Vector forward; + AngleVectors( GetLocalAngles(), &forward ); + return forward; + } +} + +//----------------------------------------------------------------------------- +// Simulates many times and reports statistical accuracy. +//----------------------------------------------------------------------------- +void CAI_BaseNPC::CollectShotStats( const Vector &vecShootOrigin, const Vector &vecShootDir ) +{ +#ifdef HL2_DLL + if( ai_shot_stats.GetBool() != 0 && GetEnemy()->IsPlayer() ) + { + int iterations = ai_shot_stats_term.GetInt(); + int iHits = 0; + Vector testDir = vecShootDir; + + CShotManipulator manipulator( testDir ); + + for( int i = 0 ; i < iterations ; i++ ) + { + // Apply appropriate accuracy. + manipulator.ApplySpread( GetAttackSpread( GetActiveWeapon(), GetEnemy() ), GetSpreadBias( GetActiveWeapon(), GetEnemy() ) ); + Vector shotDir = manipulator.GetResult(); + + Vector vecEnd = vecShootOrigin + shotDir * 8192; + + trace_t tr; + AI_TraceLine( vecShootOrigin, vecEnd, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr); + + if( tr.m_pEnt && tr.m_pEnt == GetEnemy() ) + { + iHits++; + } + Vector vecProjectedPosition = GetActualShootPosition( vecShootOrigin ); + Vector testDir = vecProjectedPosition - vecShootOrigin; + VectorNormalize( testDir ); + manipulator.SetShootDir( testDir ); + } + + float flHitPercent = ((float)iHits / (float)iterations) * 100.0; + m_LastShootAccuracy = flHitPercent; + //DevMsg("Shots:%d Hits:%d Percentage:%.1f\n", iterations, iHits, flHitPercent); + } + else + { + m_LastShootAccuracy = -1; + } +#endif +} + +#ifdef HL2_DLL +//----------------------------------------------------------------------------- +// Purpose: Return the actual position the NPC wants to fire at when it's trying +// to hit it's current enemy. +//----------------------------------------------------------------------------- +Vector CAI_BaseNPC::GetActualShootPosition( const Vector &shootOrigin ) +{ + // Project the target's location into the future. + Vector vecEnemyLKP = GetEnemyLKP(); + Vector vecEnemyOffset = GetEnemy()->BodyTarget( shootOrigin ) - GetEnemy()->GetAbsOrigin(); + Vector vecTargetPosition = vecEnemyOffset + vecEnemyLKP; + +#ifdef PORTAL + // Check if it's also visible through portals + CProp_Portal *pPortal = FInViewConeThroughPortal( vecEnemyLKP ); + if ( pPortal ) + { + // Get the target's position through portals + Vector vecEnemyOffsetTransformed; + Vector vecEnemyLKPTransformed; + UTIL_Portal_VectorTransform( pPortal->m_hLinkedPortal->MatrixThisToLinked(), vecEnemyOffset, vecEnemyOffsetTransformed ); + UTIL_Portal_PointTransform( pPortal->m_hLinkedPortal->MatrixThisToLinked(), vecEnemyLKP, vecEnemyLKPTransformed ); + Vector vecTargetPositionTransformed = vecEnemyOffsetTransformed + vecEnemyLKPTransformed; + + // Get the distance to the target with and without portals + float fDistanceToEnemyThroughPortalSqr = GetAbsOrigin().DistToSqr( vecTargetPositionTransformed ); + float fDistanceToEnemySqr = GetAbsOrigin().DistToSqr( vecTargetPosition ); + + if ( fDistanceToEnemyThroughPortalSqr < fDistanceToEnemySqr || !FInViewCone( vecEnemyLKP ) || !FVisible( vecEnemyLKP ) ) + { + // We're better off shooting through the portals + vecTargetPosition = vecTargetPositionTransformed; + } + } +#endif + + // lead for some fraction of a second. + return (vecTargetPosition + ( GetEnemy()->GetSmoothedVelocity() * ai_lead_time.GetFloat() )); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +float CAI_BaseNPC::GetSpreadBias( CBaseCombatWeapon *pWeapon, CBaseEntity *pTarget ) +{ + float bias = BaseClass::GetSpreadBias( pWeapon, pTarget ); + AI_EnemyInfo_t *pEnemyInfo = m_pEnemies->Find( pTarget ); + if ( ai_shot_bias.GetFloat() != 1.0 ) + bias = ai_shot_bias.GetFloat(); + if ( pEnemyInfo ) + { + float timeToFocus = ai_spread_pattern_focus_time.GetFloat(); + if ( timeToFocus > 0.0 ) + { + float timeSinceValidEnemy = gpGlobals->curtime - pEnemyInfo->timeValidEnemy; + if ( timeSinceValidEnemy < 0.0f ) + { + timeSinceValidEnemy = 0.0f; + } + float timeSinceReacquire = gpGlobals->curtime - pEnemyInfo->timeLastReacquired; + if ( timeSinceValidEnemy < timeToFocus ) + { + float scale = timeSinceValidEnemy / timeToFocus; + Assert( scale >= 0.0 && scale <= 1.0 ); + bias *= scale; + } + else if ( timeSinceReacquire < timeToFocus ) // handled seperately as might be tuning seperately + { + float scale = timeSinceReacquire / timeToFocus; + Assert( scale >= 0.0 && scale <= 1.0 ); + bias *= scale; + } + + } + } + return bias; +} + +//----------------------------------------------------------------------------- +Vector CAI_BaseNPC::GetAttackSpread( CBaseCombatWeapon *pWeapon, CBaseEntity *pTarget ) +{ + Vector baseResult = BaseClass::GetAttackSpread( pWeapon, pTarget ); + + AI_EnemyInfo_t *pEnemyInfo = m_pEnemies->Find( pTarget ); + if ( pEnemyInfo ) + { + float timeToFocus = ai_spread_cone_focus_time.GetFloat(); + if ( timeToFocus > 0.0 ) + { + float timeSinceValidEnemy = gpGlobals->curtime - pEnemyInfo->timeValidEnemy; + if ( timeSinceValidEnemy < 0 ) + timeSinceValidEnemy = 0; + if ( timeSinceValidEnemy < timeToFocus ) + { + float coneMultiplier = ai_spread_defocused_cone_multiplier.GetFloat(); + if ( coneMultiplier > 1.0 ) + { + float scale = 1.0 - timeSinceValidEnemy / timeToFocus; + Assert( scale >= 0.0 && scale <= 1.0 ); + float multiplier = ( (coneMultiplier - 1.0) * scale ) + 1.0; + baseResult *= multiplier; + } + } + } + } + return baseResult; +} + +//----------------------------------------------------------------------------- +// Similar to calling GetShootEnemyDir, but returns the exact trajectory to +// fire the bullet along, after calculating for target speed, location, +// concealment, etc. +// +// Ultimately, this code results in the shooter aiming his weapon somewhere ahead of +// a moving target. Since bullet traces are instant, aiming ahead of a target +// will result in more misses than hits. This is designed to provide targets with +// a bonus when moving perpendicular to the shooter's line of sight. +// +// Do not confuse this with leading a target in an effort to more easily hit it. +// +// This code PENALIZES a target for moving directly along the shooter's line of sight. +// +// This code REWARDS a target for moving perpendicular to the shooter's line of sight. +//----------------------------------------------------------------------------- +Vector CAI_BaseNPC::GetActualShootTrajectory( const Vector &shootOrigin ) +{ + if( !GetEnemy() ) + return GetShootEnemyDir( shootOrigin ); + + // If we're above water shooting at a player underwater, bias some of the shots forward of + // the player so that they see the cool bubble trails in the water ahead of them. + if (GetEnemy()->IsPlayer() && (GetWaterLevel() != 3) && (GetEnemy()->GetWaterLevel() == 3)) + { +#if 1 + if (random->RandomInt(0, 4) < 3) + { + Vector vecEnemyForward; + GetEnemy()->GetVectors( &vecEnemyForward, NULL, NULL ); + vecEnemyForward.z = 0; + + // Lead up to a second ahead of them unless they are moving backwards. + Vector vecEnemyVelocity = GetEnemy()->GetSmoothedVelocity(); + VectorNormalize( vecEnemyVelocity ); + float flVelocityScale = vecEnemyForward.Dot( vecEnemyVelocity ); + if ( flVelocityScale < 0.0f ) + { + flVelocityScale = 0.0f; + } + + Vector vecAimPos = GetEnemy()->EyePosition() + ( 48.0f * vecEnemyForward ) + (flVelocityScale * GetEnemy()->GetSmoothedVelocity() ); + //NDebugOverlay::Cross3D(vecAimPos, Vector(-16,-16,-16), Vector(16,16,16), 255, 255, 0, true, 1.0f ); + + //vecAimPos.z = UTIL_WaterLevel( vecAimPos, vecAimPos.z, vecAimPos.z + 400.0f ); + //NDebugOverlay::Cross3D(vecAimPos, Vector(-32,-32,-32), Vector(32,32,32), 255, 0, 0, true, 1.0f ); + + Vector vecShotDir = vecAimPos - shootOrigin; + VectorNormalize( vecShotDir ); + return vecShotDir; + } +#else + if (random->RandomInt(0, 4) < 3) + { + // Aim at a point a few feet in front of the player's eyes + Vector vecEnemyForward; + GetEnemy()->GetVectors( &vecEnemyForward, NULL, NULL ); + + Vector vecAimPos = GetEnemy()->EyePosition() + (120.0f * vecEnemyForward ); + + Vector vecShotDir = vecAimPos - shootOrigin; + VectorNormalize( vecShotDir ); + + CShotManipulator manipulator( vecShotDir ); + manipulator.ApplySpread( VECTOR_CONE_10DEGREES, 1 ); + vecShotDir = manipulator.GetResult(); + + return vecShotDir; + } +#endif + } + + Vector vecProjectedPosition = GetActualShootPosition( shootOrigin ); + + Vector shotDir = vecProjectedPosition - shootOrigin; + VectorNormalize( shotDir ); + + CollectShotStats( shootOrigin, shotDir ); + + // NOW we have a shoot direction. Where a 100% accurate bullet should go. + // Modify it by weapon proficiency. + // construct a manipulator + CShotManipulator manipulator( shotDir ); + + // Apply appropriate accuracy. + bool bUsePerfectAccuracy = false; + if ( GetEnemy() && GetEnemy()->Classify() == CLASS_BULLSEYE ) + { + CNPC_Bullseye *pBullseye = dynamic_cast(GetEnemy()); + if ( pBullseye && pBullseye->UsePerfectAccuracy() ) + { + bUsePerfectAccuracy = true; + } + } + + if ( !bUsePerfectAccuracy ) + { + manipulator.ApplySpread( GetAttackSpread( GetActiveWeapon(), GetEnemy() ), GetSpreadBias( GetActiveWeapon(), GetEnemy() ) ); + shotDir = manipulator.GetResult(); + } + + // Look for an opportunity to make misses hit interesting things. + CBaseCombatCharacter *pEnemy; + + pEnemy = GetEnemy()->MyCombatCharacterPointer(); + + if( pEnemy && pEnemy->ShouldShootMissTarget( this ) ) + { + Vector vecEnd = shootOrigin + shotDir * 8192; + trace_t tr; + + AI_TraceLine(shootOrigin, vecEnd, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr); + + if( tr.fraction != 1.0 && tr.m_pEnt && tr.m_pEnt->m_takedamage != DAMAGE_NO ) + { + // Hit something we can harm. Just shoot it. + return manipulator.GetResult(); + } + + // Find something interesting around the enemy to shoot instead of just missing. + CBaseEntity *pMissTarget = pEnemy->FindMissTarget(); + + if( pMissTarget ) + { + shotDir = pMissTarget->WorldSpaceCenter() - shootOrigin; + VectorNormalize( shotDir ); + } + } + + return shotDir; +} +#endif // HL2_DLL + +//----------------------------------------------------------------------------- + +Vector CAI_BaseNPC::BodyTarget( const Vector &posSrc, bool bNoisy ) +{ + Vector low = WorldSpaceCenter() - ( WorldSpaceCenter() - GetAbsOrigin() ) * .25; + Vector high = EyePosition(); + Vector delta = high - low; + Vector result; + if ( bNoisy ) + { + // bell curve + float rand1 = random->RandomFloat( 0.0, 0.5 ); + float rand2 = random->RandomFloat( 0.0, 0.5 ); + result = low + delta * rand1 + delta * rand2; + } + else + result = low + delta * 0.5; + + return result; +} + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::ShouldMoveAndShoot() +{ + return ( ( CapabilitiesGet() & bits_CAP_MOVE_SHOOT ) != 0 ); +} + + +//========================================================= +// FacingIdeal - tells us if a npc is facing its ideal +// yaw. Created this function because many spots in the +// code were checking the yawdiff against this magic +// number. Nicer to have it in one place if we're gonna +// be stuck with it. +//========================================================= +bool CAI_BaseNPC::FacingIdeal( void ) +{ + if ( fabs( GetMotor()->DeltaIdealYaw() ) <= 0.006 )//!!!BUGBUG - no magic numbers!!! + { + return true; + } + + return false; +} + +//--------------------------------- + +void CAI_BaseNPC::AddFacingTarget( CBaseEntity *pTarget, float flImportance, float flDuration, float flRamp ) +{ + GetMotor()->AddFacingTarget( pTarget, flImportance, flDuration, flRamp ); +} + +void CAI_BaseNPC::AddFacingTarget( const Vector &vecPosition, float flImportance, float flDuration, float flRamp ) +{ + GetMotor()->AddFacingTarget( vecPosition, flImportance, flDuration, flRamp ); +} + +void CAI_BaseNPC::AddFacingTarget( CBaseEntity *pTarget, const Vector &vecPosition, float flImportance, float flDuration, float flRamp ) +{ + GetMotor()->AddFacingTarget( pTarget, vecPosition, flImportance, flDuration, flRamp ); +} + +float CAI_BaseNPC::GetFacingDirection( Vector &vecDir ) +{ + return (GetMotor()->GetFacingDirection( vecDir )); +} + + +//--------------------------------- + + +int CAI_BaseNPC::PlaySentence( const char *pszSentence, float delay, float volume, soundlevel_t soundlevel, CBaseEntity *pListener ) +{ + int sentenceIndex = -1; + + if ( pszSentence && IsAlive() ) + { + + if ( pszSentence[0] == '!' ) + { + sentenceIndex = SENTENCEG_Lookup( pszSentence ); + CPASAttenuationFilter filter( this, soundlevel ); + CBaseEntity::EmitSentenceByIndex( filter, entindex(), CHAN_VOICE, sentenceIndex, volume, soundlevel, 0, PITCH_NORM ); + } + else + { + sentenceIndex = SENTENCEG_PlayRndSz( edict(), pszSentence, volume, soundlevel, 0, PITCH_NORM ); + } + } + + return sentenceIndex; +} + + +int CAI_BaseNPC::PlayScriptedSentence( const char *pszSentence, float delay, float volume, soundlevel_t soundlevel, bool bConcurrent, CBaseEntity *pListener ) +{ + return PlaySentence( pszSentence, delay, volume, soundlevel, pListener ); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : +// Output : +//----------------------------------------------------------------------------- +CBaseEntity *CAI_BaseNPC::FindNamedEntity( const char *name, IEntityFindFilter *pFilter ) +{ + if ( !stricmp( name, "!player" )) + { + return ( CBaseEntity * )AI_GetSinglePlayer(); + } + else if ( !stricmp( name, "!enemy" ) ) + { + if (GetEnemy() != NULL) + return GetEnemy(); + } + else if ( !stricmp( name, "!self" ) || !stricmp( name, "!target1" ) ) + { + return this; + } + else if ( !stricmp( name, "!nearestfriend" ) || !stricmp( name, "!friend" ) ) + { + // FIXME: look at CBaseEntity *CNPCSimpleTalker::FindNearestFriend(bool fPlayer) + // punt for now + return ( CBaseEntity * )AI_GetSinglePlayer(); + } + else if (!stricmp( name, "self" )) + { + static int selfwarningcount = 0; + + // fix the vcd, the reserved names have changed + if ( ++selfwarningcount < 5 ) + { + DevMsg( "ERROR: \"self\" is no longer used, use \"!self\" in vcd instead!\n" ); + } + return this; + } + else if ( !stricmp( name, "Player" )) + { + static int playerwarningcount = 0; + if ( ++playerwarningcount < 5 ) + { + DevMsg( "ERROR: \"player\" is no longer used, use \"!player\" in vcd instead!\n" ); + } + return ( CBaseEntity * )AI_GetSinglePlayer(); + } + else + { + // search for up to 32 entities with the same name and choose one randomly + CBaseEntity *entityList[ FINDNAMEDENTITY_MAX_ENTITIES ]; + CBaseEntity *entity; + int iCount; + + entity = NULL; + for( iCount = 0; iCount < FINDNAMEDENTITY_MAX_ENTITIES; iCount++ ) + { + entity = gEntList.FindEntityByName( entity, name, NULL, NULL, NULL, pFilter ); + if ( !entity ) + { + break; + } + entityList[ iCount ] = entity; + } + + if ( iCount > 0 ) + { + int index = RandomInt( 0, iCount - 1 ); + entity = entityList[ index ]; + return entity; + } + } + + return NULL; +} + + +void CAI_BaseNPC::CorpseFallThink( void ) +{ + if ( GetFlags() & FL_ONGROUND ) + { + SetThink ( NULL ); + + SetSequenceBox( ); + } + else + { + SetNextThink( gpGlobals->curtime + 0.1f ); + } +} + +// Call after animation/pose is set up +void CAI_BaseNPC::NPCInitDead( void ) +{ + InitBoneControllers(); + + RemoveSolidFlags( FSOLID_NOT_SOLID ); + + // so he'll fall to ground + SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_BOUNCE ); + + SetCycle( 0 ); + ResetSequenceInfo( ); + m_flPlaybackRate = 0; + + // Copy health + m_iMaxHealth = m_iHealth; + m_lifeState = LIFE_DEAD; + + UTIL_SetSize(this, vec3_origin, vec3_origin ); + + // Setup health counters, etc. + SetThink( &CAI_BaseNPC::CorpseFallThink ); + + SetNextThink( gpGlobals->curtime + 0.5f ); +} + +//========================================================= +// BBoxIsFlat - check to see if the npc's bounding box +// is lying flat on a surface (traces from all four corners +// are same length.) +//========================================================= +bool CAI_BaseNPC::BBoxFlat ( void ) +{ + trace_t tr; + Vector vecPoint; + float flXSize, flYSize; + float flLength; + float flLength2; + + flXSize = WorldAlignSize().x / 2; + flYSize = WorldAlignSize().y / 2; + + vecPoint.x = GetAbsOrigin().x + flXSize; + vecPoint.y = GetAbsOrigin().y + flYSize; + vecPoint.z = GetAbsOrigin().z; + + AI_TraceLine ( vecPoint, vecPoint - Vector ( 0, 0, 100 ), MASK_NPCSOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr ); + flLength = (vecPoint - tr.endpos).Length(); + + vecPoint.x = GetAbsOrigin().x - flXSize; + vecPoint.y = GetAbsOrigin().y - flYSize; + + AI_TraceLine ( vecPoint, vecPoint - Vector ( 0, 0, 100 ), MASK_NPCSOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr ); + flLength2 = (vecPoint - tr.endpos).Length(); + if ( flLength2 > flLength ) + { + return false; + } + flLength = flLength2; + + vecPoint.x = GetAbsOrigin().x - flXSize; + vecPoint.y = GetAbsOrigin().y + flYSize; + AI_TraceLine ( vecPoint, vecPoint - Vector ( 0, 0, 100 ), MASK_NPCSOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr ); + flLength2 = (vecPoint - tr.endpos).Length(); + if ( flLength2 > flLength ) + { + return false; + } + flLength = flLength2; + + vecPoint.x = GetAbsOrigin().x + flXSize; + vecPoint.y = GetAbsOrigin().y - flYSize; + AI_TraceLine ( vecPoint, vecPoint - Vector ( 0, 0, 100 ), MASK_NPCSOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr ); + flLength2 = (vecPoint - tr.endpos).Length(); + if ( flLength2 > flLength ) + { + return false; + } + flLength = flLength2; + + return true; +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Input : *pEnemy - +// bSetCondNewEnemy - +//----------------------------------------------------------------------------- +void CAI_BaseNPC::SetEnemy( CBaseEntity *pEnemy, bool bSetCondNewEnemy ) +{ + if (m_hEnemy != pEnemy) + { + ClearAttackConditions( ); + VacateStrategySlot(); + m_GiveUpOnDeadEnemyTimer.Stop(); + + // If we've just found a new enemy, set the condition + if ( pEnemy && bSetCondNewEnemy ) + { + SetCondition( COND_NEW_ENEMY ); + } + } + + // Assert( (pEnemy == NULL) || (m_NPCState == NPC_STATE_COMBAT) ); + + m_hEnemy = pEnemy; + m_flTimeEnemyAcquired = gpGlobals->curtime; + + m_LastShootAccuracy = -1; + m_TotalShots = 0; + m_TotalHits = 0; + + if ( !pEnemy ) + ClearCondition( COND_NEW_ENEMY ); +} + +const Vector &CAI_BaseNPC::GetEnemyLKP() const +{ + return (const_cast(this))->GetEnemies()->LastKnownPosition( GetEnemy() ); +} + +float CAI_BaseNPC::GetEnemyLastTimeSeen() const +{ + return (const_cast(this))->GetEnemies()->LastTimeSeen( GetEnemy() ); +} + +void CAI_BaseNPC::MarkEnemyAsEluded() +{ + GetEnemies()->MarkAsEluded( GetEnemy() ); +} + +void CAI_BaseNPC::ClearEnemyMemory() +{ + GetEnemies()->ClearMemory( GetEnemy() ); +} + +bool CAI_BaseNPC::EnemyHasEludedMe() const +{ + return (const_cast(this))->GetEnemies()->HasEludedMe( GetEnemy() ); +} + +void CAI_BaseNPC::SetTarget( CBaseEntity *pTarget ) +{ + m_hTargetEnt = pTarget; +} + + +//========================================================= +// Choose Enemy - tries to find the best suitable enemy for the npc. +//========================================================= + +bool CAI_BaseNPC::ShouldChooseNewEnemy() +{ + CBaseEntity *pEnemy = GetEnemy(); + if ( pEnemy ) + { + if ( GetEnemies()->GetSerialNumber() != m_EnemiesSerialNumber ) + { + return true; + } + + m_EnemiesSerialNumber = GetEnemies()->GetSerialNumber(); + + if ( EnemyHasEludedMe() || (IRelationType( pEnemy ) != D_HT && IRelationType( pEnemy ) != D_FR) || !IsValidEnemy( pEnemy ) ) + { + DbgEnemyMsg( this, "ShouldChooseNewEnemy() --> true (1)\n" ); + return true; + } + if ( HasCondition(COND_SEE_HATE) || HasCondition(COND_SEE_DISLIKE) || HasCondition(COND_SEE_NEMESIS) || HasCondition(COND_SEE_FEAR) ) + { + DbgEnemyMsg( this, "ShouldChooseNewEnemy() --> true (2)\n" ); + return true; + } + if ( !pEnemy->IsAlive() ) + { + if ( m_GiveUpOnDeadEnemyTimer.IsRunning() ) + { + if ( m_GiveUpOnDeadEnemyTimer.Expired() ) + { + DbgEnemyMsg( this, "ShouldChooseNewEnemy() --> true (3)\n" ); + return true; + } + } + else + m_GiveUpOnDeadEnemyTimer.Start(); + } + + AI_EnemyInfo_t *pInfo = GetEnemies()->Find( pEnemy ); + + if ( m_FailChooseEnemyTimer.Expired() ) + { + m_FailChooseEnemyTimer.Set( 1.5 ); + if ( HasCondition( COND_TASK_FAILED ) || + ( pInfo && ( pInfo->timeAtFirstHand == AI_INVALID_TIME || gpGlobals->curtime - pInfo->timeLastSeen > 10 ) ) ) + { + return true; + } + } + + if ( pInfo && pInfo->timeValidEnemy < gpGlobals->curtime ) + { + DbgEnemyMsg( this, "ShouldChooseNewEnemy() --> false\n" ); + return false; + } + } + + DbgEnemyMsg( this, "ShouldChooseNewEnemy() --> true (4)\n" ); + m_EnemiesSerialNumber = GetEnemies()->GetSerialNumber(); + + return true; +} + +//------------------------------------- + +bool CAI_BaseNPC::ChooseEnemy( void ) +{ + AI_PROFILE_SCOPE(CAI_Enemies_ChooseEnemy); + + DbgEnemyMsg( this, "ChooseEnemy() {\n" ); + + //--------------------------------- + // + // Gather initial conditions + // + + CBaseEntity *pInitialEnemy = GetEnemy(); + CBaseEntity *pChosenEnemy = pInitialEnemy; + + // Use memory bits in case enemy pointer altered outside this function, (e.g., ehandle goes NULL) + bool fHadEnemy = ( HasMemory( bits_MEMORY_HAD_ENEMY | bits_MEMORY_HAD_PLAYER ) ); + bool fEnemyWasPlayer = HasMemory( bits_MEMORY_HAD_PLAYER ); + bool fEnemyWentNull = ( fHadEnemy && !pInitialEnemy ); + bool fEnemyEluded = ( fEnemyWentNull || ( pInitialEnemy && GetEnemies()->HasEludedMe( pInitialEnemy ) ) ); + + //--------------------------------- + // + // Establish suitability of choosing a new enemy + // + + bool fHaveCondNewEnemy; + bool fHaveCondLostEnemy; + + if ( !m_ScheduleState.bScheduleWasInterrupted && GetCurSchedule() && !FScheduleDone() ) + { + Assert( InterruptFromCondition( COND_NEW_ENEMY ) == COND_NEW_ENEMY && InterruptFromCondition( COND_LOST_ENEMY ) == COND_LOST_ENEMY ); + fHaveCondNewEnemy = GetCurSchedule()->HasInterrupt( COND_NEW_ENEMY ); + fHaveCondLostEnemy = GetCurSchedule()->HasInterrupt( COND_LOST_ENEMY ); + + // See if they've been added as a custom interrupt + if ( !fHaveCondNewEnemy ) + { + fHaveCondNewEnemy = IsCustomInterruptConditionSet( COND_NEW_ENEMY ); + } + if ( !fHaveCondLostEnemy ) + { + fHaveCondLostEnemy = IsCustomInterruptConditionSet( COND_LOST_ENEMY ); + } + } + else + { + fHaveCondNewEnemy = true; // not having a schedule is the same as being interruptable by any condition + fHaveCondLostEnemy = true; + } + + if ( !fEnemyWentNull ) + { + if ( !fHaveCondNewEnemy && !( fHaveCondLostEnemy && fEnemyEluded ) ) + { + // DO NOT mess with the npc's enemy pointer unless the schedule the npc is currently + // running will be interrupted by COND_NEW_ENEMY or COND_LOST_ENEMY. This will + // eliminate the problem of npcs getting a new enemy while they are in a schedule + // that doesn't care, and then not realizing it by the time they get to a schedule + // that does. I don't feel this is a good permanent fix. + m_bSkippedChooseEnemy = true; + + DbgEnemyMsg( this, "Skipped enemy selection due to schedule restriction\n" ); + DbgEnemyMsg( this, "}\n" ); + return ( pChosenEnemy != NULL ); + } + } + else if ( !fHaveCondNewEnemy && !fHaveCondLostEnemy && GetCurSchedule() ) + { + DevMsg( 2, "WARNING: AI enemy went NULL but schedule (%s) is not interested\n", GetCurSchedule()->GetName() ); + } + + m_bSkippedChooseEnemy = false; + + //--------------------------------- + // + // Select a target + // + + if ( ShouldChooseNewEnemy() ) + { + pChosenEnemy = BestEnemy(); + } + + //--------------------------------- + // + // React to result of selection + // + + bool fChangingEnemy = ( pChosenEnemy != pInitialEnemy ); + + if ( fChangingEnemy || fEnemyWentNull ) + { + DbgEnemyMsg( this, "Enemy changed from %s to %s\n", pInitialEnemy->GetDebugName(), pChosenEnemy->GetDebugName() ); + Forget( bits_MEMORY_HAD_ENEMY | bits_MEMORY_HAD_PLAYER ); + + // Did our old enemy snuff it? + if ( pInitialEnemy && !pInitialEnemy->IsAlive() ) + { + SetCondition( COND_ENEMY_DEAD ); + } + + SetEnemy( pChosenEnemy ); + + if ( fHadEnemy ) + { + // Vacate any strategy slot on old enemy + VacateStrategySlot(); + + // Force output event for establishing LOS + Forget( bits_MEMORY_HAD_LOS ); + // m_flLastAttackTime = 0; + } + + if ( !pChosenEnemy ) + { + // Don't break on enemies going null if they've been killed + if ( !HasCondition(COND_ENEMY_DEAD) ) + { + SetCondition( COND_ENEMY_WENT_NULL ); + } + + if ( fEnemyEluded ) + { + SetCondition( COND_LOST_ENEMY ); + LostEnemySound(); + } + + if ( fEnemyWasPlayer ) + { + m_OnLostPlayer.FireOutput( pInitialEnemy, this ); + } + m_OnLostEnemy.FireOutput( pInitialEnemy, this); + } + else + { + Remember( ( pChosenEnemy->IsPlayer() ) ? bits_MEMORY_HAD_PLAYER : bits_MEMORY_HAD_ENEMY ); + } + } + + //--------------------------------- + + return ( pChosenEnemy != NULL ); +} + + +//========================================================= +void CAI_BaseNPC::PickupWeapon( CBaseCombatWeapon *pWeapon ) +{ + pWeapon->OnPickedUp( this ); + Weapon_Equip( pWeapon ); + m_iszPendingWeapon = NULL_STRING; +} + +//========================================================= +// DropItem - dead npc drops named item +//========================================================= +CBaseEntity *CAI_BaseNPC::DropItem ( const char *pszItemName, Vector vecPos, QAngle vecAng ) +{ + if ( !pszItemName ) + { + DevMsg( "DropItem() - No item name!\n" ); + return NULL; + } + + CBaseEntity *pItem = CBaseEntity::Create( pszItemName, vecPos, vecAng, this ); + + if ( pItem ) + { + if ( g_pGameRules->IsAllowedToSpawn( pItem ) == false ) + { + UTIL_Remove( pItem ); + return NULL; + } + + IPhysicsObject *pPhys = pItem->VPhysicsGetObject(); + + if ( pPhys ) + { + // Add an extra push in a random direction + Vector vel = RandomVector( -64.0f, 64.0f ); + AngularImpulse angImp = RandomAngularImpulse( -300.0f, 300.0f ); + + vel[2] = 0.0f; + pPhys->AddVelocity( &vel, &angImp ); + } + else + { + // do we want this behavior to be default?! (sjb) + pItem->ApplyAbsVelocityImpulse( GetAbsVelocity() ); + pItem->ApplyLocalAngularVelocityImpulse( AngularImpulse( 0, random->RandomFloat( 0, 100 ), 0 ) ); + } + + return pItem; + } + else + { + DevMsg( "DropItem() - Didn't create!\n" ); + return NULL; + } + +} + +bool CAI_BaseNPC::ShouldFadeOnDeath( void ) +{ + if ( g_RagdollLVManager.IsLowViolence() ) + { + return true; + } + else + { + // if flagged to fade out + return HasSpawnFlags(SF_NPC_FADE_CORPSE); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Indicates whether or not this npc should play an idle sound now. +// +// +// Output : Returns true if yes, false if no. +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::ShouldPlayIdleSound( void ) +{ + if ( ( m_NPCState == NPC_STATE_IDLE || m_NPCState == NPC_STATE_ALERT ) && + random->RandomInt(0,99) == 0 && !HasSpawnFlags(SF_NPC_GAG) ) + { + return true; + } + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: Make a sound that other AI's can hear, to broadcast our presence +// Input : volume (radius) of the sound. +// Output : +//----------------------------------------------------------------------------- +void CAI_BaseNPC::MakeAIFootstepSound( float volume, float duration ) +{ + CSoundEnt::InsertSound( SOUND_COMBAT, EyePosition(), volume, duration, this, SOUNDENT_CHANNEL_NPC_FOOTSTEP ); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : +// Output : +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::FOkToMakeSound( int soundPriority ) +{ + // ask the squad to filter sounds if I'm in one + if ( m_pSquad ) + { + if ( !m_pSquad->FOkToMakeSound( soundPriority ) ) + return false; + } + else + { + // otherwise, check my own sound timer + // Am I making uninterruptable sound? + if (gpGlobals->curtime <= m_flSoundWaitTime) + { + if ( soundPriority <= m_nSoundPriority ) + return false; + } + } + + // no talking outside of combat if gagged. + if ( HasSpawnFlags(SF_NPC_GAG) && ( m_NPCState != NPC_STATE_COMBAT ) ) + return false; + + return true; +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Input : +// Output : +//----------------------------------------------------------------------------- +void CAI_BaseNPC::JustMadeSound( int soundPriority, float flSoundLength ) +{ + m_flSoundWaitTime = gpGlobals->curtime + flSoundLength + random->RandomFloat(1.5, 2.0); + m_nSoundPriority = soundPriority; + + if (m_pSquad) + { + m_pSquad->JustMadeSound( soundPriority, gpGlobals->curtime + flSoundLength + random->RandomFloat(1.5, 2.0) ); + } +} + +Activity CAI_BaseNPC::GetStoppedActivity( void ) +{ + if (GetNavigator()->IsGoalActive()) + { + Activity activity = GetNavigator()->GetArrivalActivity(); + + if (activity > ACT_RESET) + { + return activity; + } + } + + return ACT_IDLE; +} + + +//========================================================= +//========================================================= +void CAI_BaseNPC::OnScheduleChange ( void ) +{ + EndTaskOverlay(); + + m_pNavigator->OnScheduleChange(); + + m_flMoveWaitFinished = 0; + + VacateStrategySlot(); + + // If I still have have a route, clear it + // FIXME: Routes should only be cleared inside of tasks (kenb) + GetNavigator()->ClearGoal(); + + UnlockBestSound(); + + // If I locked a hint node clear it + if ( HasMemory(bits_MEMORY_LOCKED_HINT) && GetHintNode() != NULL) + { + float hintDelay = GetHintDelay(GetHintNode()->HintType()); + GetHintNode()->Unlock(hintDelay); + SetHintNode( NULL ); + } +} + + + +CBaseCombatCharacter* CAI_BaseNPC::GetEnemyCombatCharacterPointer() +{ + if ( GetEnemy() == NULL ) + return NULL; + + return GetEnemy()->MyCombatCharacterPointer(); +} + + +// Global Savedata for npc +// +// This should be an exact copy of the var's in the header. Fields +// that aren't save/restored are commented out + +BEGIN_DATADESC( CAI_BaseNPC ) + + // m_pSchedule (reacquired on restore) + DEFINE_EMBEDDED( m_ScheduleState ), + DEFINE_FIELD( m_IdealSchedule, FIELD_INTEGER ), // handled specially but left in for "virtual" schedules + DEFINE_FIELD( m_failSchedule, FIELD_INTEGER ), // handled specially but left in for "virtual" schedules + DEFINE_FIELD( m_bUsingStandardThinkTime, FIELD_BOOLEAN ), + DEFINE_FIELD( m_flLastRealThinkTime, FIELD_TIME ), + // m_iFrameBlocked (not saved) + // m_bInChoreo (not saved) + // m_bDoPostRestoreRefindPath (not saved) + // gm_flTimeLastSpawn (static) + // gm_nSpawnedThisFrame (static) + // m_Conditions (custom save) + // m_CustomInterruptConditions (custom save) + // m_ConditionsPreIgnore (custom save) + // m_InverseIgnoreConditions (custom save) + // m_poseAim_Pitch (not saved; recomputed on restore) + // m_poseAim_Yaw (not saved; recomputed on restore) + // m_poseMove_Yaw (not saved; recomputed on restore) + DEFINE_FIELD( m_flTimePingEffect, FIELD_TIME ), + DEFINE_FIELD( m_bForceConditionsGather, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bConditionsGathered, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bSkippedChooseEnemy, FIELD_BOOLEAN ), + DEFINE_FIELD( m_NPCState, FIELD_INTEGER ), + DEFINE_FIELD( m_IdealNPCState, FIELD_INTEGER ), + DEFINE_FIELD( m_flLastStateChangeTime, FIELD_TIME ), + DEFINE_FIELD( m_Efficiency, FIELD_INTEGER ), + DEFINE_FIELD( m_MoveEfficiency, FIELD_INTEGER ), + DEFINE_FIELD( m_flNextDecisionTime, FIELD_TIME ), + DEFINE_KEYFIELD( m_SleepState, FIELD_INTEGER, "sleepstate" ), + DEFINE_FIELD( m_SleepFlags, FIELD_INTEGER ), + DEFINE_KEYFIELD( m_flWakeRadius, FIELD_FLOAT, "wakeradius" ), + DEFINE_KEYFIELD( m_bWakeSquad, FIELD_BOOLEAN, "wakesquad" ), + DEFINE_FIELD( m_nWakeTick, FIELD_TICK ), + + DEFINE_CUSTOM_FIELD( m_Activity, ActivityDataOps() ), + DEFINE_CUSTOM_FIELD( m_translatedActivity, ActivityDataOps() ), + DEFINE_CUSTOM_FIELD( m_IdealActivity, ActivityDataOps() ), + DEFINE_CUSTOM_FIELD( m_IdealTranslatedActivity, ActivityDataOps() ), + DEFINE_CUSTOM_FIELD( m_IdealWeaponActivity, ActivityDataOps() ), + + DEFINE_FIELD( m_nIdealSequence, FIELD_INTEGER ), + DEFINE_EMBEDDEDBYREF( m_pSenses ), + DEFINE_EMBEDDEDBYREF( m_pLockedBestSound ), + DEFINE_FIELD( m_hEnemy, FIELD_EHANDLE ), + DEFINE_FIELD( m_flTimeEnemyAcquired, FIELD_TIME ), + DEFINE_FIELD( m_hTargetEnt, FIELD_EHANDLE ), + DEFINE_EMBEDDED( m_GiveUpOnDeadEnemyTimer ), + DEFINE_EMBEDDED( m_FailChooseEnemyTimer ), + DEFINE_FIELD( m_EnemiesSerialNumber, FIELD_INTEGER ), + DEFINE_FIELD( m_flAcceptableTimeSeenEnemy, FIELD_TIME ), + DEFINE_EMBEDDED( m_UpdateEnemyPosTimer ), + // m_flTimeAnyUpdateEnemyPos (static) + DEFINE_FIELD( m_vecCommandGoal, FIELD_VECTOR ), + DEFINE_EMBEDDED( m_CommandMoveMonitor ), + DEFINE_FIELD( m_flSoundWaitTime, FIELD_TIME ), + DEFINE_FIELD( m_nSoundPriority, FIELD_INTEGER ), + DEFINE_FIELD( m_flIgnoreDangerSoundsUntil, FIELD_TIME ), + DEFINE_FIELD( m_afCapability, FIELD_INTEGER ), + DEFINE_FIELD( m_flMoveWaitFinished, FIELD_TIME ), + DEFINE_FIELD( m_hOpeningDoor, FIELD_EHANDLE ), + DEFINE_EMBEDDEDBYREF( m_pNavigator ), + DEFINE_EMBEDDEDBYREF( m_pLocalNavigator ), + DEFINE_EMBEDDEDBYREF( m_pPathfinder ), + DEFINE_EMBEDDEDBYREF( m_pMoveProbe ), + DEFINE_EMBEDDEDBYREF( m_pMotor ), + DEFINE_UTLVECTOR(m_UnreachableEnts, FIELD_EMBEDDED), + DEFINE_FIELD( m_hInteractionPartner, FIELD_EHANDLE ), + DEFINE_FIELD( m_hLastInteractionTestTarget, FIELD_EHANDLE ), + DEFINE_FIELD( m_hForcedInteractionPartner, FIELD_EHANDLE ), + DEFINE_FIELD( m_flForcedInteractionTimeout, FIELD_TIME ), + DEFINE_FIELD( m_vecForcedWorldPosition, FIELD_POSITION_VECTOR ), + DEFINE_FIELD( m_bCannotDieDuringInteraction, FIELD_BOOLEAN ), + DEFINE_FIELD( m_iInteractionState, FIELD_INTEGER ), + DEFINE_FIELD( m_iInteractionPlaying, FIELD_INTEGER ), + DEFINE_UTLVECTOR(m_ScriptedInteractions,FIELD_EMBEDDED), + DEFINE_FIELD( m_flInteractionYaw, FIELD_FLOAT ), + DEFINE_EMBEDDED( m_CheckOnGroundTimer ), + DEFINE_FIELD( m_vDefaultEyeOffset, FIELD_VECTOR ), + DEFINE_FIELD( m_flNextEyeLookTime, FIELD_TIME ), + DEFINE_FIELD( m_flEyeIntegRate, FIELD_FLOAT ), + DEFINE_FIELD( m_vEyeLookTarget, FIELD_POSITION_VECTOR ), + DEFINE_FIELD( m_vCurEyeTarget, FIELD_POSITION_VECTOR ), + DEFINE_FIELD( m_hEyeLookTarget, FIELD_EHANDLE ), + DEFINE_FIELD( m_flHeadYaw, FIELD_FLOAT ), + DEFINE_FIELD( m_flHeadPitch, FIELD_FLOAT ), + DEFINE_FIELD( m_flOriginalYaw, FIELD_FLOAT ), + DEFINE_FIELD( m_bInAScript, FIELD_BOOLEAN ), + DEFINE_FIELD( m_scriptState, FIELD_INTEGER ), + DEFINE_FIELD( m_hCine, FIELD_EHANDLE ), + DEFINE_CUSTOM_FIELD( m_ScriptArrivalActivity, ActivityDataOps() ), + DEFINE_FIELD( m_strScriptArrivalSequence, FIELD_STRING ), + DEFINE_FIELD( m_flSceneTime, FIELD_TIME ), + DEFINE_FIELD( m_iszSceneCustomMoveSeq, FIELD_STRING ), + // m_pEnemies Saved specially in ai_saverestore.cpp + DEFINE_FIELD( m_afMemory, FIELD_INTEGER ), + DEFINE_FIELD( m_hEnemyOccluder, FIELD_EHANDLE ), + DEFINE_FIELD( m_flSumDamage, FIELD_FLOAT ), + DEFINE_FIELD( m_flLastDamageTime, FIELD_TIME ), + DEFINE_FIELD( m_flLastPlayerDamageTime, FIELD_TIME ), + DEFINE_FIELD( m_flLastSawPlayerTime, FIELD_TIME ), + DEFINE_FIELD( m_flLastAttackTime, FIELD_TIME ), + DEFINE_FIELD( m_flLastEnemyTime, FIELD_TIME ), + DEFINE_FIELD( m_flNextWeaponSearchTime, FIELD_TIME ), + DEFINE_FIELD( m_iszPendingWeapon, FIELD_STRING ), + DEFINE_KEYFIELD( m_bIgnoreUnseenEnemies, FIELD_BOOLEAN , "ignoreunseenenemies"), + DEFINE_EMBEDDED( m_ShotRegulator ), + DEFINE_FIELD( m_iDesiredWeaponState, FIELD_INTEGER ), + // m_pSquad Saved specially in ai_saverestore.cpp + DEFINE_KEYFIELD(m_SquadName, FIELD_STRING, "squadname" ), + DEFINE_FIELD( m_iMySquadSlot, FIELD_INTEGER ), + DEFINE_KEYFIELD( m_strHintGroup, FIELD_STRING, "hintgroup" ), + DEFINE_KEYFIELD( m_bHintGroupNavLimiting, FIELD_BOOLEAN, "hintlimiting" ), + DEFINE_EMBEDDEDBYREF( m_pTacticalServices ), + DEFINE_FIELD( m_flWaitFinished, FIELD_TIME ), + DEFINE_FIELD( m_flNextFlinchTime, FIELD_TIME ), + DEFINE_FIELD( m_flNextDodgeTime, FIELD_TIME ), + DEFINE_EMBEDDED( m_MoveAndShootOverlay ), + DEFINE_FIELD( m_vecLastPosition, FIELD_POSITION_VECTOR ), + DEFINE_FIELD( m_vSavePosition, FIELD_POSITION_VECTOR ), + DEFINE_FIELD( m_vInterruptSavePosition, FIELD_POSITION_VECTOR ), + DEFINE_FIELD( m_pHintNode, FIELD_EHANDLE), + DEFINE_FIELD( m_cAmmoLoaded, FIELD_INTEGER ), + DEFINE_FIELD( m_flDistTooFar, FIELD_FLOAT ), + DEFINE_FIELD( m_hGoalEnt, FIELD_EHANDLE ), + DEFINE_FIELD( m_flTimeLastMovement, FIELD_TIME ), + DEFINE_KEYFIELD(m_spawnEquipment, FIELD_STRING, "additionalequipment" ), + DEFINE_FIELD( m_fNoDamageDecal, FIELD_BOOLEAN ), + DEFINE_FIELD( m_hStoredPathTarget, FIELD_EHANDLE ), + DEFINE_FIELD( m_vecStoredPathGoal, FIELD_POSITION_VECTOR ), + DEFINE_FIELD( m_nStoredPathType, FIELD_INTEGER ), + DEFINE_FIELD( m_fStoredPathFlags, FIELD_INTEGER ), + DEFINE_FIELD( m_bDidDeathCleanup, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bCrouchDesired, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bForceCrouch, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bIsCrouching, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bPerformAvoidance, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bIsMoving, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bFadeCorpse, FIELD_BOOLEAN ), + DEFINE_FIELD( m_iDeathPose, FIELD_INTEGER ), + DEFINE_FIELD( m_iDeathFrame, FIELD_INTEGER ), + DEFINE_FIELD( m_bCheckContacts, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bSpeedModActive, FIELD_BOOLEAN ), + DEFINE_FIELD( m_iSpeedModRadius, FIELD_INTEGER ), + DEFINE_FIELD( m_iSpeedModSpeed, FIELD_INTEGER ), + DEFINE_FIELD( m_hEnemyFilter, FIELD_EHANDLE ), + DEFINE_KEYFIELD( m_iszEnemyFilterName, FIELD_STRING, "enemyfilter" ), + DEFINE_FIELD( m_bImportanRagdoll, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bPlayerAvoidState, FIELD_BOOLEAN ), + + // Satisfy classcheck + // DEFINE_FIELD( m_ScheduleHistory, CUtlVector < AIScheduleChoice_t > ), + + // m_fIsUsingSmallHull TODO -- This needs more consideration than simple save/load + // m_failText DEBUG + // m_interruptText DEBUG + // m_failedSchedule DEBUG + // m_interuptSchedule DEBUG + // m_nDebugCurIndex DEBUG + + // m_LastShootAccuracy DEBUG + // m_RecentShotAccuracy DEBUG + // m_TotalShots DEBUG + // m_TotalHits DEBUG + // m_bSelected DEBUG + // m_TimeLastShotMark DEBUG + // m_bDeferredNavigation + + + // Outputs + DEFINE_OUTPUT( m_OnDamaged, "OnDamaged" ), + DEFINE_OUTPUT( m_OnDeath, "OnDeath" ), + DEFINE_OUTPUT( m_OnHalfHealth, "OnHalfHealth" ), + DEFINE_OUTPUT( m_OnFoundEnemy, "OnFoundEnemy" ), + DEFINE_OUTPUT( m_OnLostEnemyLOS, "OnLostEnemyLOS" ), + DEFINE_OUTPUT( m_OnLostEnemy, "OnLostEnemy" ), + DEFINE_OUTPUT( m_OnFoundPlayer, "OnFoundPlayer" ), + DEFINE_OUTPUT( m_OnLostPlayerLOS, "OnLostPlayerLOS" ), + DEFINE_OUTPUT( m_OnLostPlayer, "OnLostPlayer" ), + DEFINE_OUTPUT( m_OnHearWorld, "OnHearWorld" ), + DEFINE_OUTPUT( m_OnHearPlayer, "OnHearPlayer" ), + DEFINE_OUTPUT( m_OnHearCombat, "OnHearCombat" ), + DEFINE_OUTPUT( m_OnDamagedByPlayer, "OnDamagedByPlayer" ), + DEFINE_OUTPUT( m_OnDamagedByPlayerSquad, "OnDamagedByPlayerSquad" ), + DEFINE_OUTPUT( m_OnDenyCommanderUse, "OnDenyCommanderUse" ), + DEFINE_OUTPUT( m_OnRappelTouchdown, "OnRappelTouchdown" ), + DEFINE_OUTPUT( m_OnWake, "OnWake" ), + DEFINE_OUTPUT( m_OnSleep, "OnSleep" ), + DEFINE_OUTPUT( m_OnForcedInteractionStarted, "OnForcedInteractionStarted" ), + DEFINE_OUTPUT( m_OnForcedInteractionAborted, "OnForcedInteractionAborted" ), + DEFINE_OUTPUT( m_OnForcedInteractionFinished, "OnForcedInteractionFinished" ), + + // Inputs + DEFINE_INPUTFUNC( FIELD_STRING, "SetRelationship", InputSetRelationship ), + DEFINE_INPUTFUNC( FIELD_STRING, "SetEnemyFilter", InputSetEnemyFilter ), + DEFINE_INPUTFUNC( FIELD_INTEGER, "SetHealth", InputSetHealth ), + DEFINE_INPUTFUNC( FIELD_VOID, "BeginRappel", InputBeginRappel ), + DEFINE_INPUTFUNC( FIELD_STRING, "SetSquad", InputSetSquad ), + DEFINE_INPUTFUNC( FIELD_VOID, "Wake", InputWake ), + DEFINE_INPUTFUNC( FIELD_STRING, "ForgetEntity", InputForgetEntity ), + DEFINE_INPUTFUNC( FIELD_FLOAT, "IgnoreDangerSounds", InputIgnoreDangerSounds ), + DEFINE_INPUTFUNC( FIELD_VOID, "Break", InputBreak ), + DEFINE_INPUTFUNC( FIELD_VOID, "StartScripting", InputStartScripting ), + DEFINE_INPUTFUNC( FIELD_VOID, "StopScripting", InputStopScripting ), + DEFINE_INPUTFUNC( FIELD_VOID, "GagEnable", InputGagEnable ), + DEFINE_INPUTFUNC( FIELD_VOID, "GagDisable", InputGagDisable ), + DEFINE_INPUTFUNC( FIELD_VOID, "InsideTransition", InputInsideTransition ), + DEFINE_INPUTFUNC( FIELD_VOID, "OutsideTransition", InputOutsideTransition ), + DEFINE_INPUTFUNC( FIELD_VOID, "ActivateSpeedModifier", InputActivateSpeedModifier ), + DEFINE_INPUTFUNC( FIELD_VOID, "DisableSpeedModifier", InputDisableSpeedModifier ), + DEFINE_INPUTFUNC( FIELD_INTEGER, "SetSpeedModRadius", InputSetSpeedModifierRadius ), + DEFINE_INPUTFUNC( FIELD_INTEGER, "SetSpeedModSpeed", InputSetSpeedModifierSpeed ), + DEFINE_INPUTFUNC( FIELD_VOID, "HolsterWeapon", InputHolsterWeapon ), + DEFINE_INPUTFUNC( FIELD_VOID, "HolsterAndDestroyWeapon", InputHolsterAndDestroyWeapon ), + DEFINE_INPUTFUNC( FIELD_VOID, "UnholsterWeapon", InputUnholsterWeapon ), + DEFINE_INPUTFUNC( FIELD_STRING, "ForceInteractionWithNPC", InputForceInteractionWithNPC ), + DEFINE_INPUTFUNC( FIELD_STRING, "UpdateEnemyMemory", InputUpdateEnemyMemory ), + + // Function pointers + DEFINE_USEFUNC( NPCUse ), + DEFINE_THINKFUNC( CallNPCThink ), + DEFINE_THINKFUNC( CorpseFallThink ), + DEFINE_THINKFUNC( NPCInitThink ), + +END_DATADESC() + +BEGIN_SIMPLE_DATADESC( AIScheduleState_t ) + DEFINE_FIELD( iCurTask, FIELD_INTEGER ), + DEFINE_FIELD( fTaskStatus, FIELD_INTEGER ), + DEFINE_FIELD( timeStarted, FIELD_TIME ), + DEFINE_FIELD( timeCurTaskStarted, FIELD_TIME ), + DEFINE_FIELD( taskFailureCode, FIELD_INTEGER ), + DEFINE_FIELD( iTaskInterrupt, FIELD_INTEGER ), + DEFINE_FIELD( bTaskRanAutomovement, FIELD_BOOLEAN ), + DEFINE_FIELD( bTaskUpdatedYaw, FIELD_BOOLEAN ), + DEFINE_FIELD( bScheduleWasInterrupted, FIELD_BOOLEAN ), +END_DATADESC() + + +IMPLEMENT_SERVERCLASS_ST( CAI_BaseNPC, DT_AI_BaseNPC ) + SendPropInt( SENDINFO( m_lifeState ), 3, SPROP_UNSIGNED ), + SendPropBool( SENDINFO( m_bPerformAvoidance ) ), + SendPropBool( SENDINFO( m_bIsMoving ) ), + SendPropBool( SENDINFO( m_bFadeCorpse ) ), + SendPropInt( SENDINFO( m_iDeathPose ), ANIMATION_SEQUENCE_BITS ), + SendPropInt( SENDINFO( m_iDeathFrame ), 5 ), + SendPropBool( SENDINFO( m_bSpeedModActive ) ), + SendPropInt( SENDINFO( m_iSpeedModRadius ) ), + SendPropInt( SENDINFO( m_iSpeedModSpeed ) ), + SendPropBool( SENDINFO( m_bImportanRagdoll ) ), + SendPropFloat( SENDINFO( m_flTimePingEffect ) ), +END_SEND_TABLE() + +//------------------------------------- + +BEGIN_SIMPLE_DATADESC( UnreachableEnt_t ) + + DEFINE_FIELD( hUnreachableEnt, FIELD_EHANDLE ), + DEFINE_FIELD( fExpireTime, FIELD_TIME ), + DEFINE_FIELD( vLocationWhenUnreachable, FIELD_POSITION_VECTOR ), + +END_DATADESC() + +//------------------------------------- + +BEGIN_SIMPLE_DATADESC( ScriptedNPCInteraction_Phases_t ) +DEFINE_FIELD( iszSequence, FIELD_STRING ), +DEFINE_FIELD( iActivity, FIELD_INTEGER ), +END_DATADESC() + +//------------------------------------- + +BEGIN_SIMPLE_DATADESC( ScriptedNPCInteraction_t ) + DEFINE_FIELD( iszInteractionName, FIELD_STRING ), + DEFINE_FIELD( iFlags, FIELD_INTEGER ), + DEFINE_FIELD( iTriggerMethod, FIELD_INTEGER ), + DEFINE_FIELD( iLoopBreakTriggerMethod, FIELD_INTEGER ), + DEFINE_FIELD( vecRelativeOrigin, FIELD_VECTOR ), + DEFINE_FIELD( angRelativeAngles, FIELD_VECTOR ), + DEFINE_FIELD( vecRelativeVelocity, FIELD_VECTOR ), + DEFINE_FIELD( flDelay, FIELD_FLOAT ), + DEFINE_FIELD( flDistSqr, FIELD_FLOAT ), + DEFINE_FIELD( iszMyWeapon, FIELD_STRING ), + DEFINE_FIELD( iszTheirWeapon, FIELD_STRING ), + DEFINE_EMBEDDED_ARRAY( sPhases, SNPCINT_NUM_PHASES ), + DEFINE_FIELD( matDesiredLocalToWorld, FIELD_VMATRIX ), + DEFINE_FIELD( bValidOnCurrentEnemy, FIELD_BOOLEAN ), + DEFINE_FIELD( flNextAttemptTime, FIELD_TIME ), +END_DATADESC() + +//------------------------------------- + +void CAI_BaseNPC::PostConstructor( const char *szClassname ) +{ + BaseClass::PostConstructor( szClassname ); + CreateComponents(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::Activate( void ) +{ + BaseClass::Activate(); + + if ( GetModelPtr() ) + { + ParseScriptedNPCInteractions(); + } + + // Get a handle to my enemy filter entity if there is one. + if ( m_iszEnemyFilterName != NULL_STRING ) + { + CBaseEntity *pFilter = gEntList.FindEntityByName( NULL, m_iszEnemyFilterName ); + if ( pFilter != NULL ) + { + m_hEnemyFilter = dynamic_cast(pFilter); + } + } + +#ifdef AI_MONITOR_FOR_OSCILLATION + m_ScheduleHistory.RemoveAll(); +#endif//AI_MONITOR_FOR_OSCILLATION + +} + +void CAI_BaseNPC::Precache( void ) +{ + gm_iszPlayerSquad = AllocPooledString( PLAYER_SQUADNAME ); // cache for fast IsPlayerSquad calls + + if ( m_spawnEquipment != NULL_STRING && strcmp(STRING(m_spawnEquipment), "0") ) + { + UTIL_PrecacheOther( STRING(m_spawnEquipment) ); + } + + // Make sure schedules are loaded for this NPC type + if (!LoadedSchedules()) + { + DevMsg("ERROR: Rejecting spawn of %s as error in NPC's schedules.\n",GetDebugName()); + UTIL_Remove(this); + return; + } + + PrecacheScriptSound( "AI_BaseNPC.SwishSound" ); + PrecacheScriptSound( "AI_BaseNPC.BodyDrop_Heavy" ); + PrecacheScriptSound( "AI_BaseNPC.BodyDrop_Light" ); + PrecacheScriptSound( "AI_BaseNPC.SentenceStop" ); + + BaseClass::Precache(); +} + + +//----------------------------------------------------------------------------- + +const short AI_EXTENDED_SAVE_HEADER_VERSION = 5; +const short AI_EXTENDED_SAVE_HEADER_RESET_VERSION = 3; + +const short AI_EXTENDED_SAVE_HEADER_FIRST_VERSION_WITH_CONDITIONS = 2; +const short AI_EXTENDED_SAVE_HEADER_FIRST_VERSION_WITH_SCHEDULE_ID_FIXUP = 3; +const short AI_EXTENDED_SAVE_HEADER_FIRST_VERSION_WITH_SEQUENCE = 4; +const short AI_EXTENDED_SAVE_HEADER_FIRST_VERSION_WITH_NAVIGATOR_SAVE = 5; + +struct AIExtendedSaveHeader_t +{ + AIExtendedSaveHeader_t() + : version(AI_EXTENDED_SAVE_HEADER_VERSION), + flags(0), + scheduleCrc(0) + { + szSchedule[0] = 0; + szIdealSchedule[0] = 0; + szFailSchedule[0] = 0; + szSequence[0] = 0; + } + + short version; + unsigned flags; + char szSchedule[128]; + CRC32_t scheduleCrc; + char szIdealSchedule[128]; + char szFailSchedule[128]; + char szSequence[128]; + + DECLARE_SIMPLE_DATADESC(); +}; + +enum AIExtendedSaveHeaderFlags_t +{ + AIESH_HAD_ENEMY = 0x01, + AIESH_HAD_TARGET = 0x02, + AIESH_HAD_NAVGOAL = 0x04, +}; + +//------------------------------------- + +BEGIN_SIMPLE_DATADESC( AIExtendedSaveHeader_t ) + DEFINE_FIELD( version, FIELD_SHORT ), + DEFINE_FIELD( flags, FIELD_INTEGER ), + DEFINE_AUTO_ARRAY( szSchedule, FIELD_CHARACTER ), + DEFINE_FIELD( scheduleCrc, FIELD_INTEGER ), + DEFINE_AUTO_ARRAY( szIdealSchedule, FIELD_CHARACTER ), + DEFINE_AUTO_ARRAY( szFailSchedule, FIELD_CHARACTER ), + DEFINE_AUTO_ARRAY( szSequence, FIELD_CHARACTER ), +END_DATADESC() + +//------------------------------------- + +int CAI_BaseNPC::Save( ISave &save ) +{ + AIExtendedSaveHeader_t saveHeader; + + if ( GetEnemy() ) + saveHeader.flags |= AIESH_HAD_ENEMY; + if ( GetTarget() ) + saveHeader.flags |= AIESH_HAD_TARGET; + if ( GetNavigator()->IsGoalActive() ) + saveHeader.flags |= AIESH_HAD_NAVGOAL; + + if ( m_pSchedule ) + { + const char *pszSchedule = m_pSchedule->GetName(); + + Assert( Q_strlen( pszSchedule ) < sizeof( saveHeader.szSchedule ) - 1 ); + Q_strncpy( saveHeader.szSchedule, pszSchedule, sizeof( saveHeader.szSchedule ) ); + + CRC32_Init( &saveHeader.scheduleCrc ); + CRC32_ProcessBuffer( &saveHeader.scheduleCrc, (void *)m_pSchedule->GetTaskList(), m_pSchedule->NumTasks() * sizeof(Task_t) ); + CRC32_Final( &saveHeader.scheduleCrc ); + } + else + { + saveHeader.szSchedule[0] = 0; + saveHeader.scheduleCrc = 0; + } + + int idealSchedule = GetGlobalScheduleId( m_IdealSchedule ); + + if ( idealSchedule != -1 && idealSchedule != AI_RemapToGlobal( SCHED_NONE ) && idealSchedule != AI_RemapToGlobal( SCHED_AISCRIPT ) ) + { + CAI_Schedule *pIdealSchedule = GetSchedule( m_IdealSchedule ); + if ( pIdealSchedule ) + { + const char *pszIdealSchedule = pIdealSchedule->GetName(); + Assert( Q_strlen( pszIdealSchedule ) < sizeof( saveHeader.szIdealSchedule ) - 1 ); + Q_strncpy( saveHeader.szIdealSchedule, pszIdealSchedule, sizeof( saveHeader.szIdealSchedule ) ); + } + } + + int failSchedule = GetGlobalScheduleId( m_failSchedule ); + if ( failSchedule != -1 && failSchedule != AI_RemapToGlobal( SCHED_NONE ) && failSchedule != AI_RemapToGlobal( SCHED_AISCRIPT ) ) + { + CAI_Schedule *pFailSchedule = GetSchedule( m_failSchedule ); + if ( pFailSchedule ) + { + const char *pszFailSchedule = pFailSchedule->GetName(); + Assert( Q_strlen( pszFailSchedule ) < sizeof( saveHeader.szFailSchedule ) - 1 ); + Q_strncpy( saveHeader.szFailSchedule, pszFailSchedule, sizeof( saveHeader.szFailSchedule ) ); + } + } + + if ( GetSequence() != ACT_INVALID && GetModelPtr() ) + { + const char *pszSequenceName = GetSequenceName( GetSequence() ); + if ( pszSequenceName && *pszSequenceName ) + { + Assert( Q_strlen( pszSequenceName ) < sizeof( saveHeader.szSequence ) - 1 ); + Q_strncpy( saveHeader.szSequence, pszSequenceName, sizeof(saveHeader.szSequence) ); + } + } + + save.WriteAll( &saveHeader ); + + save.StartBlock(); + SaveConditions( save, m_Conditions ); + SaveConditions( save, m_CustomInterruptConditions ); + SaveConditions( save, m_ConditionsPreIgnore ); + CAI_ScheduleBits ignoreConditions; + m_InverseIgnoreConditions.Not( &ignoreConditions ); + SaveConditions( save, ignoreConditions ); + save.EndBlock(); + + save.StartBlock(); + GetNavigator()->Save( save ); + save.EndBlock(); + + return BaseClass::Save(save); +} + +//------------------------------------- + +void CAI_BaseNPC::DiscardScheduleState() +{ + // We don't save/restore routes yet + GetNavigator()->ClearGoal(); + + // We don't save/restore schedules yet + ClearSchedule( "Restoring NPC" ); + + // Reset animation + m_Activity = ACT_RESET; + + // If we don't have an enemy, clear conditions like see enemy, etc. + if ( GetEnemy() == NULL ) + { + m_Conditions.ClearAll(); + } + + // went across a transition and lost my m_hCine + bool bLostScript = ( m_NPCState == NPC_STATE_SCRIPT && m_hCine == NULL ); + if ( bLostScript ) + { + // UNDONE: Do something better here? + // for now, just go back to idle and let the AI figure out what to do. + SetState( NPC_STATE_IDLE ); + SetIdealState( NPC_STATE_IDLE ); + DevMsg(1, "Scripted Sequence stripped on level transition for %s\n", GetDebugName() ); + } +} + +//------------------------------------- + +void CAI_BaseNPC::OnRestore() +{ + gm_iszPlayerSquad = AllocPooledString( PLAYER_SQUADNAME ); // cache for fast IsPlayerSquad calls + + if ( m_bDoPostRestoreRefindPath && CAI_NetworkManager::NetworksLoaded() ) + { + CAI_DynamicLink::InitDynamicLinks(); + if ( !GetNavigator()->RefindPathToGoal( false ) ) + DiscardScheduleState(); + } + else + { + GetNavigator()->ClearGoal(); + } + BaseClass::OnRestore(); + m_bCheckContacts = true; +} + + +//------------------------------------- + +int CAI_BaseNPC::Restore( IRestore &restore ) +{ + AIExtendedSaveHeader_t saveHeader; + restore.ReadAll( &saveHeader ); + + if ( saveHeader.version >= AI_EXTENDED_SAVE_HEADER_FIRST_VERSION_WITH_CONDITIONS ) + { + restore.StartBlock(); + RestoreConditions( restore, &m_Conditions ); + RestoreConditions( restore, &m_CustomInterruptConditions ); + RestoreConditions( restore, &m_ConditionsPreIgnore ); + CAI_ScheduleBits ignoreConditions; + RestoreConditions( restore, &ignoreConditions ); + ignoreConditions.Not( &m_InverseIgnoreConditions ); + restore.EndBlock(); + } + + if ( saveHeader.version >= AI_EXTENDED_SAVE_HEADER_FIRST_VERSION_WITH_NAVIGATOR_SAVE ) + { + restore.StartBlock(); + GetNavigator()->Restore( restore ); + restore.EndBlock(); + } + + // do a normal restore + int status = BaseClass::Restore(restore); + if ( !status ) + return 0; + + // Do schedule fix-up + if ( saveHeader.version >= AI_EXTENDED_SAVE_HEADER_FIRST_VERSION_WITH_SCHEDULE_ID_FIXUP ) + { + if ( saveHeader.szIdealSchedule[0] ) + { + CAI_Schedule *pIdealSchedule = g_AI_SchedulesManager.GetScheduleByName( saveHeader.szIdealSchedule ); + m_IdealSchedule = ( pIdealSchedule ) ? pIdealSchedule->GetId() : SCHED_NONE; + } + + if ( saveHeader.szFailSchedule[0] ) + { + CAI_Schedule *pFailSchedule = g_AI_SchedulesManager.GetScheduleByName( saveHeader.szFailSchedule ); + m_failSchedule = ( pFailSchedule ) ? pFailSchedule->GetId() : SCHED_NONE; + } + } + + bool bLostSequence = false; + if ( saveHeader.version >= AI_EXTENDED_SAVE_HEADER_FIRST_VERSION_WITH_SEQUENCE && saveHeader.szSequence[0] && GetModelPtr() ) + { + SetSequence( LookupSequence( saveHeader.szSequence ) ); + if ( GetSequence() == ACT_INVALID ) + { + DevMsg( this, AIMF_IGNORE_SELECTED, "Discarding missing sequence %s on load.\n", saveHeader.szSequence ); + SetSequence( 0 ); + bLostSequence = true; + } + + Assert( IsValidSequence( GetSequence() ) ); + } + + bool bLostScript = ( m_NPCState == NPC_STATE_SCRIPT && m_hCine == NULL ); + bool bDiscardScheduleState = ( bLostScript || + bLostSequence || + saveHeader.szSchedule[0] == 0 || + saveHeader.version < AI_EXTENDED_SAVE_HEADER_RESET_VERSION || + ( (saveHeader.flags & AIESH_HAD_ENEMY) && !GetEnemy() ) || + ( (saveHeader.flags & AIESH_HAD_TARGET) && !GetTarget() ) ); + + if ( m_ScheduleState.taskFailureCode >= NUM_FAIL_CODES ) + m_ScheduleState.taskFailureCode = FAIL_NO_TARGET; // must have been a string, gotta punt + + if ( !bDiscardScheduleState ) + { + m_pSchedule = g_AI_SchedulesManager.GetScheduleByName( saveHeader.szSchedule ); + if ( m_pSchedule ) + { + CRC32_t scheduleCrc; + CRC32_Init( &scheduleCrc ); + CRC32_ProcessBuffer( &scheduleCrc, (void *)m_pSchedule->GetTaskList(), m_pSchedule->NumTasks() * sizeof(Task_t) ); + CRC32_Final( &scheduleCrc ); + + if ( scheduleCrc != saveHeader.scheduleCrc ) + { + m_pSchedule = NULL; + } + } + } + + if ( !m_pSchedule ) + bDiscardScheduleState = true; + + if ( !bDiscardScheduleState ) + m_bDoPostRestoreRefindPath = ( ( saveHeader.flags & AIESH_HAD_NAVGOAL) != 0 ); + else + { + m_bDoPostRestoreRefindPath = false; + DiscardScheduleState(); + } + + return status; +} + +//------------------------------------- + +void CAI_BaseNPC::SaveConditions( ISave &save, const CAI_ScheduleBits &conditions ) +{ + for (int i = 0; i < MAX_CONDITIONS; i++) + { + if (conditions.IsBitSet(i)) + { + const char *pszConditionName = ConditionName(AI_RemapToGlobal(i)); + if ( !pszConditionName ) + break; + save.WriteString( pszConditionName ); + } + } + save.WriteString( "" ); +} + +//------------------------------------- + +void CAI_BaseNPC::RestoreConditions( IRestore &restore, CAI_ScheduleBits *pConditions ) +{ + pConditions->ClearAll(); + char szCondition[256]; + for (;;) + { + restore.ReadString( szCondition, sizeof(szCondition), 0 ); + if ( !szCondition[0] ) + break; + int iCondition = GetSchedulingSymbols()->ConditionSymbolToId( szCondition ); + if ( iCondition != -1 ) + pConditions->Set( AI_RemapFromGlobal( iCondition ) ); + } +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::KeyValue( const char *szKeyName, const char *szValue ) +{ + bool bResult = BaseClass::KeyValue( szKeyName, szValue ); + + if( !bResult ) + { + // Defer unhandled Keys to behaviors + CAI_BehaviorBase **ppBehaviors = AccessBehaviors(); + + for ( int i = 0; i < NumBehaviors(); i++ ) + { + if( ppBehaviors[ i ]->KeyValue( szKeyName, szValue ) ) + { + return true; + } + } + } + + return bResult; +} + +//----------------------------------------------------------------------------- +// Purpose: Debug function to make this NPC freeze in place (or unfreeze). +//----------------------------------------------------------------------------- +void CAI_BaseNPC::ToggleFreeze(void) +{ + if (!IsCurSchedule(SCHED_NPC_FREEZE)) + { + // Freeze them. + SetCondition(COND_NPC_FREEZE); + SetMoveType(MOVETYPE_NONE); + SetGravity(0); + SetLocalAngularVelocity(vec3_angle); + SetAbsVelocity( vec3_origin ); + } + else + { + // Unfreeze them. + SetCondition(COND_NPC_UNFREEZE); + m_Activity = ACT_RESET; + + // BUGBUG: this might not be the correct movetype! + SetMoveType( MOVETYPE_STEP ); + + // Doesn't restore gravity to the original value, but who cares? + SetGravity(1); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Written by subclasses macro to load schedules +// Input : +// Output : +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::LoadSchedules(void) +{ + return true; +} + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::LoadedSchedules(void) +{ + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: Constructor +// Input : +// Output : +//----------------------------------------------------------------------------- +CAI_BaseNPC::CAI_BaseNPC(void) + : m_UnreachableEnts( 0, 4 ), + m_bDeferredNavigation( false ) +{ + m_pMotor = NULL; + m_pMoveProbe = NULL; + m_pNavigator = NULL; + m_pSenses = NULL; + m_pPathfinder = NULL; + m_pLocalNavigator = NULL; + + m_pSchedule = NULL; + m_IdealSchedule = SCHED_NONE; + +#ifdef _DEBUG + // necessary since in debug, we initialize vectors to NAN for debugging + m_vecLastPosition.Init(); + m_vSavePosition.Init(); + m_vEyeLookTarget.Init(); + m_vCurEyeTarget.Init(); + m_vDefaultEyeOffset.Init(); + +#endif + m_bDidDeathCleanup = false; + + m_afCapability = 0; // Make sure this is cleared in the base class + + SetHullType(HULL_HUMAN); // Give human hull by default, subclasses should override + + m_iMySquadSlot = SQUAD_SLOT_NONE; + m_flSumDamage = 0; + m_flLastDamageTime = 0; + m_flLastAttackTime = 0; + m_flSoundWaitTime = 0; + m_flNextEyeLookTime = 0; + m_flHeadYaw = 0; + m_flHeadPitch = 0; + m_spawnEquipment = NULL_STRING; + m_pEnemies = new CAI_Enemies; + m_bIgnoreUnseenEnemies = false; + m_flEyeIntegRate = 0.95; + SetTarget( NULL ); + + m_pSquad = NULL; + + m_flMoveWaitFinished = 0; + + m_fIsUsingSmallHull = true; + + m_bHintGroupNavLimiting = false; + + m_fNoDamageDecal = false; + + SetInAScript( false ); + + m_pLockedBestSound = new CSound; + m_pLockedBestSound->m_iType = SOUND_NONE; + + // ---------------------------- + // Debugging fields + // ---------------------------- + m_interruptText = NULL; + m_failText = NULL; + m_failedSchedule = NULL; + m_interuptSchedule = NULL; + m_nDebugPauseIndex = 0; + + g_AI_Manager.AddAI( this ); + + if ( g_AI_Manager.NumAIs() == 1 ) + { + m_AnyUpdateEnemyPosTimer.Force(); + gm_flTimeLastSpawn = -1; + gm_nSpawnedThisFrame = 0; + gm_iNextThinkRebalanceTick = 0; + } + + m_iFrameBlocked = -1; + m_bInChoreo = true; // assume so until call to UpdateEfficiency() + + SetCollisionGroup( COLLISION_GROUP_NPC ); +} + +//----------------------------------------------------------------------------- +// Purpose: Destructor +// Input : +// Output : +//----------------------------------------------------------------------------- +CAI_BaseNPC::~CAI_BaseNPC(void) +{ + g_AI_Manager.RemoveAI( this ); + + delete m_pLockedBestSound; + + RemoveMemory(); + + delete m_pPathfinder; + delete m_pNavigator; + delete m_pMotor; + delete m_pLocalNavigator; + delete m_pMoveProbe; + delete m_pSenses; + delete m_pTacticalServices; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::UpdateOnRemove(void) +{ + if ( !m_bDidDeathCleanup ) + { + if ( m_NPCState == NPC_STATE_DEAD ) + DevMsg( "May not have cleaned up on NPC death\n"); + + CleanupOnDeath( NULL, false ); + } + + // Chain at end to mimic destructor unwind order + BaseClass::UpdateOnRemove(); +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +int CAI_BaseNPC::UpdateTransmitState() +{ + if( gpGlobals->curtime < m_flTimePingEffect ) + { + return SetTransmitState( FL_EDICT_ALWAYS ); + } + + return BaseClass::UpdateTransmitState(); +} + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::CreateComponents() +{ + m_pSenses = CreateSenses(); + if ( !m_pSenses ) + return false; + + m_pMotor = CreateMotor(); + if ( !m_pMotor ) + return false; + + m_pLocalNavigator = CreateLocalNavigator(); + if ( !m_pLocalNavigator ) + return false; + + m_pMoveProbe = CreateMoveProbe(); + if ( !m_pMoveProbe ) + return false; + + m_pNavigator = CreateNavigator(); + if ( !m_pNavigator ) + return false; + + m_pPathfinder = CreatePathfinder(); + if ( !m_pPathfinder ) + return false; + + m_pTacticalServices = CreateTacticalServices(); + if ( !m_pTacticalServices ) + return false; + + m_MoveAndShootOverlay.SetOuter( this ); + + m_pMotor->Init( m_pLocalNavigator ); + m_pLocalNavigator->Init( m_pNavigator ); + m_pNavigator->Init( g_pBigAINet ); + m_pPathfinder->Init( g_pBigAINet ); + m_pTacticalServices->Init( g_pBigAINet ); + + return true; +} + +//----------------------------------------------------------------------------- + +CAI_Senses *CAI_BaseNPC::CreateSenses() +{ + CAI_Senses *pSenses = new CAI_Senses; + pSenses->SetOuter( this ); + return pSenses; +} + +//----------------------------------------------------------------------------- + +CAI_Motor *CAI_BaseNPC::CreateMotor() +{ + return new CAI_Motor( this ); +} + +//----------------------------------------------------------------------------- + +CAI_MoveProbe *CAI_BaseNPC::CreateMoveProbe() +{ + return new CAI_MoveProbe( this ); +} + +//----------------------------------------------------------------------------- + +CAI_LocalNavigator *CAI_BaseNPC::CreateLocalNavigator() +{ + return new CAI_LocalNavigator( this ); +} + +//----------------------------------------------------------------------------- + +CAI_TacticalServices *CAI_BaseNPC::CreateTacticalServices() +{ + return new CAI_TacticalServices( this ); +} + +//----------------------------------------------------------------------------- + +CAI_Navigator *CAI_BaseNPC::CreateNavigator() +{ + return new CAI_Navigator( this ); +} + +//----------------------------------------------------------------------------- + +CAI_Pathfinder *CAI_BaseNPC::CreatePathfinder() +{ + return new CAI_Pathfinder( this ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::InputSetRelationship( inputdata_t &inputdata ) +{ + AddRelationship( inputdata.value.String(), inputdata.pActivator ); +} + + +//----------------------------------------------------------------------------- +// Won't affect the current enemy, only future enemy acquisitions. +//----------------------------------------------------------------------------- +void CAI_BaseNPC::InputSetEnemyFilter( inputdata_t &inputdata ) +{ + // Get a handle to my enemy filter entity if there is one. + CBaseEntity *pFilter = gEntList.FindEntityByName( NULL, inputdata.value.StringID() ); + m_hEnemyFilter = dynamic_cast(pFilter); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::InputSetHealth( inputdata_t &inputdata ) +{ + int iNewHealth = inputdata.value.Int(); + int iDelta = abs(GetHealth() - iNewHealth); + if ( iNewHealth > GetHealth() ) + { + TakeHealth( iDelta, DMG_GENERIC ); + } + else if ( iNewHealth < GetHealth() ) + { + TakeDamage( CTakeDamageInfo( this, this, iDelta, DMG_GENERIC ) ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::InputBeginRappel( inputdata_t &inputdata ) +{ + BeginRappel(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::InputSetSquad( inputdata_t &inputdata ) +{ + if ( !( CapabilitiesGet() & bits_CAP_SQUAD ) ) + { + Warning("SetSquad Input received for NPC %s, but that NPC can't use squads.\n", GetDebugName() ); + return; + } + + m_SquadName = inputdata.value.StringID(); + + // Removing from squad? + if ( m_SquadName == NULL_STRING ) + { + if ( m_pSquad ) + { + m_pSquad->RemoveFromSquad(this, true); + m_pSquad = NULL; + } + } + else + { + m_pSquad = g_AI_SquadManager.FindCreateSquad(this, m_SquadName); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::InputWake( inputdata_t &inputdata ) +{ + Wake(); + + // Check if we have a path to follow. This is normally done in StartNPC, + // but putting the NPC to sleep will cancel it, so we have to do it again. + if ( m_target != NULL_STRING )// this npc has a target + { + // Find the npc's initial target entity, stash it + SetGoalEnt( gEntList.FindEntityByName( NULL, m_target ) ); + + if ( !GetGoalEnt() ) + { + Warning( "ReadyNPC()--%s couldn't find target %s\n", GetClassname(), STRING(m_target)); + } + else + { + StartTargetHandling( GetGoalEnt() ); + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::InputForgetEntity( inputdata_t &inputdata ) +{ + const char *pszEntityToForget = inputdata.value.String(); + + if ( g_pDeveloper->GetInt() && pszEntityToForget[strlen( pszEntityToForget ) - 1] == '*' ) + DevMsg( "InputForgetEntity does not support wildcards\n" ); + + CBaseEntity *pEntity = gEntList.FindEntityByName( NULL, pszEntityToForget ); + if ( pEntity ) + { + if ( GetEnemy() == pEntity ) + { + SetEnemy( NULL ); + SetIdealState( NPC_STATE_ALERT ); + } + GetEnemies()->ClearMemory( pEntity ); + } +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +void CAI_BaseNPC::InputIgnoreDangerSounds( inputdata_t &inputdata ) +{ + // Default is 10 seconds. + float flDelay = 10.0f; + + if( inputdata.value.Float() > 0.0f ) + { + flDelay = inputdata.value.Float(); + } + + m_flIgnoreDangerSoundsUntil = gpGlobals->curtime + flDelay; +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +void CAI_BaseNPC::InputUpdateEnemyMemory( inputdata_t &inputdata ) +{ + const char *pszEnemy = inputdata.value.String(); + CBaseEntity *pEnemy = gEntList.FindEntityByName( NULL, pszEnemy ); + + if( pEnemy ) + { + UpdateEnemyMemory( pEnemy, pEnemy->GetAbsOrigin(), this ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : &inputdata - +//----------------------------------------------------------------------------- +void CAI_BaseNPC::InputOutsideTransition( inputdata_t &inputdata ) +{ +} + +//----------------------------------------------------------------------------- +// Purpose: Called when this NPC transitions to another level with the player +// Input : &inputdata - +//----------------------------------------------------------------------------- +void CAI_BaseNPC::InputInsideTransition( inputdata_t &inputdata ) +{ + CleanupScriptsOnTeleport( true ); + + // If we're inside a vcd, tell it to stop + if ( IsCurSchedule( SCHED_SCENE_GENERIC, false ) ) + { + RemoveActorFromScriptedScenes( this, false ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::CleanupScriptsOnTeleport( bool bEnrouteAsWell ) +{ + // If I'm running a scripted sequence, I need to clean up + if ( m_NPCState == NPC_STATE_SCRIPT && m_hCine ) + { + if ( !bEnrouteAsWell ) + { + // + // Don't cancel scripts when they're teleporting an NPC + // to the script for the purposes of movement. + // + if ( ( m_scriptState == CAI_BaseNPC::SCRIPT_WALK_TO_MARK ) || + ( m_scriptState == CAI_BaseNPC::SCRIPT_RUN_TO_MARK ) || + ( m_scriptState == CAI_BaseNPC::SCRIPT_CUSTOM_MOVE_TO_MARK ) || + m_hCine->IsTeleportingDueToMoveTo() ) + { + return; + } + } + + m_hCine->ScriptEntityCancel( m_hCine, true ); + } +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::HandleInteraction(int interactionType, void *data, CBaseCombatCharacter* sourceEnt) +{ +#ifdef HL2_DLL + if ( interactionType == g_interactionBarnacleVictimGrab ) + { + // Make the victim stop thinking so they're as good as dead without + // shocking the system by destroying the entity. + StopLoopingSounds(); + BarnacleDeathSound(); + SetThink( NULL ); + + // Gag the NPC so they won't talk anymore + AddSpawnFlags( SF_NPC_GAG ); + + // Drop any weapon they're holding + if ( GetActiveWeapon() ) + { + Weapon_Drop( GetActiveWeapon() ); + } + + return true; + } +#endif // HL2_DLL + + return BaseClass::HandleInteraction( interactionType, data, sourceEnt ); +} + +CAI_BaseNPC *CAI_BaseNPC::GetInteractionPartner( void ) +{ + if ( m_hInteractionPartner == NULL ) + return NULL; + + return m_hInteractionPartner->MyNPCPointer(); +} + +//----------------------------------------------------------------------------- +// Purpose: Called when exiting a scripted sequence. +// Output : Returns true if alive, false if dead. +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::ExitScriptedSequence( ) +{ + if ( m_lifeState == LIFE_DYING ) + { + // is this legal? + // BUGBUG -- This doesn't call Killed() + SetIdealState( NPC_STATE_DEAD ); + return false; + } + + if (m_hCine) + { + m_hCine->CancelScript( ); + } + + return true; +} + + +ConVar sv_test_scripted_sequences( "sv_test_scripted_sequences", "0", FCVAR_NONE, "Tests for scripted sequences that are embedded in the world. Run through your map with this set to check for NPCs falling through the world." ); + +bool CAI_BaseNPC::CineCleanup() +{ + CAI_ScriptedSequence *pOldCine = m_hCine; + int nSavedFlags = ( m_hCine ? m_hCine->m_savedFlags : GetFlags() ); + + bool bDestroyCine = false; + if ( IsRunningDynamicInteraction() ) + { + bDestroyCine = true; + + // Re-enable physics collisions between me & the other NPC + if ( m_hInteractionPartner ) + { + PhysEnableEntityCollisions( this, m_hInteractionPartner ); + //Msg("%s(%s) enabled collisions with %s(%s) at %0.2f\n", GetClassname(), GetDebugName(), m_hInteractionPartner->GetClassName(), m_hInteractionPartner->GetDebugName(), gpGlobals->curtime ); + } + + if ( m_hForcedInteractionPartner ) + { + // We've finished a forced interaction. Let the mapmaker know. + m_OnForcedInteractionFinished.FireOutput( this, this ); + } + + // Clear interaction partner, because we're not running a scripted sequence anymore + m_hInteractionPartner = NULL; + CleanupForcedInteraction(); + } + + // am I linked to a cinematic? + if (m_hCine) + { + // okay, reset me to what it thought I was before + m_hCine->SetTarget( NULL ); + // NOTE that this will have had EF_NODRAW removed in script.dll when it's cached off + SetEffects( m_hCine->m_saved_effects ); + + SetCollisionGroup( m_hCine->m_savedCollisionGroup ); + } + else + { + // arg, punt + AddSolidFlags( FSOLID_NOT_STANDABLE ); + } + + m_hCine = NULL; + SetTarget( NULL ); + SetGoalEnt( NULL ); + if (m_lifeState == LIFE_DYING) + { + // last frame of death animation? + if ( m_iHealth > 0 ) + { + m_iHealth = 0; + } + + AddSolidFlags( FSOLID_NOT_SOLID ); + SetState( NPC_STATE_DEAD ); + m_lifeState = LIFE_DEAD; + UTIL_SetSize( this, WorldAlignMins(), Vector(WorldAlignMaxs().x, WorldAlignMaxs().y, WorldAlignMins().z + 2) ); + + if ( pOldCine && pOldCine->HasSpawnFlags( SF_SCRIPT_LEAVECORPSE ) ) + { + SetUse( NULL ); // BUGBUG -- This doesn't call Killed() + SetThink( NULL ); // This will probably break some stuff + SetTouch( NULL ); + } + else + SUB_StartFadeOut(); // SetThink( SUB_DoNothing ); + + + //Not becoming a ragdoll, so set the NOINTERP flag on. + if ( CanBecomeRagdoll() == false ) + { + StopAnimation(); + IncrementInterpolationFrame(); // Don't interpolate either, assume the corpse is positioned in its final resting place + } + + SetMoveType( MOVETYPE_NONE ); + return false; + } + + // If we actually played a sequence + if ( pOldCine && pOldCine->m_iszPlay != NULL_STRING && pOldCine->PlayedSequence() ) + { + if ( !pOldCine->HasSpawnFlags(SF_SCRIPT_DONT_TELEPORT_AT_END) ) + { + // reset position + Vector new_origin; + QAngle new_angle; + GetBonePosition( 0, new_origin, new_angle ); + + // Figure out how far they have moved + // We can't really solve this problem because we can't query the movement of the origin relative + // to the sequence. We can get the root bone's position as we do here, but there are + // cases where the root bone is in a different relative position to the entity's origin + // before/after the sequence plays. So we are stuck doing this: + + // !!!HACKHACK: Float the origin up and drop to floor because some sequences have + // irregular motion that can't be properly accounted for. + + // UNDONE: THIS SHOULD ONLY HAPPEN IF WE ACTUALLY PLAYED THE SEQUENCE. + Vector oldOrigin = GetLocalOrigin(); + + // UNDONE: ugly hack. Don't move NPC if they don't "seem" to move + // this really needs to be done with the AX,AY,etc. flags, but that aren't consistantly + // being set, so animations that really do move won't be caught. + if ((oldOrigin - new_origin).Length2D() < 8.0) + new_origin = oldOrigin; + + Vector origin = GetLocalOrigin(); + + origin.x = new_origin.x; + origin.y = new_origin.y; + origin.z += 1; + + if ( nSavedFlags & FL_FLY ) + { + origin.z = new_origin.z; + SetLocalOrigin( origin ); + } + else + { + SetLocalOrigin( origin ); + + int drop = UTIL_DropToFloor( this, MASK_NPCSOLID, UTIL_GetLocalPlayer() ); + + // Origin in solid? Set to org at the end of the sequence + if ( ( drop < 0 ) || sv_test_scripted_sequences.GetBool() ) + { + SetLocalOrigin( oldOrigin ); + } + else if ( drop == 0 ) // Hanging in air? + { + Vector origin = GetLocalOrigin(); + origin.z = new_origin.z; + SetLocalOrigin( origin ); + SetGroundEntity( NULL ); + } + } + + origin = GetLocalOrigin(); + + // teleport if it's a non-trivial distance + if ((oldOrigin - origin).Length() > 8.0) + { + // Call teleport to notify + Teleport( &origin, NULL, NULL ); + SetLocalOrigin( origin ); + IncrementInterpolationFrame(); + } + + if ( m_iHealth <= 0 ) + { + // Dropping out because he got killed + SetIdealState( NPC_STATE_DEAD ); + SetCondition( COND_LIGHT_DAMAGE ); + m_lifeState = LIFE_DYING; + } + } + + // We should have some animation to put these guys in, but for now it's idle. + // Due to NOINTERP above, there won't be any blending between this anim & the sequence + m_Activity = ACT_RESET; + } + + // set them back into a normal state + if ( m_iHealth > 0 ) + { + SetIdealState( NPC_STATE_IDLE ); + } + else + { + // Dropping out because he got killed + SetIdealState( NPC_STATE_DEAD ); + SetCondition( COND_LIGHT_DAMAGE ); + } + + // SetAnimation( m_NPCState ); + CLEARBITS(m_spawnflags, SF_NPC_WAIT_FOR_SCRIPT ); + + if ( bDestroyCine ) + { + UTIL_Remove( pOldCine ); + } + + return true; +} + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::Teleport( const Vector *newPosition, const QAngle *newAngles, const Vector *newVelocity ) +{ + CleanupScriptsOnTeleport( false ); + + BaseClass::Teleport( newPosition, newAngles, newVelocity ); +} + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::FindSpotForNPCInRadius( Vector *pResult, const Vector &vStartPos, CAI_BaseNPC *pNPC, float radius, bool bOutOfPlayerViewcone ) +{ + CBasePlayer *pPlayer = AI_GetSinglePlayer(); + QAngle fan; + + fan.x = 0; + fan.z = 0; + + for( fan.y = 0 ; fan.y < 360 ; fan.y += 18.0 ) + { + Vector vecTest; + Vector vecDir; + + AngleVectors( fan, &vecDir ); + + vecTest = vStartPos + vecDir * radius; + + if ( bOutOfPlayerViewcone && pPlayer && !pPlayer->FInViewCone( vecTest ) ) + continue; + + trace_t tr; + + UTIL_TraceLine( vecTest, vecTest - Vector( 0, 0, 8192 ), MASK_SHOT, pNPC, COLLISION_GROUP_NONE, &tr ); + if( tr.fraction == 1.0 ) + { + continue; + } + + UTIL_TraceHull( tr.endpos, + tr.endpos + Vector( 0, 0, 10 ), + pNPC->GetHullMins(), + pNPC->GetHullMaxs(), + MASK_NPCSOLID, + pNPC, + COLLISION_GROUP_NONE, + &tr ); + + if( tr.fraction == 1.0 && pNPC->GetMoveProbe()->CheckStandPosition( tr.endpos, MASK_NPCSOLID ) ) + { + *pResult = tr.endpos; + return true; + } + } + return false; +} + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::IsNavigationUrgent() +{ + // return true if the navigation is for something that can't react well to failure + if ( IsCurSchedule( SCHED_SCRIPTED_WALK, false ) || + IsCurSchedule( SCHED_SCRIPTED_RUN, false ) || + IsCurSchedule( SCHED_SCRIPTED_CUSTOM_MOVE, false ) || + ( IsCurSchedule( SCHED_SCENE_GENERIC, false ) && IsInLockedScene() ) ) + { + return true; + } + return false; +} + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::ShouldFailNav( bool bMovementFailed ) +{ +#ifdef HL2_EPISODIC + + if ( ai_vehicle_avoidance.GetBool() ) + { + // Never be blocked this way by a vehicle (creates too many headaches around the levels) + CBaseEntity *pEntity = GetNavigator()->GetBlockingEntity(); + if ( pEntity && pEntity->GetServerVehicle() ) + { + // Vital allies never get stuck, and urgent moves cannot be blocked by a vehicle + if ( Classify() == CLASS_PLAYER_ALLY_VITAL || IsNavigationUrgent() ) + return false; + } + } + +#endif // HL2_EPISODIC + + // It's up to the schedule that requested movement to deal with failed movement. Currently, only a handfull of + // schedules are considered Urgent, and they need to deal with what to do when there's no route, which by inspection + // they'd don't. + + if ( IsNavigationUrgent()) + { + return false; + } + + return true; +} + +Navigation_t CAI_BaseNPC::GetNavType() const +{ + return m_pNavigator->GetNavType(); +} + +void CAI_BaseNPC::SetNavType( Navigation_t navType ) +{ + m_pNavigator->SetNavType( navType ); +} + +//----------------------------------------------------------------------------- +// NPCs can override this to tweak with how costly particular movements are +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::MovementCost( int moveType, const Vector &vecStart, const Vector &vecEnd, float *pCost ) +{ + // We have nothing to say on the matter, but derived classes might + return false; +} + +bool CAI_BaseNPC::OverrideMoveFacing( const AILocalMoveGoal_t &move, float flInterval ) +{ + return false; +} + +bool CAI_BaseNPC::OverrideMove( float flInterval ) +{ + return false; +} + + +//========================================================= +// VecToYaw - turns a directional vector into a yaw value +// that points down that vector. +//========================================================= +float CAI_BaseNPC::VecToYaw( const Vector &vecDir ) +{ + if (vecDir.x == 0 && vecDir.y == 0 && vecDir.z == 0) + return GetLocalAngles().y; + + return UTIL_VecToYaw( vecDir ); +} + +//----------------------------------------------------------------------------- +// Inherited from IAI_MotorMovementServices +//----------------------------------------------------------------------------- +float CAI_BaseNPC::CalcYawSpeed( void ) +{ + // Negative values are invalud + return -1.0f; +} + +bool CAI_BaseNPC::OnCalcBaseMove( AILocalMoveGoal_t *pMoveGoal, + float distClear, + AIMoveResult_t *pResult ) +{ + if ( pMoveGoal->directTrace.pObstruction ) + { + CBasePropDoor *pPropDoor = dynamic_cast( pMoveGoal->directTrace.pObstruction ); + if ( pPropDoor && OnUpcomingPropDoor( pMoveGoal, pPropDoor, distClear, pResult ) ) + { + return true; + } + } + + return false; +} + + +bool CAI_BaseNPC::OnObstructionPreSteer( AILocalMoveGoal_t *pMoveGoal, + float distClear, + AIMoveResult_t *pResult ) +{ + if ( pMoveGoal->directTrace.pObstruction ) + { + CBaseDoor *pDoor = dynamic_cast( pMoveGoal->directTrace.pObstruction ); + if ( pDoor && OnObstructingDoor( pMoveGoal, pDoor, distClear, pResult ) ) + { + return true; + } + } + + return false; +} + + +bool CAI_BaseNPC::OnObstructingDoor( AILocalMoveGoal_t *pMoveGoal, + CBaseDoor *pDoor, + float distClear, + AIMoveResult_t *pResult ) +{ + if ( pMoveGoal->maxDist < distClear ) + return false; + + // By default, NPCs don't know how to open doors + if ( pDoor->m_toggle_state == TS_AT_BOTTOM || pDoor->m_toggle_state == TS_GOING_DOWN ) + { + if ( distClear < 0.1 ) + { + *pResult = AIMR_BLOCKED_ENTITY; + } + else + { + pMoveGoal->maxDist = distClear; + *pResult = AIMR_OK; + } + + return true; + } + + return false; +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Input : pMoveGoal - +// pDoor - +// distClear - +// default - +// spawn - +// oldorg - +// pfPosition - +// neworg - +// Output : Returns true if movement is solved, false otherwise. +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::OnUpcomingPropDoor( AILocalMoveGoal_t *pMoveGoal, + CBasePropDoor *pDoor, + float distClear, + AIMoveResult_t *pResult ) +{ + if ( (pMoveGoal->flags & AILMG_TARGET_IS_GOAL) && pMoveGoal->maxDist < distClear ) + return false; + + if ( pMoveGoal->maxDist + GetHullWidth() * .25 < distClear ) + return false; + + if (pDoor == m_hOpeningDoor) + { + if ( pDoor->IsNPCOpening( this ) ) + { + // We're in the process of opening the door, don't be blocked by it. + pMoveGoal->maxDist = distClear; + *pResult = AIMR_OK; + return true; + } + m_hOpeningDoor = NULL; + } + + if ((CapabilitiesGet() & bits_CAP_DOORS_GROUP) && !pDoor->IsDoorLocked() && (pDoor->IsDoorClosed() || pDoor->IsDoorClosing())) + { + AI_Waypoint_t *pOpenDoorRoute = NULL; + + opendata_t opendata; + pDoor->GetNPCOpenData(this, opendata); + + // dvs: FIXME: local route might not be sufficient + pOpenDoorRoute = GetPathfinder()->BuildLocalRoute( + GetLocalOrigin(), + opendata.vecStandPos, + NULL, + bits_WP_TO_DOOR | bits_WP_DONT_SIMPLIFY, + NO_NODE, + bits_BUILD_GROUND | bits_BUILD_IGNORE_NPCS, + 0.0); + + if ( pOpenDoorRoute ) + { + if ( AIIsDebuggingDoors(this) ) + { + NDebugOverlay::Cross3D(opendata.vecStandPos + Vector(0,0,1), 32, 255, 255, 255, false, 1.0 ); + Msg( "Opening door!\n" ); + } + + // Attach the door to the waypoint so we open it when we get there. + // dvs: FIXME: this is kind of bullshit, I need to find the exact waypoint to open the door + // should I just walk the path until I find it? + pOpenDoorRoute->m_hData = pDoor; + + GetNavigator()->GetPath()->PrependWaypoints( pOpenDoorRoute ); + + m_hOpeningDoor = pDoor; + pMoveGoal->maxDist = distClear; + *pResult = AIMR_CHANGE_TYPE; + + return true; + } + else + AIDoorDebugMsg( this, "Failed create door route!\n" ); + } + + return false; +} + + +//----------------------------------------------------------------------------- +// Purpose: Called by the navigator to initiate the opening of a prop_door +// that is in our way. +//----------------------------------------------------------------------------- +void CAI_BaseNPC::OpenPropDoorBegin( CBasePropDoor *pDoor ) +{ + // dvs: not quite working, disabled for now. + //opendata_t opendata; + //pDoor->GetNPCOpenData(this, opendata); + // + //if (HaveSequenceForActivity(opendata.eActivity)) + //{ + // SetIdealActivity(opendata.eActivity); + //} + //else + { + // We don't have an appropriate sequence, just open the door magically. + OpenPropDoorNow( pDoor ); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Called when we are trying to open a prop_door and it's time to start +// the door moving. This is called either in response to an anim event +// or as a fallback when we don't have an appropriate open activity. +//----------------------------------------------------------------------------- +void CAI_BaseNPC::OpenPropDoorNow( CBasePropDoor *pDoor ) +{ + // Start the door moving. + pDoor->NPCOpenDoor(this); + + // Wait for the door to finish opening before trying to move through the doorway. + m_flMoveWaitFinished = gpGlobals->curtime + pDoor->GetOpenInterval(); +} + + +//----------------------------------------------------------------------------- +// Purpose: Called when the door we were trying to open becomes fully open. +// Input : pDoor - +//----------------------------------------------------------------------------- +void CAI_BaseNPC::OnDoorFullyOpen(CBasePropDoor *pDoor) +{ + // We're done with the door. + m_hOpeningDoor = NULL; +} + + +//----------------------------------------------------------------------------- +// Purpose: Called when the door we were trying to open becomes blocked before opening. +// Input : pDoor - +//----------------------------------------------------------------------------- +void CAI_BaseNPC::OnDoorBlocked(CBasePropDoor *pDoor) +{ + // dvs: FIXME: do something so that we don't loop forever trying to open this door + // not clearing out the door handle will cause the NPC to invalidate the connection + // We're done with the door. + //m_hOpeningDoor = NULL; +} + + +//----------------------------------------------------------------------------- +// Purpose: Template NPCs are marked as templates by the level designer. They +// do not spawn, but their keyvalues are saved for use by a template +// spawner. +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::IsTemplate( void ) +{ + return HasSpawnFlags( SF_NPC_TEMPLATE ); +} + + + +//----------------------------------------------------------------------------- +// +// Movement code for walking + flying +// +//----------------------------------------------------------------------------- +int CAI_BaseNPC::FlyMove( const Vector& pfPosition, unsigned int mask ) +{ + Vector oldorg, neworg; + trace_t trace; + + // try the move + VectorCopy( GetAbsOrigin(), oldorg ); + VectorAdd( oldorg, pfPosition, neworg ); + UTIL_TraceEntity( this, oldorg, neworg, mask, &trace ); + if (trace.fraction == 1) + { + if ( (GetFlags() & FL_SWIM) && enginetrace->GetPointContents(trace.endpos) == CONTENTS_EMPTY ) + return false; // swim monster left water + + SetAbsOrigin( trace.endpos ); + PhysicsTouchTriggers(); + return true; + } + + return false; +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Input : ent - +// Dir - Normalized direction vector for movement. +// dist - Distance along 'Dir' to move. +// iMode - +// Output : Returns nonzero on success, zero on failure. +//----------------------------------------------------------------------------- +int CAI_BaseNPC::WalkMove( const Vector& vecPosition, unsigned int mask ) +{ + if ( GetFlags() & (FL_FLY | FL_SWIM) ) + { + return FlyMove( vecPosition, mask ); + } + + if ( (GetFlags() & FL_ONGROUND) == 0 ) + { + return 0; + } + + trace_t trace; + Vector oldorg, neworg, end; + Vector move( vecPosition[0], vecPosition[1], 0.0f ); + VectorCopy( GetAbsOrigin(), oldorg ); + VectorAdd( oldorg, move, neworg ); + + // push down from a step height above the wished position + float flStepSize = sv_stepsize.GetFloat(); + neworg[2] += flStepSize; + VectorCopy(neworg, end); + end[2] -= flStepSize*2; + + UTIL_TraceEntity( this, neworg, end, mask, &trace ); + if ( trace.allsolid ) + return false; + + if (trace.startsolid) + { + neworg[2] -= flStepSize; + UTIL_TraceEntity( this, neworg, end, mask, &trace ); + if ( trace.allsolid || trace.startsolid ) + return false; + } + + if (trace.fraction == 1) + { + // if monster had the ground pulled out, go ahead and fall + if ( GetFlags() & FL_PARTIALGROUND ) + { + SetAbsOrigin( oldorg + move ); + PhysicsTouchTriggers(); + SetGroundEntity( NULL ); + return true; + } + + return false; // walked off an edge + } + + // check point traces down for dangling corners + SetAbsOrigin( trace.endpos ); + + if (UTIL_CheckBottom( this, NULL, flStepSize ) == 0) + { + if ( GetFlags() & FL_PARTIALGROUND ) + { + // entity had floor mostly pulled out from underneath it + // and is trying to correct + PhysicsTouchTriggers(); + return true; + } + + // Reset to original position + SetAbsOrigin( oldorg ); + return false; + } + + if ( GetFlags() & FL_PARTIALGROUND ) + { + // Con_Printf ("back on ground\n"); + RemoveFlag( FL_PARTIALGROUND ); + } + + // the move is ok + SetGroundEntity( trace.m_pEnt ); + PhysicsTouchTriggers(); + return true; +} + +//----------------------------------------------------------------------------- + +static void AIMsgGuts( CAI_BaseNPC *pAI, unsigned flags, const char *pszMsg ) +{ + int len = strlen( pszMsg ); + const char *pszFmt2 = NULL; + + if ( len && pszMsg[len-1] == '\n' ) + { + (const_cast(pszMsg))[len-1] = 0; + pszFmt2 = "%s (%s: %d/%s) [%d]\n"; + } + else + pszFmt2 = "%s (%s: %d/%s) [%d]"; + + DevMsg( pszFmt2, + pszMsg, + pAI->GetClassname(), + pAI->entindex(), + ( pAI->GetEntityName() == NULL_STRING ) ? "" : STRING(pAI->GetEntityName()), + gpGlobals->tickcount ); +} + +void DevMsg( CAI_BaseNPC *pAI, unsigned flags, const char *pszFormat, ... ) +{ + if ( (flags & AIMF_IGNORE_SELECTED) || (pAI->m_debugOverlays & OVERLAY_NPC_SELECTED_BIT) ) + { + va_list ap; + va_start(ap, pszFormat); + char szTempMsgBuf[512]; + V_vsprintf_safe( szTempMsgBuf, pszFormat, ap ); + + AIMsgGuts( pAI, flags, szTempMsgBuf ); + va_end(ap); + } +} + +//----------------------------------------------------------------------------- + +void DevMsg( CAI_BaseNPC *pAI, const char *pszFormat, ... ) +{ + if ( (pAI->m_debugOverlays & OVERLAY_NPC_SELECTED_BIT) ) + { + va_list ap; + va_start(ap, pszFormat); + char szTempMsgBuf[512]; + V_vsprintf_safe( szTempMsgBuf, pszFormat, ap ); + + AIMsgGuts( pAI, 0, szTempMsgBuf ); + va_end(ap); + } +} + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::IsPlayerAlly( CBasePlayer *pPlayer ) +{ + if ( pPlayer == NULL ) + { + // in multiplayer mode we need a valid pPlayer + // or override this virtual function + if ( !AI_IsSinglePlayer() ) + return false; + + // NULL means single player mode + pPlayer = UTIL_GetLocalPlayer(); + } + + return ( !pPlayer || IRelationType( pPlayer ) == D_LI ); +} + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::SetCommandGoal( const Vector &vecGoal ) +{ + m_vecCommandGoal = vecGoal; + m_CommandMoveMonitor.ClearMark(); +} + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::ClearCommandGoal() +{ + m_vecCommandGoal = vec3_invalid; + m_CommandMoveMonitor.ClearMark(); +} + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::IsInPlayerSquad() const +{ + return ( m_pSquad && MAKE_STRING(m_pSquad->GetName()) == GetPlayerSquadName() && !CAI_Squad::IsSilentMember(this) ); +} + + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::CanBeUsedAsAFriend( void ) +{ + if ( IsCurSchedule(SCHED_FORCED_GO) || IsCurSchedule(SCHED_FORCED_GO_RUN) ) + return false; + return true; +} + +//----------------------------------------------------------------------------- + +Vector CAI_BaseNPC::GetSmoothedVelocity( void ) +{ + if( GetNavType() == NAV_GROUND || GetNavType() == NAV_FLY ) + { + return m_pMotor->GetCurVel(); + } + + return BaseClass::GetSmoothedVelocity(); +} + + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::IsCoverPosition( const Vector &vecThreat, const Vector &vecPosition ) +{ + trace_t tr; + + // By default, we ignore the viewer (me) when determining cover positions + CTraceFilterLOS filter( NULL, COLLISION_GROUP_NONE, this ); + + // If I'm trying to find cover from the player, and the player is in a vehicle, + // ignore the vehicle for the purpose of determining line of sight. + CBaseEntity *pEnemy = GetEnemy(); + if ( pEnemy ) + { + // Hack to see if our threat position is our enemy + bool bThreatPosIsEnemy = ( (vecThreat - GetEnemy()->EyePosition()).LengthSqr() < 0.1f ); + if ( bThreatPosIsEnemy ) + { + CBaseCombatCharacter *pCCEnemy = GetEnemy()->MyCombatCharacterPointer(); + if ( pCCEnemy != NULL && pCCEnemy->IsInAVehicle() ) + { + // Ignore the vehicle + filter.SetPassEntity( pCCEnemy->GetVehicleEntity() ); + } + + if ( !filter.GetPassEntity() ) + { + filter.SetPassEntity( pEnemy ); + } + } + } + + AI_TraceLOS( vecThreat, vecPosition, this, &tr, &filter ); + + if( tr.fraction != 1.0 && hl2_episodic.GetBool() ) + { + if( tr.m_pEnt->m_iClassname == m_iClassname ) + { + // Don't hide behind buddies! + return false; + } + } + + return (tr.fraction != 1.0); +} + +//----------------------------------------------------------------------------- + +float CAI_BaseNPC::SetWait( float minWait, float maxWait ) +{ + int minThinks = Ceil2Int( minWait * 10 ); + + if ( maxWait == 0.0 ) + { + m_flWaitFinished = gpGlobals->curtime + ( 0.1 * minThinks ); + } + else + { + if ( minThinks == 0 ) // random 0..n is almost certain to not return 0 + minThinks = 1; + int maxThinks = Ceil2Int( maxWait * 10 ); + + m_flWaitFinished = gpGlobals->curtime + ( 0.1 * random->RandomInt( minThinks, maxThinks ) ); + } + return m_flWaitFinished; +} + +//----------------------------------------------------------------------------- + +void CAI_BaseNPC::ClearWait() +{ + m_flWaitFinished = FLT_MAX; +} + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::IsWaitFinished() +{ + return ( gpGlobals->curtime >= m_flWaitFinished ); +} + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::IsWaitSet() +{ + return ( m_flWaitFinished != FLT_MAX ); +} + +void CAI_BaseNPC::TestPlayerPushing( CBaseEntity *pEntity ) +{ + if ( HasSpawnFlags( SF_NPC_NO_PLAYER_PUSHAWAY ) ) + return; + + // Heuristic for determining if the player is pushing me away + CBasePlayer *pPlayer = ToBasePlayer( pEntity ); + if ( pPlayer && !( pPlayer->GetFlags() & FL_NOTARGET ) ) + { + if ( (pPlayer->m_nButtons & (IN_FORWARD|IN_BACK|IN_MOVELEFT|IN_MOVERIGHT)) || + pPlayer->GetAbsVelocity().AsVector2D().LengthSqr() > 50*50 ) + { + SetCondition( COND_PLAYER_PUSHING ); + Vector vecPush = GetAbsOrigin() - pPlayer->GetAbsOrigin(); + VectorNormalize( vecPush ); + CascadePlayerPush( vecPush, pPlayer->WorldSpaceCenter() ); + } + } +} + +void CAI_BaseNPC::CascadePlayerPush( const Vector &push, const Vector &pushOrigin ) +{ + // + // Try to push any friends that are in the way. + // + float hullWidth = GetHullWidth(); + const Vector & origin = GetAbsOrigin(); + const Vector2D &origin2D = origin.AsVector2D(); + + const float MIN_Z_TO_TRANSMIT = GetHullHeight() * 0.5 + 0.1; + const float DIST_REQD_TO_TRANSMIT_PUSH_SQ = Square( hullWidth * 5 + 0.1 ); + const float DIST_FROM_PUSH_VECTOR_REQD_SQ = Square( hullWidth + 0.1 ); + + Vector2D pushTestPoint = vec2_invalid; + + for ( int i = 0; i < g_AI_Manager.NumAIs(); i++ ) + { + CAI_BaseNPC *pOther = g_AI_Manager.AccessAIs()[i]; + if ( pOther != this && pOther->IRelationType(this) == D_LI && !pOther->HasCondition( COND_PLAYER_PUSHING ) ) + { + const Vector &friendOrigin = pOther->GetAbsOrigin(); + if ( fabsf( friendOrigin.z - origin.z ) < MIN_Z_TO_TRANSMIT && + ( friendOrigin.AsVector2D() - origin.AsVector2D() ).LengthSqr() < DIST_REQD_TO_TRANSMIT_PUSH_SQ ) + { + if ( pushTestPoint == vec2_invalid ) + { + pushTestPoint = origin2D - pushOrigin.AsVector2D(); + // No normalize, since it wants to just be a big number and we can't be less that a hull away + pushTestPoint *= 2000; + pushTestPoint += origin2D; + + } + float t; + float distSq = CalcDistanceSqrToLine2D( friendOrigin.AsVector2D(), origin2D, pushTestPoint, &t ); + if ( t > 0 && distSq < DIST_FROM_PUSH_VECTOR_REQD_SQ ) + { + pOther->SetCondition( COND_PLAYER_PUSHING ); + } + } + } + } +} + + +//----------------------------------------------------------------------------- +// Break into pieces! +//----------------------------------------------------------------------------- +void CAI_BaseNPC::Break( CBaseEntity *pBreaker ) +{ + m_takedamage = DAMAGE_NO; + + Vector velocity; + AngularImpulse angVelocity; + IPhysicsObject *pPhysics = VPhysicsGetObject(); + Vector origin; + QAngle angles; + AddSolidFlags( FSOLID_NOT_SOLID ); + if ( pPhysics ) + { + pPhysics->GetVelocity( &velocity, &angVelocity ); + pPhysics->GetPosition( &origin, &angles ); + pPhysics->RecheckCollisionFilter(); + } + else + { + velocity = GetAbsVelocity(); + QAngleToAngularImpulse( GetLocalAngularVelocity(), angVelocity ); + origin = GetAbsOrigin(); + angles = GetAbsAngles(); + } + + breakablepropparams_t params( GetAbsOrigin(), GetAbsAngles(), velocity, angVelocity ); + params.impactEnergyScale = m_impactEnergyScale; + params.defCollisionGroup = GetCollisionGroup(); + if ( params.defCollisionGroup == COLLISION_GROUP_NONE ) + { + // don't automatically make anything COLLISION_GROUP_NONE or it will + // collide with debris being ejected by breaking + params.defCollisionGroup = COLLISION_GROUP_INTERACTIVE; + } + + // no damage/damage force? set a burst of 100 for some movement + params.defBurstScale = 100;//pDamageInfo ? 0 : 100; + PropBreakableCreateAll( GetModelIndex(), pPhysics, params, this, -1, false ); + + UTIL_Remove(this); +} + + +//----------------------------------------------------------------------------- +// Purpose: Input handler for breaking the breakable immediately. +//----------------------------------------------------------------------------- +void CAI_BaseNPC::InputBreak( inputdata_t &inputdata ) +{ + Break( inputdata.pActivator ); +} + + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::FindNearestValidGoalPos( const Vector &vTestPoint, Vector *pResult ) +{ + AIMoveTrace_t moveTrace; + Vector vCandidate = vec3_invalid; + if ( GetNavigator()->CanFitAtPosition( vTestPoint, MASK_SOLID_BRUSHONLY ) ) + { + if ( GetMoveProbe()->CheckStandPosition( vTestPoint, MASK_SOLID_BRUSHONLY ) ) + { + vCandidate = vTestPoint; + } + } + + if ( vCandidate == vec3_invalid ) + { + int iNearestNode = GetPathfinder()->NearestNodeToPoint( vTestPoint ); + if ( iNearestNode != NO_NODE ) + { + GetMoveProbe()->MoveLimit( NAV_GROUND, + g_pBigAINet->GetNodePosition(GetHullType(), iNearestNode ), + vTestPoint, + MASK_SOLID_BRUSHONLY, + NULL, + 0, + &moveTrace ); + if ( ( moveTrace.vEndPosition - vTestPoint ).Length2DSqr() < Square( GetHullWidth() * 3.0 ) && + GetMoveProbe()->CheckStandPosition( moveTrace.vEndPosition, MASK_SOLID_BRUSHONLY ) ) + { + vCandidate = moveTrace.vEndPosition; + } + } + } + + if ( vCandidate != vec3_invalid ) + { + AI_Waypoint_t *pPathToPoint = GetPathfinder()->BuildRoute( GetAbsOrigin(), vCandidate, AI_GetSinglePlayer(), 5*12, NAV_NONE, true ); + if ( pPathToPoint ) + { + GetPathfinder()->UnlockRouteNodes( pPathToPoint ); + CAI_Path tempPath; + tempPath.SetWaypoints( pPathToPoint ); // path object will delete waypoints + } + else + vCandidate = vec3_invalid; + } + + if ( vCandidate == vec3_invalid ) + { + GetMoveProbe()->MoveLimit( NAV_GROUND, + GetAbsOrigin(), + vTestPoint, + MASK_SOLID_BRUSHONLY, + NULL, + 0, + &moveTrace ); + vCandidate = moveTrace.vEndPosition; + } + + if ( vCandidate == vec3_invalid ) + return false; + + if ( pResult != NULL ) + { + *pResult = vCandidate; + } + + return true; +} + +//--------------------------------------------------------- +// Pass a direction to get how far an NPC would see if facing +// that direction. Pass nothing to get the length of the NPC's +// current line of sight. +//--------------------------------------------------------- +float CAI_BaseNPC::LineOfSightDist( const Vector &vecDir, float zEye ) +{ + Vector testDir; + if( vecDir == vec3_invalid ) + { + testDir = EyeDirection3D(); + } + else + { + testDir = vecDir; + } + + if ( zEye == FLT_MAX ) + zEye = EyePosition().z; + + trace_t tr; + // Need to center trace so don't get erratic results based on orientation + Vector testPos( GetAbsOrigin().x, GetAbsOrigin().y, zEye ); + AI_TraceLOS( testPos, testPos + testDir * MAX_COORD_RANGE, this, &tr ); + return (tr.startpos - tr.endpos ).Length(); +} + +ConVar ai_LOS_mode( "ai_LOS_mode", "0", FCVAR_REPLICATED ); + +//----------------------------------------------------------------------------- +// Purpose: Use this to perform AI tracelines that are trying to determine LOS between points. +// LOS checks between entities should use FVisible. +//----------------------------------------------------------------------------- +void AI_TraceLOS( const Vector& vecAbsStart, const Vector& vecAbsEnd, CBaseEntity *pLooker, trace_t *ptr, ITraceFilter *pFilter ) +{ + AI_PROFILE_SCOPE( AI_TraceLOS ); + + if ( ai_LOS_mode.GetBool() ) + { + // Don't use LOS tracefilter + UTIL_TraceLine( vecAbsStart, vecAbsEnd, MASK_BLOCKLOS, pLooker, COLLISION_GROUP_NONE, ptr ); + return; + } + + // Use the custom LOS trace filter + CTraceFilterLOS traceFilter( pLooker, COLLISION_GROUP_NONE ); + if ( !pFilter ) + pFilter = &traceFilter; + AI_TraceLine( vecAbsStart, vecAbsEnd, MASK_BLOCKLOS_AND_NPCS, pFilter, ptr ); +} + +void CAI_BaseNPC::InputSetSpeedModifierRadius( inputdata_t &inputdata ) +{ + m_iSpeedModRadius = inputdata.value.Int(); + m_iSpeedModRadius *= m_iSpeedModRadius; +} +void CAI_BaseNPC::InputSetSpeedModifierSpeed( inputdata_t &inputdata ) +{ + m_iSpeedModSpeed = inputdata.value.Int(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::IsAllowedToDodge( void ) +{ + // Can't do it if I'm not available + if ( m_NPCState != NPC_STATE_IDLE && m_NPCState != NPC_STATE_ALERT && m_NPCState != NPC_STATE_COMBAT ) + return false; + + return ( m_flNextDodgeTime <= gpGlobals->curtime ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::ParseScriptedNPCInteractions( void ) +{ + // Already parsed them? + if ( m_ScriptedInteractions.Count() ) + return; + + // Parse the model's key values and find any dynamic interactions + KeyValues *modelKeyValues = new KeyValues(""); + CUtlBuffer buf( 1024, 0, CUtlBuffer::TEXT_BUFFER ); + + if (! modelinfo->GetModelKeyValue( GetModel(), buf )) + return; + + if ( modelKeyValues->LoadFromBuffer( modelinfo->GetModelName( GetModel() ), buf ) ) + { + // Do we have a dynamic interactions section? + KeyValues *pkvInteractions = modelKeyValues->FindKey("dynamic_interactions"); + if ( pkvInteractions ) + { + KeyValues *pkvNode = pkvInteractions->GetFirstSubKey(); + while ( pkvNode ) + { + ScriptedNPCInteraction_t sInteraction; + sInteraction.iszInteractionName = AllocPooledString( pkvNode->GetName() ); + + // Trigger method + const char *pszTrigger = pkvNode->GetString( "trigger", NULL ); + if ( pszTrigger ) + { + if ( !Q_strncmp( pszTrigger, "auto_in_combat", 14) ) + { + sInteraction.iTriggerMethod = SNPCINT_AUTOMATIC_IN_COMBAT; + } + } + + // Loop Break trigger method + pszTrigger = pkvNode->GetString( "loop_break_trigger", NULL ); + if ( pszTrigger ) + { + char szTrigger[256]; + Q_strncpy( szTrigger, pszTrigger, sizeof(szTrigger) ); + char *pszParam = strtok( szTrigger, " " ); + while (pszParam) + { + if ( !Q_strncmp( pszParam, "on_damage", 9) ) + { + sInteraction.iLoopBreakTriggerMethod |= SNPCINT_LOOPBREAK_ON_DAMAGE; + } + if ( !Q_strncmp( pszParam, "on_flashlight_illum", 19) ) + { + sInteraction.iLoopBreakTriggerMethod |= SNPCINT_LOOPBREAK_ON_FLASHLIGHT_ILLUM; + } + + pszParam = strtok(NULL," "); + } + } + + // Origin + const char *pszOrigin = pkvNode->GetString( "origin_relative", "0 0 0" ); + UTIL_StringToVector( sInteraction.vecRelativeOrigin.Base(), pszOrigin ); + + // Angles + const char *pszAngles = pkvNode->GetString( "angles_relative", NULL ); + if ( pszAngles ) + { + sInteraction.iFlags |= SCNPC_FLAG_TEST_OTHER_ANGLES; + UTIL_StringToVector( sInteraction.angRelativeAngles.Base(), pszAngles ); + } + + // Velocity + const char *pszVelocity = pkvNode->GetString( "velocity_relative", NULL ); + if ( pszVelocity ) + { + sInteraction.iFlags |= SCNPC_FLAG_TEST_OTHER_VELOCITY; + UTIL_StringToVector( sInteraction.vecRelativeVelocity.Base(), pszVelocity ); + } + + // Entry Sequence + const char *pszSequence = pkvNode->GetString( "entry_sequence", NULL ); + if ( pszSequence ) + { + sInteraction.sPhases[SNPCINT_ENTRY].iszSequence = AllocPooledString( pszSequence ); + } + // Entry Activity + const char *pszActivity = pkvNode->GetString( "entry_activity", NULL ); + if ( pszActivity ) + { + sInteraction.sPhases[SNPCINT_ENTRY].iActivity = GetActivityID( pszActivity ); + } + + // Sequence + pszSequence = pkvNode->GetString( "sequence", NULL ); + if ( pszSequence ) + { + sInteraction.sPhases[SNPCINT_SEQUENCE].iszSequence = AllocPooledString( pszSequence ); + } + // Activity + pszActivity = pkvNode->GetString( "activity", NULL ); + if ( pszActivity ) + { + sInteraction.sPhases[SNPCINT_SEQUENCE].iActivity = GetActivityID( pszActivity ); + } + + // Exit Sequence + pszSequence = pkvNode->GetString( "exit_sequence", NULL ); + if ( pszSequence ) + { + sInteraction.sPhases[SNPCINT_EXIT].iszSequence = AllocPooledString( pszSequence ); + } + // Exit Activity + pszActivity = pkvNode->GetString( "exit_activity", NULL ); + if ( pszActivity ) + { + sInteraction.sPhases[SNPCINT_EXIT].iActivity = GetActivityID( pszActivity ); + } + + // Delay + sInteraction.flDelay = pkvNode->GetFloat( "delay", 10.0 ); + + // Delta + sInteraction.flDistSqr = pkvNode->GetFloat( "origin_max_delta", (DSS_MAX_DIST * DSS_MAX_DIST) ); + + // Loop? + if ( pkvNode->GetFloat( "loop_in_action", 0 ) ) + { + sInteraction.iFlags |= SCNPC_FLAG_LOOP_IN_ACTION; + } + + // Fixup position? + const char *pszDontFixup = pkvNode->GetString( "dont_teleport_at_end", NULL ); + if ( pszDontFixup ) + { + if ( !Q_stricmp( pszDontFixup, "me" ) || !Q_stricmp( pszDontFixup, "both" ) ) + { + sInteraction.iFlags |= SCNPC_FLAG_DONT_TELEPORT_AT_END_ME; + } + else if ( !Q_stricmp( pszDontFixup, "them" ) || !Q_stricmp( pszDontFixup, "both" ) ) + { + sInteraction.iFlags |= SCNPC_FLAG_DONT_TELEPORT_AT_END_THEM; + } + } + + // Needs a weapon? + const char *pszNeedsWeapon = pkvNode->GetString( "needs_weapon", NULL ); + if ( pszNeedsWeapon ) + { + if ( !Q_strncmp( pszNeedsWeapon, "ME", 2 ) ) + { + sInteraction.iFlags |= SCNPC_FLAG_NEEDS_WEAPON_ME; + } + else if ( !Q_strncmp( pszNeedsWeapon, "THEM", 4 ) ) + { + sInteraction.iFlags |= SCNPC_FLAG_NEEDS_WEAPON_THEM; + } + else if ( !Q_strncmp( pszNeedsWeapon, "BOTH", 4 ) ) + { + sInteraction.iFlags |= SCNPC_FLAG_NEEDS_WEAPON_ME; + sInteraction.iFlags |= SCNPC_FLAG_NEEDS_WEAPON_THEM; + } + } + + // Specific weapon types + const char *pszWeaponName = pkvNode->GetString( "weapon_mine", NULL ); + if ( pszWeaponName ) + { + sInteraction.iFlags |= SCNPC_FLAG_NEEDS_WEAPON_ME; + sInteraction.iszMyWeapon = AllocPooledString( pszWeaponName ); + } + pszWeaponName = pkvNode->GetString( "weapon_theirs", NULL ); + if ( pszWeaponName ) + { + sInteraction.iFlags |= SCNPC_FLAG_NEEDS_WEAPON_THEM; + sInteraction.iszTheirWeapon = AllocPooledString( pszWeaponName ); + } + + // Add it to the list + AddScriptedNPCInteraction( &sInteraction ); + + // Move to next interaction + pkvNode = pkvNode->GetNextKey(); + } + } + } + + modelKeyValues->deleteThis(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::AddScriptedNPCInteraction( ScriptedNPCInteraction_t *pInteraction ) +{ + int nNewIndex = m_ScriptedInteractions.AddToTail(); + + if ( ai_debug_dyninteractions.GetBool() ) + { + Msg("%s(%s): Added dynamic interaction: %s\n", GetClassname(), GetDebugName(), STRING(pInteraction->iszInteractionName) ); + } + + // Copy the interaction over + ScriptedNPCInteraction_t *pNewInt = &(m_ScriptedInteractions[nNewIndex]); + memcpy( pNewInt, pInteraction, sizeof(ScriptedNPCInteraction_t) ); + + // Calculate the local to world matrix + m_ScriptedInteractions[nNewIndex].matDesiredLocalToWorld.SetupMatrixOrgAngles( pInteraction->vecRelativeOrigin, pInteraction->angRelativeAngles ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +const char *CAI_BaseNPC::GetScriptedNPCInteractionSequence( ScriptedNPCInteraction_t *pInteraction, int iPhase ) +{ + if ( pInteraction->sPhases[iPhase].iActivity != ACT_INVALID ) + { + int iSequence = SelectWeightedSequence( (Activity)pInteraction->sPhases[iPhase].iActivity ); + return GetSequenceName( iSequence ); + } + + if ( pInteraction->sPhases[iPhase].iszSequence != NULL_STRING ) + return STRING(pInteraction->sPhases[iPhase].iszSequence); + + return NULL; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::StartRunningInteraction( CAI_BaseNPC *pOtherNPC, bool bActive ) +{ + m_hInteractionPartner = pOtherNPC; + if ( bActive ) + { + m_iInteractionState = NPCINT_RUNNING_ACTIVE; + } + else + { + m_iInteractionState = NPCINT_RUNNING_PARTNER; + } + m_bCannotDieDuringInteraction = true; + + // Force the NPC into an idle schedule so they don't move. + // NOTE: We must set SCHED_IDLE_STAND directly, to prevent derived NPC + // classes from translating the idle stand schedule away to do something bad. + SetSchedule( GetSchedule(SCHED_IDLE_STAND) ); + + // Prepare the NPC for the script. Setting this allows the scripted sequences + // that we're about to create to immediately grab & use this NPC right away. + // This prevents the NPC from being able to make any schedule decisions + // before the DSS gets underway. + m_scriptState = SCRIPT_PLAYING; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::StartScriptedNPCInteraction( CAI_BaseNPC *pOtherNPC, ScriptedNPCInteraction_t *pInteraction, Vector vecOtherOrigin, QAngle angOtherAngles ) +{ + variant_t emptyVariant; + + StartRunningInteraction( pOtherNPC, true ); + if ( pOtherNPC ) + { + pOtherNPC->StartRunningInteraction( this, false ); + + //Msg("%s(%s) disabled collisions with %s(%s) at %0.2f\n", GetClassname(), GetDebugName(), pOtherNPC->GetClassName(), pOtherNPC->GetDebugName(), gpGlobals->curtime ); + PhysDisableEntityCollisions( this, pOtherNPC ); + } + + // Determine which sequences we're going to use + const char *pszEntrySequence = GetScriptedNPCInteractionSequence( pInteraction, SNPCINT_ENTRY ); + const char *pszSequence = GetScriptedNPCInteractionSequence( pInteraction, SNPCINT_SEQUENCE ); + const char *pszExitSequence = GetScriptedNPCInteractionSequence( pInteraction, SNPCINT_EXIT ); + + // Debug + if ( ai_debug_dyninteractions.GetBool() ) + { + if ( pOtherNPC ) + { + Msg("%s(%s) starting dynamic interaction \"%s\" with %s(%s).\n", GetClassname(), GetDebugName(), STRING(pInteraction->iszInteractionName), pOtherNPC->GetClassname(), pOtherNPC->GetDebugName() ); + if ( pszEntrySequence ) + { + Msg( " - Entry sequence: %s\n", pszEntrySequence ); + } + Msg( " - Core sequence: %s\n", pszSequence ); + if ( pszExitSequence ) + { + Msg( " - Exit sequence: %s\n", pszExitSequence ); + } + } + } + + // Create a scripted sequence name that's guaranteed to be unique + char szSSName[256]; + if ( pOtherNPC ) + { + Q_snprintf( szSSName, sizeof(szSSName), "dss_%s%d%s%d", GetDebugName(), entindex(), pOtherNPC->GetDebugName(), pOtherNPC->entindex() ); + } + else + { + Q_snprintf( szSSName, sizeof(szSSName), "dss_%s%d", GetDebugName(), entindex() ); + } + string_t iszSSName = AllocPooledString(szSSName); + + // Setup next attempt + pInteraction->flNextAttemptTime = gpGlobals->curtime + pInteraction->flDelay + RandomFloat(-2,2); + + // Spawn a scripted sequence for this NPC to play the interaction anim + CAI_ScriptedSequence *pMySequence = (CAI_ScriptedSequence*)CreateEntityByName( "scripted_sequence" ); + pMySequence->KeyValue( "m_iszEntry", pszEntrySequence ); + pMySequence->KeyValue( "m_iszPlay", pszSequence ); + pMySequence->KeyValue( "m_iszPostIdle", pszExitSequence ); + pMySequence->KeyValue( "m_fMoveTo", "5" ); + pMySequence->SetAbsOrigin( GetAbsOrigin() ); + + QAngle angDesired = GetAbsAngles(); + angDesired[YAW] = m_flInteractionYaw; + + pMySequence->SetAbsAngles( angDesired ); + pMySequence->ForceSetTargetEntity( this, true ); + pMySequence->SetName( iszSSName ); + pMySequence->AddSpawnFlags( SF_SCRIPT_NOINTERRUPT | SF_SCRIPT_HIGH_PRIORITY | SF_SCRIPT_OVERRIDESTATE ); + if ((pInteraction->iFlags & SCNPC_FLAG_DONT_TELEPORT_AT_END_ME) != 0) + { + pMySequence->AddSpawnFlags( SF_SCRIPT_DONT_TELEPORT_AT_END ); + } + pMySequence->SetLoopActionSequence( (pInteraction->iFlags & SCNPC_FLAG_LOOP_IN_ACTION) != 0 ); + pMySequence->SetSynchPostIdles( true ); + if ( ai_debug_dyninteractions.GetBool() ) + { + pMySequence->m_debugOverlays |= OVERLAY_TEXT_BIT | OVERLAY_PIVOT_BIT; + } + + // Spawn the matching scripted sequence for the other NPC + CAI_ScriptedSequence *pTheirSequence = NULL; + if ( pOtherNPC ) + { + pTheirSequence = (CAI_ScriptedSequence*)CreateEntityByName( "scripted_sequence" ); + pTheirSequence->KeyValue( "m_iszEntry", pszEntrySequence ); + pTheirSequence->KeyValue( "m_iszPlay", pszSequence ); + pTheirSequence->KeyValue( "m_iszPostIdle", pszExitSequence ); + pTheirSequence->KeyValue( "m_fMoveTo", "5" ); + pTheirSequence->SetAbsOrigin( vecOtherOrigin ); + pTheirSequence->SetAbsAngles( angOtherAngles ); + pTheirSequence->ForceSetTargetEntity( pOtherNPC, true ); + pTheirSequence->SetName( iszSSName ); + pTheirSequence->AddSpawnFlags( SF_SCRIPT_NOINTERRUPT | SF_SCRIPT_HIGH_PRIORITY | SF_SCRIPT_OVERRIDESTATE ); + if ((pInteraction->iFlags & SCNPC_FLAG_DONT_TELEPORT_AT_END_THEM) != 0) + { + pTheirSequence->AddSpawnFlags( SF_SCRIPT_DONT_TELEPORT_AT_END ); + } + pTheirSequence->SetLoopActionSequence( (pInteraction->iFlags & SCNPC_FLAG_LOOP_IN_ACTION) != 0 ); + pTheirSequence->SetSynchPostIdles( true ); + if ( ai_debug_dyninteractions.GetBool() ) + { + pTheirSequence->m_debugOverlays |= OVERLAY_TEXT_BIT | OVERLAY_PIVOT_BIT; + } + + // Tell their sequence to keep their position relative to me + pTheirSequence->SetupInteractionPosition( this, pInteraction->matDesiredLocalToWorld ); + } + + // Spawn both sequences at once + pMySequence->Spawn(); + if ( pTheirSequence ) + { + pTheirSequence->Spawn(); + } + + // Call activate on both sequences at once + pMySequence->Activate(); + if ( pTheirSequence ) + { + pTheirSequence->Activate(); + } + + // Setup the outputs for both sequences. The first kills them both when it finishes + pMySequence->KeyValue( "OnCancelFailedSequence", UTIL_VarArgs("%s,Kill,,0,-1", szSSName ) ); + if ( pszExitSequence ) + { + pMySequence->KeyValue( "OnPostIdleEndSequence", UTIL_VarArgs("%s,Kill,,0,-1", szSSName ) ); + if ( pTheirSequence ) + { + pTheirSequence->KeyValue( "OnPostIdleEndSequence", UTIL_VarArgs("%s,Kill,,0,-1", szSSName ) ); + } + } + else + { + pMySequence->KeyValue( "OnEndSequence", UTIL_VarArgs("%s,Kill,,0,-1", szSSName ) ); + if ( pTheirSequence ) + { + pTheirSequence->KeyValue( "OnEndSequence", UTIL_VarArgs("%s,Kill,,0,-1", szSSName ) ); + } + } + if ( pTheirSequence ) + { + pTheirSequence->KeyValue( "OnCancelFailedSequence", UTIL_VarArgs("%s,Kill,,0,-1", szSSName ) ); + } + + // Tell both sequences to start + pMySequence->AcceptInput( "BeginSequence", this, this, emptyVariant, 0 ); + if ( pTheirSequence ) + { + pTheirSequence->AcceptInput( "BeginSequence", this, this, emptyVariant, 0 ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::CanRunAScriptedNPCInteraction( bool bForced ) +{ + if ( m_NPCState != NPC_STATE_IDLE && m_NPCState != NPC_STATE_ALERT && m_NPCState != NPC_STATE_COMBAT ) + return false; + + if ( !IsAlive() ) + return false; + + if ( IsOnFire() ) + return false; + + if ( IsCrouching() ) + return false; + + // Not while running scripted sequences + if ( m_hCine ) + return false; + + if ( bForced ) + { + if ( !m_hForcedInteractionPartner ) + return false; + } + else + { + if ( m_hForcedInteractionPartner || m_hInteractionPartner ) + return false; + if ( IsInAScript() || !HasCondition(COND_IN_PVS) ) + return false; + if ( HasCondition(COND_HEAR_DANGER) || HasCondition(COND_HEAR_MOVE_AWAY) ) + return false; + + // Default AI prevents interactions while melee attacking, but not ranged attacking + if ( IsCurSchedule( SCHED_MELEE_ATTACK1 ) || IsCurSchedule( SCHED_MELEE_ATTACK2 ) ) + return false; + } + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::CheckForScriptedNPCInteractions( void ) +{ + // Are we being forced to interact with another NPC? If so, do that + if ( m_hForcedInteractionPartner ) + { + CheckForcedNPCInteractions(); + return; + } + + // Otherwise, see if we can interaction with our enemy + if ( !m_ScriptedInteractions.Count() || !GetEnemy() ) + return; + + CAI_BaseNPC *pNPC = GetEnemy()->MyNPCPointer(); + + if( !pNPC ) + return; + + // Recalculate interaction capability whenever we switch enemies + if ( m_hLastInteractionTestTarget != GetEnemy() ) + { + m_hLastInteractionTestTarget = GetEnemy(); + + CalculateValidEnemyInteractions(); + } + + // First, make sure I'm in a state where I can do this + if ( !CanRunAScriptedNPCInteraction() ) + return; + if ( pNPC && !pNPC->CanRunAScriptedNPCInteraction() ) + return; + + for ( int i = 0; i < m_ScriptedInteractions.Count(); i++ ) + { + ScriptedNPCInteraction_t *pInteraction = &m_ScriptedInteractions[i]; + + if ( !pInteraction->bValidOnCurrentEnemy ) + continue; + + if ( pInteraction->flNextAttemptTime > gpGlobals->curtime ) + continue; + + Vector vecOrigin; + QAngle angAngles; + if ( InteractionCouldStart( pNPC, pInteraction, vecOrigin, angAngles ) ) + { + m_iInteractionPlaying = i; + StartScriptedNPCInteraction( pNPC, pInteraction, vecOrigin, angAngles ); + break; + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: Calculate all the valid dynamic interactions we can perform with our current enemy +//----------------------------------------------------------------------------- +void CAI_BaseNPC::CalculateValidEnemyInteractions( void ) +{ + CAI_BaseNPC *pNPC = GetEnemy()->MyNPCPointer(); + if ( !pNPC ) + return; + + bool bDebug = (m_debugOverlays & OVERLAY_NPC_SELECTED_BIT && ai_debug_dyninteractions.GetBool()); + if ( bDebug ) + { + Msg("%s(%s): Computing valid interactions with %s(%s)\n", GetClassname(), GetDebugName(), pNPC->GetClassname(), pNPC->GetDebugName() ); + } + + bool bFound = false; + for ( int i = 0; i < m_ScriptedInteractions.Count(); i++ ) + { + ScriptedNPCInteraction_t *pInteraction = &m_ScriptedInteractions[i]; + pInteraction->bValidOnCurrentEnemy = false; + + // If the trigger method of the interaction isn't the one we're after, we're done + if ( pInteraction->iTriggerMethod != SNPCINT_AUTOMATIC_IN_COMBAT ) + continue; + + if ( !pNPC->GetModelPtr() ) + continue; + + // If we have a damage filter that prevents us hurting the enemy, + // don't interact with him, since most interactions kill the enemy. + // Create a fake damage info to test it with. + CTakeDamageInfo tempinfo( this, this, vec3_origin, vec3_origin, 1.0, DMG_BULLET ); + if ( !pNPC->PassesDamageFilter( tempinfo ) ) + continue; + + // Check the weapon requirements for the interaction + if ( pInteraction->iFlags & SCNPC_FLAG_NEEDS_WEAPON_ME ) + { + if ( !GetActiveWeapon()) + continue; + + // Check the specific weapon type + if ( pInteraction->iszMyWeapon != NULL_STRING && GetActiveWeapon()->m_iClassname != pInteraction->iszMyWeapon ) + continue; + } + if ( pInteraction->iFlags & SCNPC_FLAG_NEEDS_WEAPON_THEM ) + { + if ( !pNPC->GetActiveWeapon() ) + continue; + + // Check the specific weapon type + if ( pInteraction->iszTheirWeapon != NULL_STRING && pNPC->GetActiveWeapon()->m_iClassname != pInteraction->iszTheirWeapon ) + continue; + } + + // Script needs the other NPC, so make sure they're not dead + if ( !pNPC->IsAlive() ) + continue; + + // Use sequence? or activity? + if ( pInteraction->sPhases[SNPCINT_SEQUENCE].iActivity != ACT_INVALID ) + { + // Resolve the activity to a sequence, and make sure our enemy has it + const char *pszSequence = GetScriptedNPCInteractionSequence( pInteraction, SNPCINT_SEQUENCE ); + if ( !pszSequence ) + continue; + if ( pNPC->LookupSequence( pszSequence ) == -1 ) + continue; + } + else + { + if ( pNPC->LookupSequence( STRING(pInteraction->sPhases[SNPCINT_SEQUENCE].iszSequence) ) == -1 ) + continue; + } + + pInteraction->bValidOnCurrentEnemy = true; + bFound = true; + + if ( bDebug ) + { + Msg(" Found: %s\n", STRING(pInteraction->iszInteractionName) ); + } + } + + if ( bDebug && !bFound ) + { + Msg(" No valid interactions found.\n"); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::CheckForcedNPCInteractions( void ) +{ + // If we don't have an interaction, we're waiting for our partner to start it. Do nothing. + if ( m_iInteractionPlaying == NPCINT_NONE ) + return; + + CAI_BaseNPC *pNPC = m_hForcedInteractionPartner->MyNPCPointer(); + bool bAbort = false; + + // First, make sure both NPCs are able to do this + if ( !CanRunAScriptedNPCInteraction( true ) || !pNPC->CanRunAScriptedNPCInteraction( true ) ) + { + // If we were still moving to our target, abort. + if ( m_iInteractionState == NPCINT_MOVING_TO_MARK ) + { + bAbort = true; + } + else + { + return; + } + } + + // Check to see if we can start our interaction. If we can, dance. + Vector vecOrigin; + QAngle angAngles; + + ScriptedNPCInteraction_t *pInteraction = &m_ScriptedInteractions[m_iInteractionPlaying]; + + if ( !bAbort ) + { + if ( !InteractionCouldStart( pNPC, pInteraction, vecOrigin, angAngles ) ) + { + if ( ( gpGlobals->curtime > m_flForcedInteractionTimeout ) && ( m_iInteractionState == NPCINT_MOVING_TO_MARK ) ) + { + bAbort = true; + } + else + { + return; + } + } + } + + if ( bAbort ) + { + if ( m_hForcedInteractionPartner ) + { + // We've aborted a forced interaction. Let the mapmaker know. + m_OnForcedInteractionAborted.FireOutput( this, this ); + } + + CleanupForcedInteraction(); + pNPC->CleanupForcedInteraction(); + + return; + } + + StartScriptedNPCInteraction( pNPC, pInteraction, vecOrigin, angAngles ); + m_OnForcedInteractionStarted.FireOutput( this, this ); +} + + +//----------------------------------------------------------------------------- +// Returns whether two NPCs can fit at each other's origin. +// Kinda like that movie with Eddie Murphy and Dan Akroyd. +//----------------------------------------------------------------------------- +bool CanNPCsTradePlaces( CAI_BaseNPC *pNPC1, CAI_BaseNPC *pNPC2, bool bDebug ) +{ + bool bTest1At2 = true; + bool bTest2At1 = true; + + if ( ( pNPC1->GetHullMins().x <= pNPC2->GetHullMins().x ) && + ( pNPC1->GetHullMins().y <= pNPC2->GetHullMins().y ) && + ( pNPC1->GetHullMins().z <= pNPC2->GetHullMins().z ) && + ( pNPC1->GetHullMaxs().x >= pNPC2->GetHullMaxs().x ) && + ( pNPC1->GetHullMaxs().y >= pNPC2->GetHullMaxs().y ) && + ( pNPC1->GetHullMaxs().z >= pNPC2->GetHullMaxs().z ) ) + { + // 1 bigger than 2 in all axes, skip 2 in 1 test + bTest2At1 = false; + } + else if ( ( pNPC2->GetHullMins().x <= pNPC1->GetHullMins().x ) && + ( pNPC2->GetHullMins().y <= pNPC1->GetHullMins().y ) && + ( pNPC2->GetHullMins().z <= pNPC1->GetHullMins().z ) && + ( pNPC2->GetHullMaxs().x >= pNPC1->GetHullMaxs().x ) && + ( pNPC2->GetHullMaxs().y >= pNPC1->GetHullMaxs().y ) && + ( pNPC2->GetHullMaxs().z >= pNPC1->GetHullMaxs().z ) ) + { + // 2 bigger than 1 in all axes, skip 1 in 2 test + bTest1At2 = false; + } + + trace_t tr; + CTraceFilterSkipTwoEntities traceFilter( pNPC1, pNPC2, COLLISION_GROUP_NONE ); + + if ( bTest1At2 ) + { + AI_TraceHull( pNPC2->GetAbsOrigin(), pNPC2->GetAbsOrigin(), pNPC1->GetHullMins(), pNPC1->GetHullMaxs(), MASK_SOLID, &traceFilter, &tr ); + if ( tr.startsolid ) + { + if ( bDebug ) + { + NDebugOverlay::Box( pNPC2->GetAbsOrigin(), pNPC1->GetHullMins(), pNPC1->GetHullMaxs(), 255,0,0, true, 1.0 ); + } + return false; + } + } + + if ( bTest2At1 ) + { + AI_TraceHull( pNPC1->GetAbsOrigin(), pNPC1->GetAbsOrigin(), pNPC2->GetHullMins(), pNPC2->GetHullMaxs(), MASK_SOLID, &traceFilter, &tr ); + if ( tr.startsolid ) + { + if ( bDebug ) + { + NDebugOverlay::Box( pNPC1->GetAbsOrigin(), pNPC2->GetHullMins(), pNPC2->GetHullMaxs(), 255,0,0, true, 1.0 ); + } + return false; + } + } + + return true; +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::InteractionCouldStart( CAI_BaseNPC *pOtherNPC, ScriptedNPCInteraction_t *pInteraction, Vector &vecOrigin, QAngle &angAngles ) +{ + // Get a matrix that'll convert from my local interaction space to world space + VMatrix matMeToWorld, matLocalToWorld; + QAngle angMyCurrent = GetAbsAngles(); + angMyCurrent[YAW] = m_flInteractionYaw; + matMeToWorld.SetupMatrixOrgAngles( GetAbsOrigin(), angMyCurrent ); + MatrixMultiply( matMeToWorld, pInteraction->matDesiredLocalToWorld, matLocalToWorld ); + + // Get the desired NPC position in worldspace + vecOrigin = matLocalToWorld.GetTranslation(); + MatrixToAngles( matLocalToWorld, angAngles ); + + bool bDebug = ai_debug_dyninteractions.GetBool(); + if ( bDebug ) + { + NDebugOverlay::Axis( vecOrigin, angAngles, 20, true, 0.1 ); + } + + // Determine whether or not the enemy is on the target + float flDistSqr = (vecOrigin - pOtherNPC->GetAbsOrigin()).LengthSqr(); + if ( flDistSqr > pInteraction->flDistSqr ) + { + if ( bDebug ) + { + if ( m_debugOverlays & OVERLAY_NPC_SELECTED_BIT || pOtherNPC->m_debugOverlays & OVERLAY_NPC_SELECTED_BIT ) + { + if ( ai_debug_dyninteractions.GetFloat() == 2 ) + { + Msg(" %s distsqr: %0.2f (%0.2f %0.2f %0.2f), desired: <%0.2f (%0.2f %0.2f %0.2f)\n", GetDebugName(), flDistSqr, + pOtherNPC->GetAbsOrigin().x, pOtherNPC->GetAbsOrigin().y, pOtherNPC->GetAbsOrigin().z, pInteraction->flDistSqr, vecOrigin.x, vecOrigin.y, vecOrigin.z ); + } + } + } + return false; + } + + if ( bDebug ) + { + Msg("DYNINT: (%s) testing interaction \"%s\"\n", GetDebugName(), STRING(pInteraction->iszInteractionName) ); + Msg(" %s is at: %0.2f %0.2f %0.2f\n", GetDebugName(), GetAbsOrigin().x, GetAbsOrigin().y, GetAbsOrigin().z ); + Msg(" %s distsqr: %0.2f (%0.2f %0.2f %0.2f), desired: (%0.2f %0.2f %0.2f)\n", GetDebugName(), flDistSqr, + pOtherNPC->GetAbsOrigin().x, pOtherNPC->GetAbsOrigin().y, pOtherNPC->GetAbsOrigin().z, vecOrigin.x, vecOrigin.y, vecOrigin.z ); + + if ( pOtherNPC ) + { + float flOtherSpeed = pOtherNPC->GetSequenceGroundSpeed( pOtherNPC->GetSequence() ); + Msg(" %s Speed: %.2f\n", pOtherNPC->GetSequenceName( pOtherNPC->GetSequence() ), flOtherSpeed); + } + } + + // Angle check, if we're supposed to + if ( pInteraction->iFlags & SCNPC_FLAG_TEST_OTHER_ANGLES ) + { + QAngle angEnemyAngles = pOtherNPC->GetAbsAngles(); + bool bMatches = true; + for ( int ang = 0; ang < 3; ang++ ) + { + float flAngDiff = AngleDiff( angEnemyAngles[ang], angAngles[ang] ); + if ( fabs(flAngDiff) > DSS_MAX_ANGLE_DIFF ) + { + bMatches = false; + break; + } + } + if ( !bMatches ) + return false; + + if ( bDebug ) + { + Msg(" %s angle matched: (%0.2f %0.2f %0.2f), desired (%0.2f, %0.2f, %0.2f)\n", GetDebugName(), + anglemod(angEnemyAngles.x), anglemod(angEnemyAngles.y), anglemod(angEnemyAngles.z), anglemod(angAngles.x), anglemod(angAngles.y), anglemod(angAngles.z) ); + } + } + + // TODO: Velocity check, if we're supposed to + if ( pInteraction->iFlags & SCNPC_FLAG_TEST_OTHER_VELOCITY ) + { + + } + + // Valid so far. Now check to make sure there's nothing in the way. + // This isn't a very good method of checking, but it's cheap and rules out the problems we're seeing so far. + // If we start getting interactions that start a fair distance apart, we're going to need to do more work here. + trace_t tr; + AI_TraceLine( EyePosition(), pOtherNPC->EyePosition(), MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr); + if ( tr.fraction != 1.0 && tr.m_pEnt != pOtherNPC ) + { + if ( bDebug ) + { + Msg( " %s Interaction was blocked.\n", GetDebugName() ); + NDebugOverlay::Line( tr.startpos, tr.endpos, 0,255,0, true, 1.0 ); + NDebugOverlay::Line( pOtherNPC->EyePosition(), tr.endpos, 255,0,0, true, 1.0 ); + } + return false; + } + + if ( bDebug ) + { + NDebugOverlay::Line( tr.startpos, tr.endpos, 0,255,0, true, 1.0 ); + } + + // Do a knee-level trace to find low physics objects + Vector vecMyKnee, vecOtherKnee; + CollisionProp()->NormalizedToWorldSpace( Vector(0,0,0.25f), &vecMyKnee ); + pOtherNPC->CollisionProp()->NormalizedToWorldSpace( Vector(0,0,0.25f), &vecOtherKnee ); + AI_TraceLine( vecMyKnee, vecOtherKnee, MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr); + if ( tr.fraction != 1.0 && tr.m_pEnt != pOtherNPC ) + { + if ( bDebug ) + { + Msg( " %s Interaction was blocked.\n", GetDebugName() ); + NDebugOverlay::Line( tr.startpos, tr.endpos, 0,255,0, true, 1.0 ); + NDebugOverlay::Line( vecOtherKnee, tr.endpos, 255,0,0, true, 1.0 ); + } + return false; + } + + if ( bDebug ) + { + NDebugOverlay::Line( tr.startpos, tr.endpos, 0,255,0, true, 1.0 ); + } + + // Finally, make sure the NPC can actually fit at the interaction position + // This solves problems with NPCs who are a few units or so above the + // interaction point, and would sink into the ground when playing the anim. + CTraceFilterSkipTwoEntities traceFilter( pOtherNPC, this, COLLISION_GROUP_NONE ); + AI_TraceHull( vecOrigin, vecOrigin, pOtherNPC->GetHullMins(), pOtherNPC->GetHullMaxs(), MASK_SOLID, &traceFilter, &tr ); + if ( tr.startsolid ) + { + if ( bDebug ) + { + NDebugOverlay::Box( vecOrigin, pOtherNPC->GetHullMins(), pOtherNPC->GetHullMaxs(), 255,0,0, true, 1.0 ); + } + return false; + } + + // If the NPCs are swapping places during this interaction, make sure they can fit at each + // others' origins before allowing the interaction. + if ( !CanNPCsTradePlaces( this, pOtherNPC, bDebug ) ) + { + return false; + } + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: Return true if this NPC cannot die because it's in an interaction +// and the flag has been set by the animation. +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::HasInteractionCantDie( void ) +{ + return ( m_bCannotDieDuringInteraction && IsRunningDynamicInteraction() ); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : &inputdata - +//----------------------------------------------------------------------------- +void CAI_BaseNPC::InputForceInteractionWithNPC( inputdata_t &inputdata ) +{ + // Get the interaction name & target + char parseString[255]; + Q_strncpy(parseString, inputdata.value.String(), sizeof(parseString)); + + // First, the target's name + char *pszParam = strtok(parseString," "); + if ( !pszParam || !pszParam[0] ) + { + Warning("%s(%s) received ForceInteractionWithNPC input with bad parameters: %s\nFormat should be: ForceInteractionWithNPC \n", GetClassname(), GetDebugName(), inputdata.value.String() ); + return; + } + // Find the target + CBaseEntity *pTarget = FindNamedEntity( pszParam ); + if ( !pTarget ) + { + Warning("%s(%s) received ForceInteractionWithNPC input, but couldn't find entity named: %s\n", GetClassname(), GetDebugName(), pszParam ); + return; + } + CAI_BaseNPC *pNPC = pTarget->MyNPCPointer(); + if ( !pNPC || !pNPC->GetModelPtr() ) + { + Warning("%s(%s) received ForceInteractionWithNPC input, but entity named %s cannot run dynamic interactions.\n", GetClassname(), GetDebugName(), pszParam ); + return; + } + + // Second, the interaction name + pszParam = strtok(NULL," "); + if ( !pszParam || !pszParam[0] ) + { + Warning("%s(%s) received ForceInteractionWithNPC input with bad parameters: %s\nFormat should be: ForceInteractionWithNPC \n", GetClassname(), GetDebugName(), inputdata.value.String() ); + return; + } + + // Find the interaction from the name, and ensure it's one that the target NPC can play + int iInteraction = -1; + for ( int i = 0; i < m_ScriptedInteractions.Count(); i++ ) + { + if ( Q_strncmp( pszParam, STRING(m_ScriptedInteractions[i].iszInteractionName), strlen(pszParam) ) ) + continue; + + // Use sequence? or activity? + if ( m_ScriptedInteractions[i].sPhases[SNPCINT_SEQUENCE].iActivity != ACT_INVALID ) + { + if ( !pNPC->HaveSequenceForActivity( (Activity)m_ScriptedInteractions[i].sPhases[SNPCINT_SEQUENCE].iActivity ) ) + { + // Other NPC may have all the matching sequences, but just without the activity specified. + // Lets find a single sequence for us, and ensure they have a matching one. + int iMySeq = SelectWeightedSequence( (Activity)m_ScriptedInteractions[i].sPhases[SNPCINT_SEQUENCE].iActivity ); + if ( pNPC->LookupSequence( GetSequenceName(iMySeq) ) == -1 ) + continue; + } + } + else + { + if ( pNPC->LookupSequence( STRING(m_ScriptedInteractions[i].sPhases[SNPCINT_SEQUENCE].iszSequence) ) == -1 ) + continue; + } + + iInteraction = i; + break; + } + + if ( iInteraction == -1 ) + { + Warning("%s(%s) received ForceInteractionWithNPC input, but couldn't find an interaction named %s that entity named %s could run.\n", GetClassname(), GetDebugName(), pszParam, pNPC->GetDebugName() ); + return; + } + + // Found both pieces of data, lets dance. + StartForcedInteraction( pNPC, iInteraction ); + pNPC->StartForcedInteraction( this, NPCINT_NONE ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::StartForcedInteraction( CAI_BaseNPC *pNPC, int iInteraction ) +{ + m_hForcedInteractionPartner = pNPC; + ClearSchedule( "Starting a forced interaction" ); + + m_flForcedInteractionTimeout = gpGlobals->curtime + 8.0f; + m_iInteractionPlaying = iInteraction; + m_iInteractionState = NPCINT_MOVING_TO_MARK; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::CleanupForcedInteraction( void ) +{ + m_hForcedInteractionPartner = NULL; + m_iInteractionPlaying = NPCINT_NONE; + m_iInteractionState = NPCINT_NOT_RUNNING; + m_flForcedInteractionTimeout = 0; +} + +//----------------------------------------------------------------------------- +// Purpose: Calculate a position to move to so that I can interact with my +// target NPC. +// +// FIXME: THIS ONLY WORKS FOR INTERACTIONS THAT REQUIRE THE TARGET +// NPC TO BE SOME DISTANCE DIRECTLY IN FRONT OF ME. +//----------------------------------------------------------------------------- +void CAI_BaseNPC::CalculateForcedInteractionPosition( void ) +{ + if ( m_iInteractionPlaying == NPCINT_NONE ) + return; + + ScriptedNPCInteraction_t *pInteraction = GetRunningDynamicInteraction(); + + // Pretend I was facing the target, and extrapolate from that the position I should be at + Vector vecToTarget = m_hForcedInteractionPartner->GetAbsOrigin() - GetAbsOrigin(); + VectorNormalize( vecToTarget ); + QAngle angToTarget; + VectorAngles( vecToTarget, angToTarget ); + + // Get the desired position in worldspace, relative to the target + VMatrix matMeToWorld, matLocalToWorld; + matMeToWorld.SetupMatrixOrgAngles( GetAbsOrigin(), angToTarget ); + MatrixMultiply( matMeToWorld, pInteraction->matDesiredLocalToWorld, matLocalToWorld ); + + Vector vecOrigin = GetAbsOrigin() - matLocalToWorld.GetTranslation(); + m_vecForcedWorldPosition = m_hForcedInteractionPartner->GetAbsOrigin() + vecOrigin; + + //NDebugOverlay::Axis( m_vecForcedWorldPosition, angToTarget, 20, true, 3.0 ); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : *pPlayer - +//----------------------------------------------------------------------------- +void CAI_BaseNPC::PlayerHasIlluminatedNPC( CBasePlayer *pPlayer, float flDot ) +{ +#ifdef HL2_EPISODIC + if ( IsActiveDynamicInteraction() ) + { + ScriptedNPCInteraction_t *pInteraction = GetRunningDynamicInteraction(); + if ( pInteraction->iLoopBreakTriggerMethod & SNPCINT_LOOPBREAK_ON_FLASHLIGHT_ILLUM ) + { + // Only do this in alyx darkness mode + if ( HL2GameRules()->IsAlyxInDarknessMode() ) + { + // Can only break when we're in the action anim + if ( m_hCine->IsPlayingAction() ) + { + m_hCine->StopActionLoop( true ); + } + } + } + } +#endif +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::ModifyOrAppendCriteria( AI_CriteriaSet& set ) +{ + BaseClass::ModifyOrAppendCriteria( set ); + + // Append time since seen player + if ( m_flLastSawPlayerTime ) + { + set.AppendCriteria( "timesinceseenplayer", UTIL_VarArgs( "%f", gpGlobals->curtime - m_flLastSawPlayerTime ) ); + } + else + { + set.AppendCriteria( "timesinceseenplayer", "-1" ); + } + + // Append distance to my enemy + if ( GetEnemy() ) + { + set.AppendCriteria( "distancetoenemy", UTIL_VarArgs( "%f", EnemyDistance(GetEnemy()) ) ); + } + else + { + set.AppendCriteria( "distancetoenemy", "-1" ); + } +} + +//----------------------------------------------------------------------------- +// If I were crouching at my current location, could I shoot this target? +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::CouldShootIfCrouching( CBaseEntity *pTarget ) +{ + bool bWasStanding = !IsCrouching(); + Crouch(); + + Vector vecTarget; + if (GetActiveWeapon()) + { + vecTarget = pTarget->BodyTarget( GetActiveWeapon()->GetLocalOrigin() ); + } + else + { + vecTarget = pTarget->BodyTarget( GetLocalOrigin() ); + } + + bool bResult = WeaponLOSCondition( GetLocalOrigin(), vecTarget, false ); + + if ( bWasStanding ) + { + Stand(); + } + + return bResult; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::IsCrouchedActivity( Activity activity ) +{ + Activity realActivity = TranslateActivity(activity); + + switch ( realActivity ) + { + case ACT_RELOAD_LOW: + case ACT_COVER_LOW: + case ACT_COVER_PISTOL_LOW: + case ACT_COVER_SMG1_LOW: + case ACT_RELOAD_SMG1_LOW: + return true; + } + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: Get shoot position of BCC at an arbitrary position +//----------------------------------------------------------------------------- +Vector CAI_BaseNPC::Weapon_ShootPosition( void ) +{ + Vector right; + GetVectors( NULL, &right, NULL ); + + bool bStanding = !IsCrouching(); + if ( bStanding && (CapabilitiesGet() & bits_CAP_DUCK) ) + { + if ( IsCrouchedActivity( GetActivity() ) ) + { + bStanding = false; + } + } + + if ( !bStanding ) + return (GetAbsOrigin() + GetCrouchGunOffset() + right * 8); + + return BaseClass::Weapon_ShootPosition(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::ShouldProbeCollideAgainstEntity( CBaseEntity *pEntity ) +{ + if ( pEntity->GetMoveType() == MOVETYPE_VPHYSICS ) + { + if ( ai_test_moveprobe_ignoresmall.GetBool() && IsNavigationUrgent() ) + { + IPhysicsObject *pPhysics = pEntity->VPhysicsGetObject(); + + if ( pPhysics->IsMoveable() && pPhysics->GetMass() < 40.0 ) + return false; + } + } + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::Crouch( void ) +{ + m_bIsCrouching = true; + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::IsCrouching( void ) +{ + return ( (CapabilitiesGet() & bits_CAP_DUCK) && m_bIsCrouching ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::Stand( void ) +{ + if ( m_bForceCrouch ) + return false; + + m_bIsCrouching = false; + DesireStand(); + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CAI_BaseNPC::DesireCrouch( void ) +{ + m_bCrouchDesired = true; +} + +bool CAI_BaseNPC::IsInChoreo() const +{ + return m_bInChoreo; +} -- cgit v1.2.3