First version of the SOurce SDK 2013

1 files changed, 14130 insertions, 0 deletions

diff --git a/mp/src/game/server/ai_basenpc.cpp b/mp/src/game/server/ai_basenpc.cpp
new file mode 100644
index 00000000..54b47636
--- /dev/null
+++ b/mp/src/game/server/ai_basenpc.cpp
@@ -0,0 +1,14130 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: 

+//

+//=============================================================================//

+

+#include "cbase.h"

+

+#include "ai_basenpc.h"

+#include "fmtstr.h"

+#include "activitylist.h"

+#include "animation.h"

+#include "basecombatweapon.h"

+#include "soundent.h"

+#include "decals.h"

+#include "entitylist.h"

+#include "eventqueue.h"

+#include "entityapi.h"

+#include "bitstring.h"

+#include "gamerules.h"		// For g_pGameRules

+#include "scripted.h"

+#include "worldsize.h"

+#include "game.h"

+#include "shot_manipulator.h"

+

+#ifdef HL2_DLL

+#include "ai_interactions.h"

+#include "hl2_gamerules.h"

+#endif // HL2_DLL

+

+#include "ai_network.h"

+#include "ai_networkmanager.h"

+#include "ai_pathfinder.h"

+#include "ai_node.h"

+#include "ai_default.h"

+#include "ai_schedule.h"

+#include "ai_task.h"

+#include "ai_hull.h"

+#include "ai_moveprobe.h"

+#include "ai_hint.h"

+#include "ai_navigator.h"

+#include "ai_senses.h"

+#include "ai_squadslot.h"

+#include "ai_memory.h"

+#include "ai_squad.h"

+#include "ai_localnavigator.h"

+#include "ai_tacticalservices.h"

+#include "ai_behavior.h"

+#include "ai_dynamiclink.h"

+#include "AI_Criteria.h"

+#include "basegrenade_shared.h"

+#include "ammodef.h"

+#include "player.h"

+#include "sceneentity.h"

+#include "ndebugoverlay.h"

+#include "mathlib/mathlib.h"

+#include "bone_setup.h"

+#include "IEffects.h"

+#include "vstdlib/random.h"

+#include "engine/IEngineSound.h"

+#include "tier1/strtools.h"

+#include "doors.h"

+#include "BasePropDoor.h"

+#include "saverestore_utlvector.h"

+#include "npcevent.h"

+#include "movevars_shared.h"

+#include "te_effect_dispatch.h"

+#include "globals.h"

+#include "saverestore_bitstring.h"

+#include "checksum_crc.h"

+#include "iservervehicle.h"

+#include "filters.h"

+#ifdef HL2_DLL

+#include "npc_bullseye.h"

+#include "hl2_player.h"

+#include "weapon_physcannon.h"

+#endif

+#include "waterbullet.h"

+#include "in_buttons.h"

+#include "eventlist.h"

+#include "globalstate.h"

+#include "physics_prop_ragdoll.h"

+#include "vphysics/friction.h"

+#include "physics_npc_solver.h"

+#include "tier0/vcrmode.h"

+#include "death_pose.h"

+#include "datacache/imdlcache.h"

+#include "vstdlib/jobthread.h"

+

+#ifdef HL2_EPISODIC

+#include "npc_alyx_episodic.h"

+#endif

+

+#ifdef PORTAL

+	#include "prop_portal_shared.h"

+#endif

+

+#include "env_debughistory.h"

+#include "collisionutils.h"

+

+extern ConVar sk_healthkit;

+

+// dvs: for opening doors -- these should probably not be here

+#include "ai_route.h"

+#include "ai_waypoint.h"

+

+#include "utlbuffer.h"

+#include "gamestats.h"

+

+// memdbgon must be the last include file in a .cpp file!!!

+#include "tier0/memdbgon.h"

+

+#ifdef __clang__

+	// These clang 3.1 warnings don't seem very useful, and cannot easily be

+	// avoided in this file.

+	#pragma GCC diagnostic ignored "-Wdangling-else"	// warning: add explicit braces to avoid dangling else [-Wdangling-else]

+#endif

+

+//#define DEBUG_LOOK

+

+bool RagdollManager_SaveImportant( CAI_BaseNPC *pNPC );

+

+#define	MIN_PHYSICS_FLINCH_DAMAGE	5.0f

+

+#define	NPC_GRENADE_FEAR_DIST		200

+#define	MAX_GLASS_PENETRATION_DEPTH	16.0f

+

+#define FINDNAMEDENTITY_MAX_ENTITIES	32		// max number of entities to be considered for random entity selection in FindNamedEntity

+

+extern bool			g_fDrawLines;

+extern short		g_sModelIndexLaser;		// holds the index for the laser beam

