Fix line endings. WHAMMY.

1 files changed, 14130 insertions, 14130 deletions

diff --git a/mp/src/game/server/ai_basenpc.cpp b/mp/src/game/server/ai_basenpc.cpp
index 54b47636..1db9eab1 100644
--- a/mp/src/game/server/ai_basenpc.cpp
+++ b/mp/src/game/server/ai_basenpc.cpp
@@ -1,14130 +1,14130 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//

-//

-// Purpose: 

-//

-//=============================================================================//

-

-#include "cbase.h"

-

-#include "ai_basenpc.h"

-#include "fmtstr.h"

-#include "activitylist.h"

-#include "animation.h"

-#include "basecombatweapon.h"

-#include "soundent.h"

-#include "decals.h"

-#include "entitylist.h"

-#include "eventqueue.h"

-#include "entityapi.h"

-#include "bitstring.h"

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

-#include "scripted.h"

-#include "worldsize.h"

-#include "game.h"

-#include "shot_manipulator.h"

-

-#ifdef HL2_DLL

-#include "ai_interactions.h"

-#include "hl2_gamerules.h"

-#endif // HL2_DLL

-

-#include "ai_network.h"

-#include "ai_networkmanager.h"

-#include "ai_pathfinder.h"

-#include "ai_node.h"

-#include "ai_default.h"

-#include "ai_schedule.h"

-#include "ai_task.h"

-#include "ai_hull.h"

-#include "ai_moveprobe.h"

-#include "ai_hint.h"

-#include "ai_navigator.h"

-#include "ai_senses.h"

-#include "ai_squadslot.h"

-#include "ai_memory.h"

-#include "ai_squad.h"

-#include "ai_localnavigator.h"

-#include "ai_tacticalservices.h"

-#include "ai_behavior.h"

-#include "ai_dynamiclink.h"

-#include "AI_Criteria.h"

-#include "basegrenade_shared.h"

-#include "ammodef.h"

-#include "player.h"

-#include "sceneentity.h"

-#include "ndebugoverlay.h"

-#include "mathlib/mathlib.h"

-#include "bone_setup.h"

-#include "IEffects.h"

-#include "vstdlib/random.h"

-#include "engine/IEngineSound.h"

-#include "tier1/strtools.h"

-#include "doors.h"

-#include "BasePropDoor.h"

-#include "saverestore_utlvector.h"

-#include "npcevent.h"

-#include "movevars_shared.h"

-#include "te_effect_dispatch.h"

-#include "globals.h"

-#include "saverestore_bitstring.h"

-#include "checksum_crc.h"

-#include "iservervehicle.h"

-#include "filters.h"

-#ifdef HL2_DLL

-#include "npc_bullseye.h"

-#include "hl2_player.h"

-#include "weapon_physcannon.h"

-#endif

-#include "waterbullet.h"

-#include "in_buttons.h"

-#include "eventlist.h"

-#include "globalstate.h"

-#include "physics_prop_ragdoll.h"

-#include "vphysics/friction.h"

-#include "physics_npc_solver.h"

-#include "tier0/vcrmode.h"

-#include "death_pose.h"

-#include "datacache/imdlcache.h"

-#include "vstdlib/jobthread.h"

-

-#ifdef HL2_EPISODIC

-#include "npc_alyx_episodic.h"

-#endif

-

-#ifdef PORTAL

-	#include "prop_portal_shared.h"

-#endif

-

-#include "env_debughistory.h"

-#include "collisionutils.h"

-

-extern ConVar sk_healthkit;

-

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

-#include "ai_route.h"

-#include "ai_waypoint.h"

-

-#include "utlbuffer.h"

-#include "gamestats.h"

-

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

-#include "tier0/memdbgon.h"

-

-#ifdef __clang__

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

-	// avoided in this file.

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

-#endif

-

-//#define DEBUG_LOOK

-

-bool RagdollManager_SaveImportant( CAI_BaseNPC *pNPC );

-

-#define	MIN_PHYSICS_FLINCH_DAMAGE	5.0f

-

-#define	NPC_GRENADE_FEAR_DIST		200

-#define	MAX_GLASS_PENETRATION_DEPTH	16.0f

-

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

-

-extern bool			g_fDrawLines;

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

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

-

-// Debugging tools

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

-

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

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

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

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

-

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

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

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

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

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

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

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

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

-

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

-

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

-

-#ifdef HL2_EPISODIC

-extern ConVar ai_vehicle_avoidance;

-#endif // HL2_EPISODIC

-

-#ifndef _RETAIL

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

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

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

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

-#else

-#define ShouldUseEfficiency()			( true )

-#define ShouldUseFrameThinkLimits()		( true )

-#define ShouldRebalanceThinks()			( true )

-#define ShouldDefaultEfficient()		( true )

