From f56bb35301836e56582a575a75864392a0177875 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B8rgen=20P=2E=20Tjern=C3=B8?= Date: Mon, 2 Dec 2013 19:31:46 -0800 Subject: Fix line endings. WHAMMY. --- mp/src/game/server/ai_basenpc.cpp | 28260 ++++++++++++++++++------------------ 1 file changed, 14130 insertions(+), 14130 deletions(-) (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 index 54b47636..1db9eab1 100644 --- a/mp/src/game/server/ai_basenpc.cpp +++ b/mp/src/game/server/ai_basenpc.cpp @@ -1,14130 +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; -} +//========= 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