+extern short		g_sModelIndexLaserDot;	// holds the index for the laser beam dot

+

+// Debugging tools

+ConVar	ai_no_select_box( "ai_no_select_box", "0" );

+

+ConVar	ai_show_think_tolerance( "ai_show_think_tolerance", "0" );

+ConVar	ai_debug_think_ticks( "ai_debug_think_ticks", "0" );

+ConVar	ai_debug_doors( "ai_debug_doors", "0" );

+ConVar  ai_debug_enemies( "ai_debug_enemies", "0" );

+

+ConVar	ai_rebalance_thinks( "ai_rebalance_thinks", "1" );

+ConVar	ai_use_efficiency( "ai_use_efficiency", "1" );

+ConVar	ai_use_frame_think_limits( "ai_use_frame_think_limits", "1" );

+ConVar	ai_default_efficient( "ai_default_efficient", ( IsX360() ) ? "1" : "0" );

+ConVar	ai_efficiency_override( "ai_efficiency_override", "0" );

+ConVar	ai_debug_efficiency( "ai_debug_efficiency", "0" );

+ConVar	ai_debug_dyninteractions( "ai_debug_dyninteractions", "0", FCVAR_NONE, "Debug the NPC dynamic interaction system." );

+ConVar	ai_frametime_limit( "ai_frametime_limit", "50", FCVAR_NONE, "frametime limit for min efficiency AIE_NORMAL (in sec's)." );

+

+ConVar	ai_use_think_optimizations( "ai_use_think_optimizations", "1" );

+

+ConVar	ai_test_moveprobe_ignoresmall( "ai_test_moveprobe_ignoresmall", "0" );

+

+#ifdef HL2_EPISODIC

+extern ConVar ai_vehicle_avoidance;

+#endif // HL2_EPISODIC

+

+#ifndef _RETAIL

+#define ShouldUseEfficiency()			( ai_use_think_optimizations.GetBool() && ai_use_efficiency.GetBool() )

+#define ShouldUseFrameThinkLimits()		( ai_use_think_optimizations.GetBool() && ai_use_frame_think_limits.GetBool() )

+#define ShouldRebalanceThinks()			( ai_use_think_optimizations.GetBool() && ai_rebalance_thinks.GetBool() )

+#define ShouldDefaultEfficient()		( ai_use_think_optimizations.GetBool() && ai_default_efficient.GetBool() )

+#else

+#define ShouldUseEfficiency()			( true )

+#define ShouldUseFrameThinkLimits()		( true )

+#define ShouldRebalanceThinks()			( true )

+#define ShouldDefaultEfficient()		( true )

+#endif

+

+#ifndef _RETAIL

+#define DbgEnemyMsg if ( !ai_debug_enemies.GetBool() ) ; else DevMsg

+#else

+#define DbgEnemyMsg if ( 0 ) ; else DevMsg

+#endif

+

+#ifdef DEBUG_AI_FRAME_THINK_LIMITS

+#define DbgFrameLimitMsg DevMsg

+#else

+#define DbgFrameLimitMsg (void)

+#endif

+

+// NPC damage adjusters

+ConVar	sk_npc_head( "sk_npc_head","2" );

+ConVar	sk_npc_chest( "sk_npc_chest","1" );

+ConVar	sk_npc_stomach( "sk_npc_stomach","1" );

+ConVar	sk_npc_arm( "sk_npc_arm","1" );

+ConVar	sk_npc_leg( "sk_npc_leg","1" );

+ConVar	showhitlocation( "showhitlocation", "0" );

+

+// Squad debugging

+ConVar  ai_debug_squads( "ai_debug_squads", "0" );

+ConVar  ai_debug_loners( "ai_debug_loners", "0" );

+

+// Shoot trajectory

+ConVar	ai_lead_time( "ai_lead_time","0.0" );

+ConVar	ai_shot_stats( "ai_shot_stats", "0" );

+ConVar	ai_shot_stats_term( "ai_shot_stats_term", "1000" );

+ConVar	ai_shot_bias( "ai_shot_bias", "1.0" );

+

+ConVar	ai_spread_defocused_cone_multiplier( "ai_spread_defocused_cone_multiplier","3.0" );

+ConVar	ai_spread_cone_focus_time( "ai_spread_cone_focus_time","0.6" );

+ConVar	ai_spread_pattern_focus_time( "ai_spread_pattern_focus_time","0.8" );

+

+ConVar	ai_reaction_delay_idle( "ai_reaction_delay_idle","0.3" );

+ConVar	ai_reaction_delay_alert( "ai_reaction_delay_alert", "0.1" );

+

+ConVar ai_strong_optimizations( "ai_strong_optimizations", ( IsX360() ) ? "1" : "0" );