-#endif

-

-#ifndef _RETAIL

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

-#else

-#define DbgEnemyMsg if ( 0 ) ; else DevMsg

-#endif

-

-#ifdef DEBUG_AI_FRAME_THINK_LIMITS

-#define DbgFrameLimitMsg DevMsg

-#else

-#define DbgFrameLimitMsg (void)

-#endif

-

-// NPC damage adjusters

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

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

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

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

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

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

-

-// Squad debugging

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

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

-

-// Shoot trajectory

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

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

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

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

-

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

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

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

-

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

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

-

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

-bool AIStrongOpt( void )

-{

-	return ai_strong_optimizations.GetBool();

-}

-

-//-----------------------------------------------------------------------------

-//

-// Crude frame timings

-//

-

-CFastTimer g_AIRunTimer;

-CFastTimer g_AIPostRunTimer;

-CFastTimer g_AIMoveTimer;

-

-CFastTimer g_AIConditionsTimer;

-CFastTimer g_AIPrescheduleThinkTimer;

-CFastTimer g_AIMaintainScheduleTimer;

-

-//-----------------------------------------------------------------------------

-//-----------------------------------------------------------------------------

-

-CAI_Manager g_AI_Manager;

-

-//-------------------------------------

-

-CAI_Manager::CAI_Manager()

-{

-	m_AIs.EnsureCapacity( MAX_AIS );

-}

-

-//-------------------------------------

-

-CAI_BaseNPC **CAI_Manager::AccessAIs()

-{

-	if (m_AIs.Count())

-		return &m_AIs[0];

-	return NULL;

-}

-

-//-------------------------------------

-

-int CAI_Manager::NumAIs()

-{

-	return m_AIs.Count();

-}

-

-//-------------------------------------

-

-void CAI_Manager::AddAI( CAI_BaseNPC *pAI )

-{

-	m_AIs.AddToTail( pAI );

-}

-

-//-------------------------------------

-

-void CAI_Manager::RemoveAI( CAI_BaseNPC *pAI )

-{

-	int i = m_AIs.Find( pAI );

-

-	if ( i != -1 )

-		m_AIs.FastRemove( i );

-}

-

-

-//-----------------------------------------------------------------------------

-

-// ================================================================

-//  Init static data

-// ================================================================

-int					CAI_BaseNPC::m_nDebugBits		= 0;

-CAI_BaseNPC*		CAI_BaseNPC::m_pDebugNPC		= NULL;

-int					CAI_BaseNPC::m_nDebugPauseIndex	= -1;

-

-CAI_ClassScheduleIdSpace	CAI_BaseNPC::gm_ClassScheduleIdSpace( true );

-CAI_GlobalScheduleNamespace CAI_BaseNPC::gm_SchedulingSymbols;

-CAI_LocalIdSpace			CAI_BaseNPC::gm_SquadSlotIdSpace( true );

-

-string_t CAI_BaseNPC::gm_iszPlayerSquad;

-

-int		CAI_BaseNPC::gm_iNextThinkRebalanceTick;

-float	CAI_BaseNPC::gm_flTimeLastSpawn;

-int		CAI_BaseNPC::gm_nSpawnedThisFrame;

-

-CSimpleSimTimer CAI_BaseNPC::m_AnyUpdateEnemyPosTimer;

-

-//

-//	Deferred Navigation calls go here

-//

-

-CPostFrameNavigationHook g_PostFrameNavigationHook;

-CPostFrameNavigationHook *PostFrameNavigationSystem( void )

