expvintl/source-engine-2018-hl2_src
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
master
source-engine-2018-hl2_src/game/server/ai_basenpc.cpp
FluorescentCIAAfricanAmerican 3bf9df6b27 1
2020-04-22 12:56:21 -04:00

14143 lines
404 KiB
C++
Raw Permalink Blame History

//========= 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<CAI_BaseNPC *>( 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<CNPC_Bullseye*>(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<CBaseGrenade*>((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 <<TODO>>
// 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 //<<TODO>>
// 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 <<TODO>>
// 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 <<TODO>>
// 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<AIRebalanceInfo_t> 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<CBaseEntity *>(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;
vecProjection.z = 0;
return UTIL_VecToYaw( vecProjection - GetLocalOrigin() );
}
else if ( GetNavigator()->GetMovementActivity() == ACT_STRAFE_RIGHT )
{
vecProjection.x = vecTarget.y;
vecProjection.y = vecTarget.x;
vecProjection.z = 0;
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<CBaseCombatWeapon *>( 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 <frame number> \"<ME/THEM> <Amount of damage done>\" }\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<CNPC_Bullseye*>(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<CAI_BaseNPC *>(this))->GetEnemies()->LastKnownPosition( GetEnemy() );
}
float CAI_BaseNPC::GetEnemyLastTimeSeen() const
{
return (const_cast<CAI_BaseNPC *>(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<CAI_BaseNPC *>(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<CBaseFilter*>(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<CBaseFilter*>(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<CBasePropDoor *>( 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<CBaseDoor *>( 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<char *>(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 ) ? "<unnamed>" : 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 <target NPC> <interaction name>\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 <target NPC> <interaction name>\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;
}
Reference in New Issue View Git Blame Copy Permalink