+bool AIStrongOpt( void )

+{

+	return ai_strong_optimizations.GetBool();

+}

+

+//-----------------------------------------------------------------------------

+//

+// Crude frame timings

+//

+

+CFastTimer g_AIRunTimer;

+CFastTimer g_AIPostRunTimer;

+CFastTimer g_AIMoveTimer;

+

+CFastTimer g_AIConditionsTimer;

+CFastTimer g_AIPrescheduleThinkTimer;

+CFastTimer g_AIMaintainScheduleTimer;

+

+//-----------------------------------------------------------------------------

+//-----------------------------------------------------------------------------

+

+CAI_Manager g_AI_Manager;

+

+//-------------------------------------

+

+CAI_Manager::CAI_Manager()

+{

+	m_AIs.EnsureCapacity( MAX_AIS );

+}

+

+//-------------------------------------

+

+CAI_BaseNPC **CAI_Manager::AccessAIs()

+{

+	if (m_AIs.Count())

+		return &m_AIs[0];

+	return NULL;

+}

+

+//-------------------------------------

+

+int CAI_Manager::NumAIs()

+{

+	return m_AIs.Count();

+}

+

+//-------------------------------------

+

+void CAI_Manager::AddAI( CAI_BaseNPC *pAI )

+{

+	m_AIs.AddToTail( pAI );

+}

+

+//-------------------------------------

+

+void CAI_Manager::RemoveAI( CAI_BaseNPC *pAI )

+{

+	int i = m_AIs.Find( pAI );

+

+	if ( i != -1 )

+		m_AIs.FastRemove( i );

+}

+

+

+//-----------------------------------------------------------------------------

+

+// ================================================================

+//  Init static data

+// ================================================================

+int					CAI_BaseNPC::m_nDebugBits		= 0;

+CAI_BaseNPC*		CAI_BaseNPC::m_pDebugNPC		= NULL;

+int					CAI_BaseNPC::m_nDebugPauseIndex	= -1;

+

+CAI_ClassScheduleIdSpace	CAI_BaseNPC::gm_ClassScheduleIdSpace( true );

+CAI_GlobalScheduleNamespace CAI_BaseNPC::gm_SchedulingSymbols;

+CAI_LocalIdSpace			CAI_BaseNPC::gm_SquadSlotIdSpace( true );

+

+string_t CAI_BaseNPC::gm_iszPlayerSquad;

+

+int		CAI_BaseNPC::gm_iNextThinkRebalanceTick;

+float	CAI_BaseNPC::gm_flTimeLastSpawn;

+int		CAI_BaseNPC::gm_nSpawnedThisFrame;

+

+CSimpleSimTimer CAI_BaseNPC::m_AnyUpdateEnemyPosTimer;

+

+//

+//	Deferred Navigation calls go here

+//

+

+CPostFrameNavigationHook g_PostFrameNavigationHook;

+CPostFrameNavigationHook *PostFrameNavigationSystem( void )