-{

-	return &g_PostFrameNavigationHook;

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-//-----------------------------------------------------------------------------

-bool CPostFrameNavigationHook::Init( void )

-{

-	m_Functors.Purge();

-	m_bGameFrameRunning = false;

-	return true;

-}

-

-// Main query job

-CJob *g_pQueuedNavigationQueryJob = NULL;

-

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

-{

-	// Run all queued navigation on a separate thread

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

-	{

-		(*pData[i])();

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-//-----------------------------------------------------------------------------

-void CPostFrameNavigationHook::FrameUpdatePreEntityThink( void )

-{ 

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

-	if ( g_pQueuedNavigationQueryJob )

-	{

-		g_pQueuedNavigationQueryJob->WaitForFinishAndRelease();

-		g_pQueuedNavigationQueryJob = NULL;

-		m_Functors.Purge();

-	}

-	

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

-		return;

-

-	SetGrameFrameRunning( true ); 

-}

-

-//-----------------------------------------------------------------------------

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

-//-----------------------------------------------------------------------------

-void CPostFrameNavigationHook::FrameUpdatePostEntityThink( void )

-{

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

-		return;

-

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

-	SetGrameFrameRunning( false );

-

-	// Throw this off to a thread job

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

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: Queue up our navigation call

-//-----------------------------------------------------------------------------

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

-{

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

-		return;

-

-	m_Functors.AddToTail( pFunctor );

-	pNPC->SetNavigationDeferred( true );

-}

-

-//

-//	Deferred Navigation calls go here

-//

-

-

-// ================================================================

-//  Class Methods

-// ================================================================

-

-//-----------------------------------------------------------------------------

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

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-void CAI_BaseNPC::ClearAllSchedules(void)

-{

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

-

-	while (npc)

-	{

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

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

-		npc = gEntList.NextEntByClass(npc);

-	}

-}

-

-// ==============================================================================

-

-//-----------------------------------------------------------------------------

-// Purpose:

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

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

-{

-	bool gibbed = CorpseGib( info );

-

-	if ( gibbed )

-	{

-		// don't remove players!

-		UTIL_Remove( this );

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

-	}

-	else

-	{

-		CorpseFade();

-	}

-

-	return gibbed;

-}

-

-//=========================================================

-// GetFlinchActivity - determines the best type of flinch

-// anim to play.

-//=========================================================

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

-{

-	Activity	flinchActivity;

-

-	switch ( LastHitGroup() )

-	{

-		// pick a region-specific flinch

-	case HITGROUP_HEAD:

-		flinchActivity = bGesture ? ACT_GESTURE_FLINCH_HEAD : ACT_FLINCH_HEAD;

-		break;

-	case HITGROUP_STOMACH:

-		flinchActivity = bGesture ? ACT_GESTURE_FLINCH_STOMACH : ACT_FLINCH_STOMACH;

-		break;

-	case HITGROUP_LEFTARM:

-		flinchActivity = bGesture ? ACT_GESTURE_FLINCH_LEFTARM : ACT_FLINCH_LEFTARM;

-		break;

-	case HITGROUP_RIGHTARM:

-		flinchActivity = bGesture ? ACT_GESTURE_FLINCH_RIGHTARM : ACT_FLINCH_RIGHTARM;

-		break;

-	case HITGROUP_LEFTLEG:

-		flinchActivity = bGesture ? ACT_GESTURE_FLINCH_LEFTLEG : ACT_FLINCH_LEFTLEG;

-		break;

-	case HITGROUP_RIGHTLEG:

-		flinchActivity = bGesture ? ACT_GESTURE_FLINCH_RIGHTLEG : ACT_FLINCH_RIGHTLEG;

-		break;

-	case HITGROUP_CHEST:

-		flinchActivity = bGesture ? ACT_GESTURE_FLINCH_CHEST : ACT_FLINCH_CHEST;

-		break;

-	case HITGROUP_GEAR:

-	case HITGROUP_GENERIC:

-	default:

-		// just get a generic flinch.

-		if ( bHeavyDamage )

-		{

-			flinchActivity = bGesture ? ACT_GESTURE_BIG_FLINCH : ACT_BIG_FLINCH;

-		}

-		else

-		{

-			flinchActivity = bGesture ? ACT_GESTURE_SMALL_FLINCH : ACT_SMALL_FLINCH;

-		}

-		break;

-	}

-

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

-	if ( SelectWeightedSequence ( flinchActivity ) == ACTIVITY_NOT_AVAILABLE )

-	{

-		if ( bHeavyDamage )

-		{

-			flinchActivity = bGesture ? ACT_GESTURE_BIG_FLINCH : ACT_BIG_FLINCH;

-

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

-			if ( SelectWeightedSequence ( flinchActivity ) == ACTIVITY_NOT_AVAILABLE )

-			{

-				flinchActivity = bGesture ? ACT_GESTURE_SMALL_FLINCH : ACT_SMALL_FLINCH;

-			}

-		}

-		else

-		{

-			flinchActivity = bGesture ? ACT_GESTURE_SMALL_FLINCH : ACT_SMALL_FLINCH;

-		}

-	}

-

-	return flinchActivity;

-}

-

-//-----------------------------------------------------------------------------

-// Purpose:

-// Input  :

-//-----------------------------------------------------------------------------

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

-{

-	if ( !m_bDidDeathCleanup )

-	{

-		m_bDidDeathCleanup = true;

-

-		if ( m_NPCState == NPC_STATE_SCRIPT && m_hCine )

-		{

-			// bail out of this script here

-			m_hCine->CancelScript();

-			// now keep going with the death code

-		}

-

-		if ( GetHintNode() )

-		{

-			GetHintNode()->Unlock();

-			SetHintNode( NULL );

-		}

-

-		if( bFireDeathOutput )

-		{

-			m_OnDeath.FireOutput( pCulprit, this );

-		}

-

-		// Vacate any strategy slot I might have

-		VacateStrategySlot();

-

-		// Remove from squad if in one

-		if (m_pSquad)

-		{

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

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

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

-			// my death position

-			if ( m_NPCState == NPC_STATE_IDLE && pCulprit)

-			{

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

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

-				{

-					UpdateEnemyMemory( pCulprit, GetAbsOrigin() );

-				}

-			}

-

-			// Remove from squad

-			m_pSquad->RemoveFromSquad(this, true);

-			m_pSquad = NULL;

-		}

-

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

-	}

-	else

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

-}

-

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

-{

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

-		return;

-

-	if ( ShouldPickADeathPose() == false )

-		return;

-

-	Activity aActivity = ACT_INVALID;

-	int iDeathFrame = 0;

-

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

-	if ( aActivity == ACT_INVALID )

-	{

-		SetDeathPose( ACT_INVALID );

-		SetDeathPoseFrame( 0 );

-		return;

-	}

-

-	SetDeathPose( SelectWeightedSequence( aActivity ) );

-	SetDeathPoseFrame( iDeathFrame );

-}

-

-//-----------------------------------------------------------------------------

-// Purpose:

-// Input  :

-//-----------------------------------------------------------------------------

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

-{

-	if (IsCurSchedule(SCHED_NPC_FREEZE))

-	{

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

-		return;

-	}

-

-	Wake( false );

-	

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

-	SelectDeathPose( info );

-

-	m_lifeState = LIFE_DYING;

-

-	CleanupOnDeath( info.GetAttacker() );

-

-	StopLoopingSounds();

-	DeathSound( info );

-

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

-	{

-		SetTouch( NULL );

-	}

-

-	BaseClass::Event_Killed( info );

-

-	if ( m_bFadeCorpse )

-	{

-		m_bImportanRagdoll = RagdollManager_SaveImportant( this );

-	}

-	

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

-	SetCondition( COND_LIGHT_DAMAGE );

-	SetIdealState( NPC_STATE_DEAD );

-

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

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

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

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

-	// for us.

-

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

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

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

-	if ( CanBecomeRagdoll() || IsRagdoll() )

-		 SetState( NPC_STATE_DEAD );

-

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

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

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

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

-	if ( info.GetDamageType() & DMG_REMOVENORAGDOLL )

-	{

-		if ( !IsEFlagSet( EFL_IS_BEING_LIFTED_BY_BARNACLE ) )

-		{

-			// Go away

-			RemoveDeferred();

-		}

-	}

-}

-

-//-----------------------------------------------------------------------------

-

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

-{

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

-

-#ifdef HL2_EPISODIC

-	CBasePlayer *pPlayer = AI_GetSinglePlayer();

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

-	{

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

-

-		if ( alyx )

-		{

-			alyx->EnemyIgnited( this );

-		}

-	}

-#endif

-}

-

-//-----------------------------------------------------------------------------

-

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

-

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

-{

-	if ( ai_block_damage.GetBool() )

-		return false;

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

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

-	{

-		// check attackers relationship with me

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

-		bool bHitByVehicle = false;

-		if ( !npcEnemy )

-		{

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

-			{

-				bHitByVehicle = true;

-			}

-		}

-

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

-		{

-			m_fNoDamageDecal = true;

-

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

-			{

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

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

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

-			}

-

-			return false;

-		}

-	}

-	

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

-	{

-		m_fNoDamageDecal = true;

-		return false;

-	}

-	return true;

-}

-

-//-----------------------------------------------------------------------------

-// Purpose:

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

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

-{

-	Forget( bits_MEMORY_INCOVER );

-

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

-		return 0;

-

-	if ( GetSleepState() == AISS_WAITING_FOR_THREAT )

-		Wake();

-

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

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

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

-

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

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

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

-	{

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

-	}

-

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

-	if ( IsActiveDynamicInteraction() )

-	{

-		ScriptedNPCInteraction_t *pInteraction = GetRunningDynamicInteraction();

-		if ( pInteraction->iLoopBreakTriggerMethod & SNPCINT_LOOPBREAK_ON_DAMAGE )

-		{

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

-			if ( m_hCine->IsPlayingAction() )

-			{

-				m_hCine->StopActionLoop( true );

-			}

-		}

-	}

-

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

-	// Allow my interaction partner to kill me though

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

-	{

-		m_iHealth = 1;

-	}

-

-#if 0

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

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

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

-	if ( m_NPCState == NPC_STATE_SCRIPT )

-	{

-		SetCondition( COND_LIGHT_DAMAGE );

-	}

-#endif

-

-	// -----------------------------------

-	//  Fire outputs

- 	// -----------------------------------

-	if ( m_flLastDamageTime != gpGlobals->curtime )

-	{

-		// only fire once per frame

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

-

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

-		{

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

-			

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

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

-		}

-		else

-		{

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

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

-}

+//========= 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;
+}