+{

+	return &g_PostFrameNavigationHook;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+bool CPostFrameNavigationHook::Init( void )

+{

+	m_Functors.Purge();

+	m_bGameFrameRunning = false;

+	return true;

+}

+

+// Main query job

+CJob *g_pQueuedNavigationQueryJob = NULL;

+

+static void ProcessNavigationQueries( CFunctor **pData, unsigned int nCount )

+{

+	// Run all queued navigation on a separate thread

+	for ( int i = 0; i < nCount; i++ )

+	{

+		(*pData[i])();

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CPostFrameNavigationHook::FrameUpdatePreEntityThink( void )

+{ 

+	// If the thread is executing, then wait for it to finish

+	if ( g_pQueuedNavigationQueryJob )

+	{

+		g_pQueuedNavigationQueryJob->WaitForFinishAndRelease();

+		g_pQueuedNavigationQueryJob = NULL;

+		m_Functors.Purge();

+	}

+	

+	if ( ai_post_frame_navigation.GetBool() == false )

+		return;

+

+	SetGrameFrameRunning( true ); 

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Now that the game frame has collected all the navigation queries, service them

+//-----------------------------------------------------------------------------

+void CPostFrameNavigationHook::FrameUpdatePostEntityThink( void )

+{

+	if ( ai_post_frame_navigation.GetBool() == false )

+		return;

+

+	// The guts of the NPC will check against this to decide whether or not to queue its navigation calls

+	SetGrameFrameRunning( false );

+

+	// Throw this off to a thread job

+	g_pQueuedNavigationQueryJob = ThreadExecute( &ProcessNavigationQueries, m_Functors.Base(), m_Functors.Count() );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Queue up our navigation call

+//-----------------------------------------------------------------------------

+void CPostFrameNavigationHook::EnqueueEntityNavigationQuery( CAI_BaseNPC *pNPC, CFunctor *pFunctor )

+{

+	if ( ai_post_frame_navigation.GetBool() == false )

+		return;

+

+	m_Functors.AddToTail( pFunctor );

+	pNPC->SetNavigationDeferred( true );

+}

+

+//

+//	Deferred Navigation calls go here

+//

+

+

+// ================================================================

+//  Class Methods

+// ================================================================

+

+//-----------------------------------------------------------------------------

+// Purpose: Static debug function to clear schedules for all NPCS

+// Input  :

+// Output :

+//-----------------------------------------------------------------------------

+void CAI_BaseNPC::ClearAllSchedules(void)

+{

+	CAI_BaseNPC *npc = gEntList.NextEntByClass( (CAI_BaseNPC *)NULL );

+

+	while (npc)

+	{

+		npc->ClearSchedule( "CAI_BaseNPC::ClearAllSchedules" );

+		npc->GetNavigator()->ClearGoal();

+		npc = gEntList.NextEntByClass(npc);

+	}

+}

+

+// ==============================================================================

+

+//-----------------------------------------------------------------------------

+// Purpose:

+// Input  :

+// Output :

+//-----------------------------------------------------------------------------

+bool CAI_BaseNPC::Event_Gibbed( const CTakeDamageInfo &info )

+{

+	bool gibbed = CorpseGib( info );

+

+	if ( gibbed )

+	{

+		// don't remove players!

+		UTIL_Remove( this );

+		SetThink( NULL ); //We're going away, so don't think anymore.

+	}

+	else

+	{

+		CorpseFade();

+	}

+

+	return gibbed;

+}

+

+//=========================================================

+// GetFlinchActivity - determines the best type of flinch

+// anim to play.

+//=========================================================

+Activity CAI_BaseNPC::GetFlinchActivity( bool bHeavyDamage, bool bGesture )

+{

+	Activity	flinchActivity;

+

+	switch ( LastHitGroup() )

+	{

+		// pick a region-specific flinch

+	case HITGROUP_HEAD:

+		flinchActivity = bGesture ? ACT_GESTURE_FLINCH_HEAD : ACT_FLINCH_HEAD;

+		break;

+	case HITGROUP_STOMACH:

+		flinchActivity = bGesture ? ACT_GESTURE_FLINCH_STOMACH : ACT_FLINCH_STOMACH;

+		break;

+	case HITGROUP_LEFTARM:

+		flinchActivity = bGesture ? ACT_GESTURE_FLINCH_LEFTARM : ACT_FLINCH_LEFTARM;

+		break;

+	case HITGROUP_RIGHTARM:

+		flinchActivity = bGesture ? ACT_GESTURE_FLINCH_RIGHTARM : ACT_FLINCH_RIGHTARM;

+		break;

+	case HITGROUP_LEFTLEG:

+		flinchActivity = bGesture ? ACT_GESTURE_FLINCH_LEFTLEG : ACT_FLINCH_LEFTLEG;

+		break;

+	case HITGROUP_RIGHTLEG:

+		flinchActivity = bGesture ? ACT_GESTURE_FLINCH_RIGHTLEG : ACT_FLINCH_RIGHTLEG;

+		break;

+	case HITGROUP_CHEST:

+		flinchActivity = bGesture ? ACT_GESTURE_FLINCH_CHEST : ACT_FLINCH_CHEST;

+		break;

+	case HITGROUP_GEAR:

+	case HITGROUP_GENERIC:

+	default:

+		// just get a generic flinch.

+		if ( bHeavyDamage )

+		{

+			flinchActivity = bGesture ? ACT_GESTURE_BIG_FLINCH : ACT_BIG_FLINCH;

+		}

+		else

+		{

+			flinchActivity = bGesture ? ACT_GESTURE_SMALL_FLINCH : ACT_SMALL_FLINCH;

+		}

+		break;

+	}

+

+	// do we have a sequence for the ideal activity?

+	if ( SelectWeightedSequence ( flinchActivity ) == ACTIVITY_NOT_AVAILABLE )

+	{

+		if ( bHeavyDamage )

+		{

+			flinchActivity = bGesture ? ACT_GESTURE_BIG_FLINCH : ACT_BIG_FLINCH;

+

+			// If we fail at finding a big flinch, resort to a small one

+			if ( SelectWeightedSequence ( flinchActivity ) == ACTIVITY_NOT_AVAILABLE )

+			{

+				flinchActivity = bGesture ? ACT_GESTURE_SMALL_FLINCH : ACT_SMALL_FLINCH;

+			}

+		}

+		else

+		{

+			flinchActivity = bGesture ? ACT_GESTURE_SMALL_FLINCH : ACT_SMALL_FLINCH;

+		}

+	}

+

+	return flinchActivity;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+// Input  :

+//-----------------------------------------------------------------------------

+void CAI_BaseNPC::CleanupOnDeath( CBaseEntity *pCulprit, bool bFireDeathOutput )

+{

+	if ( !m_bDidDeathCleanup )

+	{

+		m_bDidDeathCleanup = true;

+

+		if ( m_NPCState == NPC_STATE_SCRIPT && m_hCine )

+		{

+			// bail out of this script here

+			m_hCine->CancelScript();

+			// now keep going with the death code

+		}

+

+		if ( GetHintNode() )

+		{

+			GetHintNode()->Unlock();

+			SetHintNode( NULL );

+		}

+

+		if( bFireDeathOutput )

+		{

+			m_OnDeath.FireOutput( pCulprit, this );

+		}

+

+		// Vacate any strategy slot I might have

+		VacateStrategySlot();

+

+		// Remove from squad if in one

+		if (m_pSquad)

+		{

+			// If I'm in idle it means that I didn't see who killed me

+			// and my squad is still in idle state. Tell squad we have

+			// an enemy to wake them up and put the enemy position at

+			// my death position

+			if ( m_NPCState == NPC_STATE_IDLE && pCulprit)

+			{

+				// If we already have some danger memory, don't do this cheat

+				if ( GetEnemies()->GetDangerMemory() == NULL )

+				{

+					UpdateEnemyMemory( pCulprit, GetAbsOrigin() );

+				}

+			}

+

+			// Remove from squad

+			m_pSquad->RemoveFromSquad(this, true);

+			m_pSquad = NULL;

+		}

+

+		RemoveActorFromScriptedScenes( this, false /*all scenes*/ );

+	}

+	else

+		DevMsg( "Unexpected double-death-cleanup\n" );

+}

+

+void CAI_BaseNPC::SelectDeathPose( const CTakeDamageInfo &info )

+{

+	if ( !GetModelPtr() || (info.GetDamageType() & DMG_PREVENT_PHYSICS_FORCE) )

+		return;

+

+	if ( ShouldPickADeathPose() == false )

+		return;

+

+	Activity aActivity = ACT_INVALID;

+	int iDeathFrame = 0;

+

+	SelectDeathPoseActivityAndFrame( this, info, LastHitGroup(), aActivity, iDeathFrame );

+	if ( aActivity == ACT_INVALID )

+	{

+		SetDeathPose( ACT_INVALID );

+		SetDeathPoseFrame( 0 );

+		return;

+	}

+

+	SetDeathPose( SelectWeightedSequence( aActivity ) );

+	SetDeathPoseFrame( iDeathFrame );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+// Input  :

+//-----------------------------------------------------------------------------

+void CAI_BaseNPC::Event_Killed( const CTakeDamageInfo &info )

+{

+	if (IsCurSchedule(SCHED_NPC_FREEZE))

+	{

+		// We're frozen; don't die.

+		return;

+	}

+

+	Wake( false );

+	

+	//Adrian: Select a death pose to extrapolate the ragdoll's velocity.

+	SelectDeathPose( info );

+

+	m_lifeState = LIFE_DYING;

+

+	CleanupOnDeath( info.GetAttacker() );

+

+	StopLoopingSounds();

+	DeathSound( info );

+

+	if ( ( GetFlags() & FL_NPC ) && ( ShouldGib( info ) == false ) )

+	{

+		SetTouch( NULL );

+	}

+

+	BaseClass::Event_Killed( info );

+

+	if ( m_bFadeCorpse )

+	{

+		m_bImportanRagdoll = RagdollManager_SaveImportant( this );

+	}

+	

+	// Make sure this condition is fired too (OnTakeDamage breaks out before this happens on death)

+	SetCondition( COND_LIGHT_DAMAGE );

+	SetIdealState( NPC_STATE_DEAD );

+

+	// Some characters rely on getting a state transition, even to death.

+	// zombies, for instance. When a character becomes a ragdoll, their

+	// server entity ceases to think, so we have to set the dead state here

+	// because the AI code isn't going to pick up the change on the next think

+	// for us.

+

+	// Adrian - Only set this if we are going to become a ragdoll. We still want to 

+	// select SCHED_DIE or do something special when this NPC dies and we wont 

+	// catch the change of state if we set this to whatever the ideal state is.

+	if ( CanBecomeRagdoll() || IsRagdoll() )

+		 SetState( NPC_STATE_DEAD );

+

+	// If the remove-no-ragdoll flag is set in the damage type, we're being

+	// told to remove ourselves immediately on death. This is used when something

+	// else has some special reason for us to vanish instead of creating a ragdoll.

+	// i.e. The barnacle does this because it's already got a ragdoll for us.

+	if ( info.GetDamageType() & DMG_REMOVENORAGDOLL )

+	{

+		if ( !IsEFlagSet( EFL_IS_BEING_LIFTED_BY_BARNACLE ) )

+		{

+			// Go away

+			RemoveDeferred();

+		}

+	}

+}

+

+//-----------------------------------------------------------------------------

+

+void CAI_BaseNPC::Ignite( float flFlameLifetime, bool bNPCOnly, float flSize, bool bCalledByLevelDesigner )

+{

+	BaseClass::Ignite( flFlameLifetime, bNPCOnly, flSize, bCalledByLevelDesigner );

+

+#ifdef HL2_EPISODIC

+	CBasePlayer *pPlayer = AI_GetSinglePlayer();

+	if ( pPlayer->IRelationType( this ) != D_LI )

+	{

+		CNPC_Alyx *alyx = CNPC_Alyx::GetAlyx();

+

+		if ( alyx )

+		{

+			alyx->EnemyIgnited( this );

+		}

+	}

+#endif

+}

+

+//-----------------------------------------------------------------------------

+

+ConVar	ai_block_damage( "ai_block_damage","0" );

+

+bool CAI_BaseNPC::PassesDamageFilter( const CTakeDamageInfo &info )

+{

+	if ( ai_block_damage.GetBool() )

+		return false;

+	// FIXME: hook a friendly damage filter to the npc instead?

+	if ( (CapabilitiesGet() & bits_CAP_FRIENDLY_DMG_IMMUNE) && info.GetAttacker() && info.GetAttacker() != this )

+	{

+		// check attackers relationship with me

+		CBaseCombatCharacter *npcEnemy = info.GetAttacker()->MyCombatCharacterPointer();

+		bool bHitByVehicle = false;

+		if ( !npcEnemy )

+		{

+			if ( info.GetAttacker()->GetServerVehicle() )

+			{

+				bHitByVehicle = true;

+			}

+		}

+

+		if ( bHitByVehicle || (npcEnemy && npcEnemy->IRelationType( this ) == D_LI) )

+		{

+			m_fNoDamageDecal = true;

+

+			if ( npcEnemy && npcEnemy->IsPlayer() )

+			{

+				m_OnDamagedByPlayer.FireOutput( info.GetAttacker(), this );

+				// This also counts as being harmed by player's squad.

+				m_OnDamagedByPlayerSquad.FireOutput( info.GetAttacker(), this );

+			}

+

+			return false;

+		}

+	}

+	

+	if ( !BaseClass::PassesDamageFilter( info ) )

+	{

+		m_fNoDamageDecal = true;

+		return false;

+	}

+	return true;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+// Input  :

+// Output :

+//-----------------------------------------------------------------------------

+int CAI_BaseNPC::OnTakeDamage_Alive( const CTakeDamageInfo &info )

+{

+	Forget( bits_MEMORY_INCOVER );

+

+	if ( !BaseClass::OnTakeDamage_Alive( info ) )

+		return 0;

+

+	if ( GetSleepState() == AISS_WAITING_FOR_THREAT )

+		Wake();

+

+	// NOTE: This must happen after the base class is called; we need to reduce

+	// health before the pain sound, since some NPCs use the final health

+	// level as a modifier to determine which pain sound to use.

+

+	// REVISIT: Combine soldiers shoot each other a lot and then talk about it

+	// this improves that case a bunch, but it seems kind of harsh.

+	if ( !m_pSquad || !m_pSquad->SquadIsMember( info.GetAttacker() ) )

+	{

+		PainSound( info );// "Ouch!"

+	}

+

+	// See if we're running a dynamic interaction that should break when I am damaged.

+	if ( IsActiveDynamicInteraction() )

+	{

+		ScriptedNPCInteraction_t *pInteraction = GetRunningDynamicInteraction();

+		if ( pInteraction->iLoopBreakTriggerMethod & SNPCINT_LOOPBREAK_ON_DAMAGE )

+		{

+			// Can only break when we're in the action anim

+			if ( m_hCine->IsPlayingAction() )

+			{

+				m_hCine->StopActionLoop( true );

+			}

+		}

+	}

+

+	// If we're not allowed to die, refuse to die

+	// Allow my interaction partner to kill me though

+	if ( m_iHealth <= 0 && HasInteractionCantDie() && info.GetAttacker() != m_hInteractionPartner )

+	{

+		m_iHealth = 1;

+	}

+

+#if 0

+	// HACKHACK Don't kill npcs in a script.  Let them break their scripts first

+	// THIS is a Half-Life 1 hack that's not cutting the mustard in the scripts

+	// that have been authored for Half-Life 2 thus far. (sjb)

+	if ( m_NPCState == NPC_STATE_SCRIPT )

+	{

+		SetCondition( COND_LIGHT_DAMAGE );

+	}

+#endif

+

+	// -----------------------------------

+	//  Fire outputs

+ 	// -----------------------------------

+	if ( m_flLastDamageTime != gpGlobals->curtime )

+	{

+		// only fire once per frame

+		m_OnDamaged.FireOutput( info.GetAttacker(), this);

+

+		if( info.GetAttacker()->IsPlayer() )

+		{

+			m_OnDamagedByPlayer.FireOutput( info.GetAttacker(), this );

+			

+			// This also counts as being harmed by player's squad.

+			m_OnDamagedByPlayerSquad.FireOutput( info.GetAttacker(), this );

+		}

+		else

+		{

+			// See if the person that injured me is an NPC.

+			CAI_BaseNPC *pAttacker = dynamic_cast<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;

+

+		return UTIL_VecToYaw( vecProjection - GetLocalOrigin() );

+	}

+	else if ( GetNavigator()->GetMovementActivity() == ACT_STRAFE_RIGHT )

+	{

+		vecProjection.x = vecTarget.y;

+		vecProjection.y = vecTarget.x;

+

+		return UTIL_VecToYaw( vecProjection - GetLocalOrigin() );

+	}

+	else

+	{

+		return UTIL_VecToYaw ( vecTarget - GetLocalOrigin() );

+	}

+}

+

+//=========================================================

+// SetEyePosition

+//

+// queries the npc's model for $eyeposition and copies

+// that vector to the npc's m_vDefaultEyeOffset and m_vecViewOffset

+//

+//=========================================================

+void CAI_BaseNPC::SetDefaultEyeOffset ( void )

+{

+	if  ( GetModelPtr() )

+	{

+		GetEyePosition( GetModelPtr(), m_vDefaultEyeOffset );

+

+		if ( m_vDefaultEyeOffset == vec3_origin )

+		{

+			if ( Classify() != CLASS_NONE )

+			{

+				DevMsg( "WARNING: %s(%s) has no eye offset in .qc!\n", GetClassname(), STRING(GetModelName()) );

+			}

+			VectorAdd( WorldAlignMins(), WorldAlignMaxs(), m_vDefaultEyeOffset );

+			m_vDefaultEyeOffset *= 0.75;

+		}

+	}

+	else

+		m_vDefaultEyeOffset = vec3_origin;

+

+	SetViewOffset( m_vDefaultEyeOffset );

+

+}

+

+//------------------------------------------------------------------------------

+// Purpose : Returns eye offset for an NPC for the given activity

+// Input   :

+// Output  :

+//------------------------------------------------------------------------------

+Vector CAI_BaseNPC::EyeOffset( Activity nActivity )

+{

+	if ( CapabilitiesGet() & bits_CAP_DUCK )

+	{

+		if ( IsCrouchedActivity( nActivity ) )

+			return GetCrouchEyeOffset();

+	}

+

+	// if the hint doesn't tell anything, assume current state

+	if ( IsCrouching() )

+		return GetCrouchEyeOffset();

+

+	return m_vDefaultEyeOffset * GetModelScale();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+// Output : Vector

+//-----------------------------------------------------------------------------

+Vector CAI_BaseNPC::EyePosition( void ) 

+{

+	if ( IsCrouching() )

+		return GetAbsOrigin() + GetCrouchEyeOffset();

+

+	return BaseClass::EyePosition();

+}

+

+//------------------------------------------------------------------------------

+// Purpose :

+// Input   :

+// Output  :

+//------------------------------------------------------------------------------

+void CAI_BaseNPC::HandleAnimEvent( animevent_t *pEvent )

+{

+	// UNDONE: Share this code into CBaseAnimating as appropriate?

+	switch( pEvent->event )

+	{

+	case SCRIPT_EVENT_DEAD:

+		if ( m_NPCState == NPC_STATE_SCRIPT )

+		{

+			m_lifeState = LIFE_DYING;

+			// Kill me now! (and fade out when CineCleanup() is called)

+#if _DEBUG

+			DevMsg( 2, "Death event: %s\n", GetClassname() );

+#endif

+			m_iHealth = 0;

+		}

+#if _DEBUG

+		else

+			DevWarning( 2, "INVALID death event:%s\n", GetClassname() );

+#endif

+		break;

+	case SCRIPT_EVENT_NOT_DEAD:

+		if ( m_NPCState == NPC_STATE_SCRIPT )

+		{

+			m_lifeState = LIFE_ALIVE;

+			// This is for life/death sequences where the player can determine whether a character is dead or alive after the script

+			m_iHealth = m_iMaxHealth;

+		}

+		break;

+

+	case SCRIPT_EVENT_SOUND:			// Play a named wave file

+		{

+			EmitSound( pEvent->options );

+		}

+		break;

+

+	case SCRIPT_EVENT_SOUND_VOICE:

+		{

+			EmitSound( pEvent->options );

+		}

+		break;

+

+	case SCRIPT_EVENT_SENTENCE_RND1:		// Play a named sentence group 33% of the time

+		if (random->RandomInt(0,2) == 0)

+			break;

+		// fall through...

+	case SCRIPT_EVENT_SENTENCE:			// Play a named sentence group

+		SENTENCEG_PlayRndSz( edict(), pEvent->options, 1.0, SNDLVL_TALKING, 0, 100 );

+		break;

+

+	case SCRIPT_EVENT_FIREEVENT:

+	{

+		//

+		// Fire a script event. The number of the script event to fire is in the options string.

+		//

+		if ( m_hCine != NULL )

+		{

+			m_hCine->FireScriptEvent( atoi( pEvent->options ) );

+		}

+		else

+		{

+			// FIXME: look so see if it's playing a vcd and fire those instead

+			// AssertOnce( 0 );

+		}

+		break;

+	}

+	case SCRIPT_EVENT_FIRE_INPUT:

+		{

+			variant_t emptyVariant;

+			this->AcceptInput( pEvent->options, this, this, emptyVariant, 0 );

+			break;

+		}

+

+	case SCRIPT_EVENT_NOINTERRUPT:		// Can't be interrupted from now on

+		if ( m_hCine )

+			m_hCine->AllowInterrupt( false );

+		break;

+

+	case SCRIPT_EVENT_CANINTERRUPT:		// OK to interrupt now

+		if ( m_hCine )

+			m_hCine->AllowInterrupt( true );

+		break;

+

+#if 0

+	case SCRIPT_EVENT_INAIR:			// Don't engine->DropToFloor()

+	case SCRIPT_EVENT_ENDANIMATION:		// Set ending animation sequence to

+		break;

+#endif

+	case SCRIPT_EVENT_BODYGROUPON:

+	case SCRIPT_EVENT_BODYGROUPOFF:

+	case SCRIPT_EVENT_BODYGROUPTEMP:

+			DevMsg( "Bodygroup!\n" );

+		break;

+

+	case AE_NPC_ATTACK_BROADCAST:

+		break;

+

+	case NPC_EVENT_BODYDROP_HEAVY:

+		if ( GetFlags() & FL_ONGROUND )

+		{

+			EmitSound( "AI_BaseNPC.BodyDrop_Heavy" );

+		}

+		break;

+

+	case NPC_EVENT_BODYDROP_LIGHT:

+		if ( GetFlags() & FL_ONGROUND )

+		{

+			EmitSound( "AI_BaseNPC.BodyDrop_Light" );

+		}

+		break;

+

+	case NPC_EVENT_SWISHSOUND:

+		{

+			// NO NPC may use this anim event unless that npc's precache precaches this sound!!!

+			EmitSound( "AI_BaseNPC.SwishSound" );

+			break;

+		}

+

+

+	case NPC_EVENT_180TURN:

+		{

+			//DevMsg( "Turned!\n" );

+			SetIdealActivity( ACT_IDLE );

+			Forget( bits_MEMORY_TURNING );

+			SetBoneController( 0, GetLocalAngles().y );

+			IncrementInterpolationFrame();

+			break;

+		}

+

+	case NPC_EVENT_ITEM_PICKUP:

+		{

+			CBaseEntity *pPickup = NULL;

+

+			//

+			// Figure out what we're supposed to pick up.

+			//

+			if ( pEvent->options && strlen( pEvent->options ) > 0 )

+			{

+				// Pick up the weapon or item that was specified in the anim event.

+				pPickup = gEntList.FindEntityGenericNearest( pEvent->options, GetAbsOrigin(), 256, this );

+			}

+			else

+			{

+				// Pick up the weapon or item that was found earlier and cached in our target pointer.

+				pPickup = GetTarget();

+			}

+

+			// Make sure we found something to pick up.

+			if ( !pPickup )

+			{

+				TaskFail("Item no longer available!\n");

+				break;

+			}

+

+			// Make sure the item hasn't moved.

+			float flDist = ( pPickup->WorldSpaceCenter() - GetAbsOrigin() ).Length2D();

+			if ( flDist > ITEM_PICKUP_TOLERANCE )

+			{

+				TaskFail("Item has moved!\n");

+				break;

+			}

+

+			CBaseCombatWeapon *pWeapon = dynamic_cast<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;

+}