Fix line endings. WHAMMY.

1 files changed, 7764 insertions, 7764 deletions

diff --git a/mp/src/game/server/episodic/npc_hunter.cpp b/mp/src/game/server/episodic/npc_hunter.cpp
index 9d7dfd3e..d55053bc 100644
--- a/mp/src/game/server/episodic/npc_hunter.cpp
+++ b/mp/src/game/server/episodic/npc_hunter.cpp
@@ -1,7764 +1,7764 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//

-//

-// Small, fast version of the strider. Goes where striders cannot, such

-// as into buildings. Best killed with physics objects and explosives.

-//

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

-

-#include "cbase.h"

-#include "npc_strider.h"

-#include "npc_hunter.h"

-#include "ai_behavior_follow.h"

-#include "ai_moveprobe.h"

-#include "ai_senses.h"

-#include "ai_speech.h"

-#include "ai_task.h"

-#include "ai_default.h"

-#include "ai_schedule.h"

-#include "ai_hull.h"

-#include "ai_baseactor.h"

-#include "ai_waypoint.h"

-#include "ai_link.h"

-#include "ai_hint.h"

-#include "ai_squadslot.h"

-#include "ai_squad.h"

-#include "ai_tacticalservices.h"

-#include "beam_shared.h"

-#include "datacache/imdlcache.h"

-#include "eventqueue.h"

-#include "gib.h"

-#include "globalstate.h"

-#include "hierarchy.h"

-#include "movevars_shared.h"

-#include "npcevent.h"

-#include "saverestore_utlvector.h"

-#include "particle_parse.h"

-#include "te_particlesystem.h"

-#include "sceneentity.h"

-#include "shake.h"

-#include "soundenvelope.h"

-#include "soundent.h"

-#include "SpriteTrail.h"

-#include "IEffects.h"

-#include "engine/IEngineSound.h"

-#include "bone_setup.h"

-#include "studio.h"

-#include "ai_route.h"

-#include "ammodef.h"

-#include "npc_bullseye.h"

-#include "physobj.h"

-#include "ai_memory.h"

-#include "collisionutils.h"

-#include "shot_manipulator.h"

-#include "steamjet.h"

-#include "physics_prop_ragdoll.h"

-#include "vehicle_base.h"

-#include "coordsize.h"

-#include "hl2_shareddefs.h"

-#include "te_effect_dispatch.h"

-#include "beam_flags.h"

-#include "prop_combine_ball.h"

-#include "explode.h"

-#include "weapon_physcannon.h"

-#include "weapon_striderbuster.h"

-#include "monstermaker.h"

-#include "weapon_rpg.h"

-

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

-#include "tier0/memdbgon.h"

-

-class CNPC_Hunter;

-

-

-static const char *HUNTER_FLECHETTE_MODEL = "models/weapons/hunter_flechette.mdl";

-

-// Think contexts

-static const char *HUNTER_BLEED_THINK = "HunterBleed";

-static const char *HUNTER_ZAP_THINK = "HunterZap";

-static const char *HUNTER_JOSTLE_VEHICLE_THINK = "HunterJostle";

-

-

-ConVar sk_hunter_health( "sk_hunter_health", "210" );

-

-// Melee attacks

-ConVar sk_hunter_dmg_one_slash( "sk_hunter_dmg_one_slash", "20" );

-ConVar sk_hunter_dmg_charge( "sk_hunter_dmg_charge", "20" );

-

-// Flechette volley attack

-ConVar hunter_flechette_max_range( "hunter_flechette_max_range", "1200" );

-ConVar hunter_flechette_min_range( "hunter_flechette_min_range", "100" );

-ConVar hunter_flechette_volley_size( "hunter_flechette_volley_size", "8" );

-ConVar hunter_flechette_speed( "hunter_flechette_speed", "2000" );

-ConVar sk_hunter_dmg_flechette( "sk_hunter_dmg_flechette", "4.0" );

-ConVar sk_hunter_flechette_explode_dmg( "sk_hunter_flechette_explode_dmg", "12.0" );

-ConVar sk_hunter_flechette_explode_radius( "sk_hunter_flechette_explode_radius", "128.0" );

-ConVar hunter_flechette_explode_delay( "hunter_flechette_explode_delay", "2.5" );

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

-ConVar hunter_first_flechette_delay( "hunter_first_flechette_delay", "0.5" );

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

-ConVar hunter_flechette_volley_start_min_delay( "hunter_flechette_volley_start_min_delay", ".25" );

-ConVar hunter_flechette_volley_start_max_delay( "hunter_flechette_volley_start_max_delay", ".95" );

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

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

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

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

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

-

-// Damage received

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

-ConVar sk_hunter_charge_damage_scale( "sk_hunter_charge_damage_scale", "2.0" );

-ConVar sk_hunter_buckshot_damage_scale( "sk_hunter_buckshot_damage_scale", "0.5" );

-ConVar sk_hunter_vehicle_damage_scale( "sk_hunter_vehicle_damage_scale", "2.2" );

-ConVar sk_hunter_dmg_from_striderbuster( "sk_hunter_dmg_from_striderbuster", "150" );

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

-

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

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

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

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

-

-ConVar hunter_melee_delay( "hunter_melee_delay", "2.0" );

-

-// Bullrush charge.

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

-ConVar hunter_charge_min_delay( "hunter_charge_min_delay", "10.0" );

-ConVar hunter_charge_pct( "hunter_charge_pct", "25" );

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

-

-// Vehicle dodging.

-ConVar hunter_dodge_warning( "hunter_dodge_warning", "1.1" );

-ConVar hunter_dodge_warning_width( "hunter_dodge_warning_width", "180" );

-ConVar hunter_dodge_warning_cone( "hunter_dodge_warning_cone", ".5" );

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

-

-// Jostle vehicles when hit by them

-ConVar hunter_jostle_car_min_speed( "hunter_jostle_car_min_speed", "100" ); // If hit by a car going at least this fast, jostle the car

-ConVar hunter_jostle_car_max_speed( "hunter_jostle_car_max_speed", "600" ); // Used for determining jostle scale

-

-ConVar hunter_free_knowledge( "hunter_free_knowledge", "10.0" );

-ConVar hunter_plant_adjust_z( "hunter_plant_adjust_z", "12" );

-

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

-

-// Dealing with striderbusters

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

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

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

-ConVar hunter_hate_held_striderbusters_delay( "hunter_hate_held_striderbusters_delay", "0.5" );

-ConVar hunter_hate_held_striderbusters_tolerance( "hunter_hate_held_striderbusters_tolerance", "2000.0" );

-ConVar hunter_hate_thrown_striderbusters_tolerance( "hunter_hate_thrown_striderbusters_tolerance", "300.0" );

-ConVar hunter_seek_thrown_striderbusters_tolerance( "hunter_seek_thrown_striderbusters_tolerance", "400.0" );

-ConVar hunter_retreat_striderbusters( "hunter_retreat_striderbusters", "1", FCVAR_NONE, "If true, the hunter will retreat when a buster is glued to him." );

-

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

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

-

-ConVar hunter_stand_still( "hunter_stand_still", "0" ); // used for debugging, keeps them rooted in place

-

-ConVar hunter_siege_frequency( "hunter_siege_frequency", "12" );

-

-#define HUNTER_FOV_DOT					0.0		// 180 degree field of view

-#define HUNTER_CHARGE_MIN				256

-#define HUNTER_CHARGE_MAX				1024

-#define HUNTER_FACE_ENEMY_DIST			512.0f

-#define HUNTER_MELEE_REACH				80

-#define HUNTER_BLOOD_LEFT_FOOT			0

-#define HUNTER_IGNORE_ENEMY_TIME		5		// How long the hunter will ignore another enemy when distracted by the player.

-

-#define HUNTER_FACING_DOT				0.8		// The angle within which we start shooting

-#define HUNTER_SHOOT_MAX_YAW_DEG		60.0f	// Once shooting, clamp to +/- these degrees of yaw deflection as our target moves

-#define HUNTER_SHOOT_MAX_YAW_COS		0.5f	// The cosine of the above angle

-

-#define HUNTER_FLECHETTE_WARN_TIME		1.0f

-

-#define HUNTER_SEE_ENEMY_TIME_INVALID	-1

-

-#define NUM_FLECHETTE_VOLLEY_ON_FOLLOW 4

-

-#define HUNTER_SIEGE_MAX_DIST_MODIFIER 2.0f

-

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

-// Animation events

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

-int AE_HUNTER_FOOTSTEP_LEFT;

-int AE_HUNTER_FOOTSTEP_RIGHT;

-int AE_HUNTER_FOOTSTEP_BACK;

-int AE_HUNTER_MELEE_ANNOUNCE;

-int AE_HUNTER_MELEE_ATTACK_LEFT;

-int AE_HUNTER_MELEE_ATTACK_RIGHT;

-int AE_HUNTER_DIE;

-int AE_HUNTER_SPRAY_BLOOD;

-int AE_HUNTER_START_EXPRESSION;

-int AE_HUNTER_END_EXPRESSION;

-

-

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

-// Interactions.

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

-int g_interactionHunterFoundEnemy = 0;

-

-

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

-// Local stuff.

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

-static string_t s_iszStriderClassname;

-static string_t s_iszStriderBusterClassname;

-static string_t s_iszMagnadeClassname;

-static string_t s_iszPhysPropClassname;

-static string_t s_iszHuntersToRunOver;

-

-

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

-// Custom Activities

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

-Activity ACT_HUNTER_DEPLOYRA2;

-Activity ACT_HUNTER_DODGER;

-Activity ACT_HUNTER_DODGEL;

-Activity ACT_HUNTER_GESTURE_SHOOT;

-Activity ACT_HUNTER_FLINCH_STICKYBOMB;

-Activity ACT_HUNTER_STAGGER;

-Activity ACT_HUNTER_MELEE_ATTACK1_VS_PLAYER;

-Activity ACT_DI_HUNTER_MELEE;

-Activity ACT_DI_HUNTER_THROW;

-Activity ACT_HUNTER_ANGRY;

-Activity ACT_HUNTER_WALK_ANGRY;

-Activity ACT_HUNTER_FOUND_ENEMY;

-Activity ACT_HUNTER_FOUND_ENEMY_ACK;

-Activity ACT_HUNTER_CHARGE_START;

-Activity ACT_HUNTER_CHARGE_RUN;

-Activity ACT_HUNTER_CHARGE_STOP;

-Activity ACT_HUNTER_CHARGE_CRASH;

-Activity ACT_HUNTER_CHARGE_HIT;

-Activity ACT_HUNTER_RANGE_ATTACK2_UNPLANTED;

-Activity ACT_HUNTER_IDLE_PLANTED;

-Activity ACT_HUNTER_FLINCH_N;

-Activity ACT_HUNTER_FLINCH_S;

-Activity ACT_HUNTER_FLINCH_E;

-Activity ACT_HUNTER_FLINCH_W;

-

-

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

-//	Squad slots

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

-enum SquadSlot_t

-{	

-	SQUAD_SLOT_HUNTER_CHARGE = LAST_SHARED_SQUADSLOT,

-	SQUAD_SLOT_HUNTER_FLANK_FIRST,

-	SQUAD_SLOT_HUNTER_FLANK_LAST = SQUAD_SLOT_HUNTER_FLANK_FIRST,

-	SQUAD_SLOT_RUN_SHOOT,

-};

-

-#define	HUNTER_FOLLOW_DISTANCE	2000.0f

-#define	HUNTER_FOLLOW_DISTANCE_SQR	(HUNTER_FOLLOW_DISTANCE * HUNTER_FOLLOW_DISTANCE)

-

-#define HUNTER_RUNDOWN_SQUADDATA 0

-

-

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

-// We're doing this quite a lot, so this makes the check a lot faster since

-// we don't have to compare strings.

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

-bool IsStriderBuster( CBaseEntity *pEntity )

-{

-	if ( !pEntity )

-		return false;

-

-	if( pEntity->m_iClassname == s_iszStriderBusterClassname || 

-		pEntity->m_iClassname == s_iszMagnadeClassname)

-		return true;

-

-	return false;

-}

-

-

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

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

-bool HateThisStriderBuster( CBaseEntity *pTarget )

-{

-	if ( StriderBuster_WasKnockedOffStrider(pTarget) )

-		return false;

-

-	if ( pTarget->VPhysicsGetObject() )

-	{

-		if ( hunter_hate_held_striderbusters.GetBool() || 

-			hunter_hate_thrown_striderbusters.GetBool() ||

-			hunter_hate_attached_striderbusters.GetBool() )

-		{

-			if ( ( pTarget->VPhysicsGetObject()->GetGameFlags() & ( FVPHYSICS_PLAYER_HELD | FVPHYSICS_WAS_THROWN ) ) )

-			{

-				return true;

-			}

-

-			if ( StriderBuster_IsAttachedStriderBuster( pTarget ) )

-			{

-				return true;

-			}

-		}

-	}

-

-	return false;

-}

-

-

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

-// The hunter can fire a volley of explosive flechettes.

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

-static const char *s_szHunterFlechetteBubbles = "HunterFlechetteBubbles";

-static const char *s_szHunterFlechetteSeekThink = "HunterFlechetteSeekThink";

-static const char *s_szHunterFlechetteDangerSoundThink = "HunterFlechetteDangerSoundThink";

-static const char *s_szHunterFlechetteSpriteTrail = "sprites/bluelaser1.vmt";

-static int s_nHunterFlechetteImpact = -2;

-static int s_nFlechetteFuseAttach = -1;

-

-#define FLECHETTE_AIR_VELOCITY	2500

-

-class CHunterFlechette : public CPhysicsProp, public IParentPropInteraction

-{

-	DECLARE_CLASS( CHunterFlechette, CPhysicsProp );

-

-public:

-

-	CHunterFlechette();

-	~CHunterFlechette();

-

-	Class_T Classify() { return CLASS_NONE; }

-	

-	bool WasThrownBack()

-	{

-		return m_bThrownBack;

-	}

-

-public:

-

-	void Spawn();

-	void Activate();

-	void Precache();

-	void Shoot( Vector &vecVelocity, bool bBright );

-	void SetSeekTarget( CBaseEntity *pTargetEntity );

-	void Explode();

-

-	bool CreateVPhysics();

-

-	unsigned int PhysicsSolidMaskForEntity() const;

-	static CHunterFlechette *FlechetteCreate( const Vector &vecOrigin, const QAngle &angAngles, CBaseEntity *pentOwner = NULL );

-

-	// IParentPropInteraction

-	void OnParentCollisionInteraction( parentCollisionInteraction_t eType, int index, gamevcollisionevent_t *pEvent );

-	void OnParentPhysGunDrop( CBasePlayer *pPhysGunUser, PhysGunDrop_t Reason );

-

-protected:

-

-	void SetupGlobalModelData();

-

-	void StickTo( CBaseEntity *pOther, trace_t &tr );

-

-	void BubbleThink();

-	void DangerSoundThink();

-	void ExplodeThink();

-	void DopplerThink();

-	void SeekThink();

-

-	bool CreateSprites( bool bBright );

-

-	void FlechetteTouch( CBaseEntity *pOther );

-

-	Vector m_vecShootPosition;

-	EHANDLE m_hSeekTarget;

-	bool m_bThrownBack;

-

-	DECLARE_DATADESC();

-	//DECLARE_SERVERCLASS();

-};

-

-LINK_ENTITY_TO_CLASS( hunter_flechette, CHunterFlechette );

-

-BEGIN_DATADESC( CHunterFlechette )

-

-	DEFINE_THINKFUNC( BubbleThink ),

-	DEFINE_THINKFUNC( DangerSoundThink ),

-	DEFINE_THINKFUNC( ExplodeThink ),

-	DEFINE_THINKFUNC( DopplerThink ),

-	DEFINE_THINKFUNC( SeekThink ),

-	

-	DEFINE_ENTITYFUNC( FlechetteTouch ),

-

-	DEFINE_FIELD( m_vecShootPosition, FIELD_POSITION_VECTOR ),

-	DEFINE_FIELD( m_hSeekTarget, FIELD_EHANDLE ),

-	DEFINE_FIELD( m_bThrownBack, FIELD_BOOLEAN ),

-

-END_DATADESC()

-

-//IMPLEMENT_SERVERCLASS_ST( CHunterFlechette, DT_HunterFlechette )

-//END_SEND_TABLE()

-

-

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

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

-CHunterFlechette *CHunterFlechette::FlechetteCreate( const Vector &vecOrigin, const QAngle &angAngles, CBaseEntity *pentOwner )

-{

-	// Create a new entity with CHunterFlechette private data

-	CHunterFlechette *pFlechette = (CHunterFlechette *)CreateEntityByName( "hunter_flechette" );

-	UTIL_SetOrigin( pFlechette, vecOrigin );

-	pFlechette->SetAbsAngles( angAngles );

-	pFlechette->Spawn();

-	pFlechette->Activate();

-	pFlechette->SetOwnerEntity( pentOwner );

-

-	return pFlechette;

-}

-

-

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

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

-void CC_Hunter_Shoot_Flechette( const CCommand& args )

-{

-	MDLCACHE_CRITICAL_SECTION();

-

-	bool allowPrecache = CBaseEntity::IsPrecacheAllowed();

-	CBaseEntity::SetAllowPrecache( true );

-

-	CBasePlayer *pPlayer = UTIL_GetCommandClient();

-

-	QAngle angEye = pPlayer->EyeAngles();

-	CHunterFlechette *entity = CHunterFlechette::FlechetteCreate( pPlayer->EyePosition(), angEye, pPlayer );

-	if ( entity )

-	{

-		entity->Precache();

-		DispatchSpawn( entity );

-

-		// Shoot the flechette.		

-		Vector forward;

-		pPlayer->EyeVectors( &forward );

-		forward *= 2000.0f;

-		entity->Shoot( forward, false );

-	}

-

-	CBaseEntity::SetAllowPrecache( allowPrecache );

-}

-

-static ConCommand ent_create("hunter_shoot_flechette", CC_Hunter_Shoot_Flechette, "Fires a hunter flechette where the player is looking.", FCVAR_GAMEDLL | FCVAR_CHEAT);

-

-

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

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

-CHunterFlechette::CHunterFlechette()

-{

-	UseClientSideAnimation();

-}

-

-

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

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

-CHunterFlechette::~CHunterFlechette()

-{

-}

-

-

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

-// If set, the flechette will seek unerringly toward the target as it flies.

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

-void CHunterFlechette::SetSeekTarget( CBaseEntity *pTargetEntity )

-{

-	if ( pTargetEntity )

-	{

-		m_hSeekTarget = pTargetEntity;

-		SetContextThink( &CHunterFlechette::SeekThink, gpGlobals->curtime, s_szHunterFlechetteSeekThink );

-	}

-}

-

-

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

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

-bool CHunterFlechette::CreateVPhysics()

-{

-	// Create the object in the physics system

-	VPhysicsInitNormal( SOLID_BBOX, FSOLID_NOT_STANDABLE, false );

-

-	return true;

-}

-

-

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

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

-unsigned int CHunterFlechette::PhysicsSolidMaskForEntity() const

-{

-	return ( BaseClass::PhysicsSolidMaskForEntity() | CONTENTS_HITBOX ) & ~CONTENTS_GRATE;

-}

-

-

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

-// Called from CPropPhysics code when we're attached to a physics object.

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

-void CHunterFlechette::OnParentCollisionInteraction( parentCollisionInteraction_t eType, int index, gamevcollisionevent_t *pEvent )

-{

-	if ( eType == COLLISIONINTER_PARENT_FIRST_IMPACT )

-	{

-		m_bThrownBack = true;

-		Explode();

-	}

-}

-

-void CHunterFlechette::OnParentPhysGunDrop( CBasePlayer *pPhysGunUser, PhysGunDrop_t Reason )

-{

-	m_bThrownBack = true;

-}

-

-

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

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

-bool CHunterFlechette::CreateSprites( bool bBright )

-{

-	if ( bBright )

-	{

-		DispatchParticleEffect( "hunter_flechette_trail_striderbuster", PATTACH_ABSORIGIN_FOLLOW, this );

-	}

-	else

-	{

-		DispatchParticleEffect( "hunter_flechette_trail", PATTACH_ABSORIGIN_FOLLOW, this );

-	}

-	

-	return true;

-}

-

-

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

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

-void CHunterFlechette::Spawn()

-{

-	Precache( );

-

-	SetModel( HUNTER_FLECHETTE_MODEL );

-	SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_CUSTOM );

-	UTIL_SetSize( this, -Vector(1,1,1), Vector(1,1,1) );

-	SetSolid( SOLID_BBOX );

-	SetGravity( 0.05f );

-	SetCollisionGroup( COLLISION_GROUP_PROJECTILE );

-	

-	// Make sure we're updated if we're underwater

-	UpdateWaterState();

-

-	SetTouch( &CHunterFlechette::FlechetteTouch );

-

-	// Make us glow until we've hit the wall

-	m_nSkin = 1;

-}

-

-

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

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

-void CHunterFlechette::Activate()

-{

-	BaseClass::Activate();

-	SetupGlobalModelData();

-}

-

-

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

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

-void CHunterFlechette::SetupGlobalModelData()

-{

-	if ( s_nHunterFlechetteImpact == -2 )

-	{

-		s_nHunterFlechetteImpact = LookupSequence( "impact" );

-		s_nFlechetteFuseAttach = LookupAttachment( "attach_fuse" );

-	}

-}

-

-

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

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

-void CHunterFlechette::Precache()

-{

-	PrecacheModel( HUNTER_FLECHETTE_MODEL );

-	PrecacheModel( "sprites/light_glow02_noz.vmt" );

-

-	PrecacheScriptSound( "NPC_Hunter.FlechetteNearmiss" );

-	PrecacheScriptSound( "NPC_Hunter.FlechetteHitBody" );

-	PrecacheScriptSound( "NPC_Hunter.FlechetteHitWorld" );

-	PrecacheScriptSound( "NPC_Hunter.FlechettePreExplode" );

-	PrecacheScriptSound( "NPC_Hunter.FlechetteExplode" );

-

-	PrecacheParticleSystem( "hunter_flechette_trail_striderbuster" );

-	PrecacheParticleSystem( "hunter_flechette_trail" );

-	PrecacheParticleSystem( "hunter_projectile_explosion_1" );

-}

-

-

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

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

-void CHunterFlechette::StickTo( CBaseEntity *pOther, trace_t &tr )

-{

-	EmitSound( "NPC_Hunter.FlechetteHitWorld" );

-

-	SetMoveType( MOVETYPE_NONE );

-	

-	if ( !pOther->IsWorld() )

-	{

-		SetParent( pOther );

-		SetSolid( SOLID_NONE );

-		SetSolidFlags( FSOLID_NOT_SOLID );

-	}

-

-	// Do an impact effect.

-	//Vector vecDir = GetAbsVelocity();

-	//float speed = VectorNormalize( vecDir );

-

-	//Vector vForward;

-	//AngleVectors( GetAbsAngles(), &vForward );

-	//VectorNormalize ( vForward );

-

-	//CEffectData	data;

-	//data.m_vOrigin = tr.endpos;

-	//data.m_vNormal = vForward;

-	//data.m_nEntIndex = 0;

-	//DispatchEffect( "BoltImpact", data );

-	

-	Vector vecVelocity = GetAbsVelocity();

-	bool bAttachedToBuster = StriderBuster_OnFlechetteAttach( pOther, vecVelocity );

-

-	SetTouch( NULL );

-

-	// We're no longer flying. Stop checking for water volumes.

-	SetContextThink( NULL, 0, s_szHunterFlechetteBubbles );

-

-	// Stop seeking.

-	m_hSeekTarget = NULL;

-	SetContextThink( NULL, 0, s_szHunterFlechetteSeekThink );

-

-	// Get ready to explode.

-	if ( !bAttachedToBuster )

-	{

-		SetThink( &CHunterFlechette::DangerSoundThink );

-		SetNextThink( gpGlobals->curtime + (hunter_flechette_explode_delay.GetFloat() - HUNTER_FLECHETTE_WARN_TIME) );

-	}

-	else

-	{

-		DangerSoundThink();

-	}

-

-	// Play our impact animation.

-	ResetSequence( s_nHunterFlechetteImpact );

-

-	static int s_nImpactCount = 0;

-	s_nImpactCount++;

-	if ( s_nImpactCount & 0x01 )

-	{

-		UTIL_ImpactTrace( &tr, DMG_BULLET );

-		

-		// Shoot some sparks

-		if ( UTIL_PointContents( GetAbsOrigin() ) != CONTENTS_WATER)

-		{

-			g_pEffects->Sparks( GetAbsOrigin() );

-		}

-	}

-}

-

-

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

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

-void CHunterFlechette::FlechetteTouch( CBaseEntity *pOther )

-{

-	if ( pOther->IsSolidFlagSet(FSOLID_VOLUME_CONTENTS | FSOLID_TRIGGER) )

-	{

-		// Some NPCs are triggers that can take damage (like antlion grubs). We should hit them.

-		if ( ( pOther->m_takedamage == DAMAGE_NO ) || ( pOther->m_takedamage == DAMAGE_EVENTS_ONLY ) )

-			return;

-	}

-

-	if ( FClassnameIs( pOther, "hunter_flechette" ) )

-		return;

-

-	trace_t	tr;

-	tr = BaseClass::GetTouchTrace();

-

-	if ( pOther->m_takedamage != DAMAGE_NO )

-	{

-		Vector	vecNormalizedVel = GetAbsVelocity();

-

-		ClearMultiDamage();

-		VectorNormalize( vecNormalizedVel );

-

-		float flDamage = sk_hunter_dmg_flechette.GetFloat();

-		CBreakable *pBreak = dynamic_cast <CBreakable *>(pOther);

-		if ( pBreak && ( pBreak->GetMaterialType() == matGlass ) )

-		{

-			flDamage = MAX( pOther->GetHealth(), flDamage );

-		}

-

-		CTakeDamageInfo	dmgInfo( this, GetOwnerEntity(), flDamage, DMG_DISSOLVE | DMG_NEVERGIB );

-		CalculateMeleeDamageForce( &dmgInfo, vecNormalizedVel, tr.endpos, 0.7f );

-		dmgInfo.SetDamagePosition( tr.endpos );

-		pOther->DispatchTraceAttack( dmgInfo, vecNormalizedVel, &tr );

-

-		ApplyMultiDamage();

-

-		// Keep going through breakable glass.

-		if ( pOther->GetCollisionGroup() == COLLISION_GROUP_BREAKABLE_GLASS )

-			 return;

-			 

-		SetAbsVelocity( Vector( 0, 0, 0 ) );

-

-		// play body "thwack" sound

-		EmitSound( "NPC_Hunter.FlechetteHitBody" );

-

-		StopParticleEffects( this );

-

-		Vector vForward;

-		AngleVectors( GetAbsAngles(), &vForward );

-		VectorNormalize ( vForward );

-

-		trace_t	tr2;

-		UTIL_TraceLine( GetAbsOrigin(),	GetAbsOrigin() + vForward * 128, MASK_BLOCKLOS, pOther, COLLISION_GROUP_NONE, &tr2 );

-

-		if ( tr2.fraction != 1.0f )

-		{

-			//NDebugOverlay::Box( tr2.endpos, Vector( -16, -16, -16 ), Vector( 16, 16, 16 ), 0, 255, 0, 0, 10 );

-			//NDebugOverlay::Box( GetAbsOrigin(), Vector( -16, -16, -16 ), Vector( 16, 16, 16 ), 0, 0, 255, 0, 10 );

-

-			if ( tr2.m_pEnt == NULL || ( tr2.m_pEnt && tr2.m_pEnt->GetMoveType() == MOVETYPE_NONE ) )

-			{

-				CEffectData	data;

-

-				data.m_vOrigin = tr2.endpos;

-				data.m_vNormal = vForward;

-				data.m_nEntIndex = tr2.fraction != 1.0f;

-			

-				//DispatchEffect( "BoltImpact", data );

-			}

-		}

-

-		if ( ( ( pOther->GetMoveType() == MOVETYPE_VPHYSICS ) || ( pOther->GetMoveType() == MOVETYPE_PUSH ) ) && ( ( pOther->GetHealth() > 0 ) || ( pOther->m_takedamage == DAMAGE_EVENTS_ONLY ) ) )

-		{

-			CPhysicsProp *pProp = dynamic_cast<CPhysicsProp *>( pOther );

-			if ( pProp )

-			{

-				pProp->SetInteraction( PROPINTER_PHYSGUN_NOTIFY_CHILDREN );

-			}

-		

-			// We hit a physics object that survived the impact. Stick to it.

-			StickTo( pOther, tr );

-		}

-		else

-		{

-			SetTouch( NULL );

-			SetThink( NULL );

-			SetContextThink( NULL, 0, s_szHunterFlechetteBubbles );

-

-			UTIL_Remove( this );

-		}

-	}

-	else

-	{

-		// See if we struck the world

-		if ( pOther->GetMoveType() == MOVETYPE_NONE && !( tr.surface.flags & SURF_SKY ) )

-		{

-			// We hit a physics object that survived the impact. Stick to it.

-			StickTo( pOther, tr );

-		}

-		else if( pOther->GetMoveType() == MOVETYPE_PUSH && FClassnameIs(pOther, "func_breakable") )

-		{

-			// We hit a func_breakable, stick to it.

-			// The MOVETYPE_PUSH is a micro-optimization to cut down on the classname checks.

-			StickTo( pOther, tr );

-		}

-		else

-		{

-			// Put a mark unless we've hit the sky

-			if ( ( tr.surface.flags & SURF_SKY ) == false )

-			{

-				UTIL_ImpactTrace( &tr, DMG_BULLET );

-			}

-

-			UTIL_Remove( this );

-		}

-	}

-}

-

-

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

-// Fixup flechette position when seeking towards a striderbuster.

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

-void CHunterFlechette::SeekThink()

-{

-	if ( m_hSeekTarget )

-	{

-		Vector vecBodyTarget = m_hSeekTarget->BodyTarget( GetAbsOrigin() );

-

-		Vector vecClosest;

-		CalcClosestPointOnLineSegment( GetAbsOrigin(), m_vecShootPosition, vecBodyTarget, vecClosest, NULL );

-

-		Vector vecDelta = vecBodyTarget - m_vecShootPosition;

-		VectorNormalize( vecDelta );

-

-		QAngle angShoot;

-		VectorAngles( vecDelta, angShoot );

-

-		float flSpeed = hunter_flechette_speed.GetFloat();

-		if ( !flSpeed )

-		{

-			flSpeed = 2500.0f;

-		}

-

-		Vector vecVelocity = vecDelta * flSpeed;

-		Teleport( &vecClosest, &angShoot, &vecVelocity );

-

-		SetNextThink( gpGlobals->curtime, s_szHunterFlechetteSeekThink );

-	}

-}

-

-

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

-// Play a near miss sound as we travel past the player.

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

-void CHunterFlechette::DopplerThink()

-{

-	CBasePlayer *pPlayer = AI_GetSinglePlayer();

-	if ( !pPlayer )

-		return;

-

-	Vector vecVelocity = GetAbsVelocity();

-	VectorNormalize( vecVelocity );

-	

-	float flMyDot = DotProduct( vecVelocity, GetAbsOrigin() );

-	float flPlayerDot = DotProduct( vecVelocity, pPlayer->GetAbsOrigin() );

-

-	if ( flPlayerDot <= flMyDot )

-	{

-		EmitSound( "NPC_Hunter.FlechetteNearMiss" );

-		

-		// We've played the near miss sound and we're not seeking. Stop thinking.

-		SetThink( NULL );

-	}

-	else

-	{

-		SetNextThink( gpGlobals->curtime );

-	}

-}

-

-

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

-// Think every 0.1 seconds to make bubbles if we're flying through water.

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

-void CHunterFlechette::BubbleThink()

-{

-	SetNextThink( gpGlobals->curtime + 0.1f, s_szHunterFlechetteBubbles );

-

-	if ( GetWaterLevel()  == 0 )

-		return;

-

-	UTIL_BubbleTrail( GetAbsOrigin() - GetAbsVelocity() * 0.1f, GetAbsOrigin(), 5 );

-}

-

-

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

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

-void CHunterFlechette::Shoot( Vector &vecVelocity, bool bBrightFX )

-{

-	CreateSprites( bBrightFX );

-

-	m_vecShootPosition = GetAbsOrigin();

-

-	SetAbsVelocity( vecVelocity );

-

-	SetThink( &CHunterFlechette::DopplerThink );

-	SetNextThink( gpGlobals->curtime );

-

-	SetContextThink( &CHunterFlechette::BubbleThink, gpGlobals->curtime + 0.1, s_szHunterFlechetteBubbles );

-}

-

-

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

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

-void CHunterFlechette::DangerSoundThink()

-{

-	EmitSound( "NPC_Hunter.FlechettePreExplode" );

-

-	CSoundEnt::InsertSound( SOUND_DANGER|SOUND_CONTEXT_EXCLUDE_COMBINE, GetAbsOrigin(), 150.0f, 0.5, this );

-	SetThink( &CHunterFlechette::ExplodeThink );

-	SetNextThink( gpGlobals->curtime + HUNTER_FLECHETTE_WARN_TIME );

-}

-

-

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

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

-void CHunterFlechette::ExplodeThink()

-{

-	Explode();

-}

-

-

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

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

-void CHunterFlechette::Explode()

-{

-	SetSolid( SOLID_NONE );

-

-	// Don't catch self in own explosion!

-	m_takedamage = DAMAGE_NO;

-

-	EmitSound( "NPC_Hunter.FlechetteExplode" );

-	

-	// Move the explosion effect to the tip to reduce intersection with the world.

-	Vector vecFuse;

-	GetAttachment( s_nFlechetteFuseAttach, vecFuse );

-	DispatchParticleEffect( "hunter_projectile_explosion_1", vecFuse, GetAbsAngles(), NULL );

-

-	int nDamageType = DMG_DISSOLVE;

-

-	// Perf optimization - only every other explosion makes a physics force. This is

-	// hardly noticeable since flechettes usually explode in clumps.

-	static int s_nExplosionCount = 0;

-	s_nExplosionCount++;

-	if ( ( s_nExplosionCount & 0x01 ) && hunter_cheap_explosions.GetBool() )

-	{

-		nDamageType |= DMG_PREVENT_PHYSICS_FORCE;

-	}

-

-	RadiusDamage( CTakeDamageInfo( this, GetOwnerEntity(), sk_hunter_flechette_explode_dmg.GetFloat(), nDamageType ), GetAbsOrigin(), sk_hunter_flechette_explode_radius.GetFloat(), CLASS_NONE, NULL );

-		

-    AddEffects( EF_NODRAW );

-

-	SetThink( &CBaseEntity::SUB_Remove );

-	SetNextThink( gpGlobals->curtime + 0.1f );

-}

-

-

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

-// Calculate & apply damage & force for a charge to a target.

-// Done outside of the hunter because we need to do this inside a trace filter.

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

-void Hunter_ApplyChargeDamage( CBaseEntity *pHunter, CBaseEntity *pTarget, float flDamage )

-{

-	Vector attackDir = ( pTarget->WorldSpaceCenter() - pHunter->WorldSpaceCenter() );

-	VectorNormalize( attackDir );

-	Vector offset = RandomVector( -32, 32 ) + pTarget->WorldSpaceCenter();

-

-	// Generate enough force to make a 75kg guy move away at 700 in/sec

-	Vector vecForce = attackDir * ImpulseScale( 75, 700 );

-

-	// Deal the damage

-	CTakeDamageInfo	info( pHunter, pHunter, vecForce, offset, flDamage, DMG_CLUB );

-	pTarget->TakeDamage( info );

-}

-

-

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

-// A simple trace filter class to skip small moveable physics objects

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

-class CHunterTraceFilterSkipPhysics : public CTraceFilter

-{

-public:

-	// It does have a base, but we'll never network anything below here..

-	DECLARE_CLASS_NOBASE( CHunterTraceFilterSkipPhysics );

-	

-	CHunterTraceFilterSkipPhysics( const IHandleEntity *passentity, int collisionGroup, float minMass )

-		: m_pPassEnt(passentity), m_collisionGroup(collisionGroup), m_minMass(minMass)

-	{

-	}

-	virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )

-	{

-		if ( !StandardFilterRules( pHandleEntity, contentsMask ) )

-			return false;

-

-		if ( !PassServerEntityFilter( pHandleEntity, m_pPassEnt ) )

-			return false;

-

-		// Don't test if the game code tells us we should ignore this collision...

-		CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity );

-		if ( pEntity )

-		{

-			if ( !pEntity->ShouldCollide( m_collisionGroup, contentsMask ) )

-				return false;

-			

-			if ( !g_pGameRules->ShouldCollide( m_collisionGroup, pEntity->GetCollisionGroup() ) )

-				return false;

-

-			// don't test small moveable physics objects (unless it's an NPC)

-			if ( !pEntity->IsNPC() && pEntity->GetMoveType() == MOVETYPE_VPHYSICS )

-			{

-				float entMass = PhysGetEntityMass( pEntity ) ;

-				if ( entMass < m_minMass )

-				{

-					if ( entMass < m_minMass * 0.666f || pEntity->CollisionProp()->BoundingRadius() < (assert_cast<const CAI_BaseNPC *>(EntityFromEntityHandle( m_pPassEnt )))->GetHullHeight() )

-					{

-						return false;

-					}

-				}

-			}

-

-			// If we hit an antlion, don't stop, but kill it

-			if ( pEntity->Classify() == CLASS_ANTLION )

-			{

-				CBaseEntity *pHunter = (CBaseEntity *)EntityFromEntityHandle( m_pPassEnt );

-				Hunter_ApplyChargeDamage( pHunter, pEntity, pEntity->GetHealth() );

-				return false;

-			}

-		}

-

-		return true;

-	}

-

-private:

-	const IHandleEntity *m_pPassEnt;

-	int m_collisionGroup;

-	float m_minMass;

-};

-

-

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

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

-inline void HunterTraceHull_SkipPhysics( const Vector &vecAbsStart, const Vector &vecAbsEnd, const Vector &hullMin, 

-					 const Vector &hullMax,	unsigned int mask, const CBaseEntity *ignore, 

-					 int collisionGroup, trace_t *ptr, float minMass )

-{

-	Ray_t ray;

-	ray.Init( vecAbsStart, vecAbsEnd, hullMin, hullMax );

-	CHunterTraceFilterSkipPhysics traceFilter( ignore, collisionGroup, minMass );

-	enginetrace->TraceRay( ray, mask, &traceFilter, ptr );

-}

-

-

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

-// Hunter follow behavior

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

-class CAI_HunterEscortBehavior : public CAI_FollowBehavior

-{	

-public:

-	DECLARE_CLASS( CAI_HunterEscortBehavior, CAI_FollowBehavior );

-

-	CAI_HunterEscortBehavior() :

-		BaseClass( AI_FollowParams_t( AIF_HUNTER, true ) ),

-		m_flTimeEscortReturn( 0 ),

-		m_bEnabled( false )

-	{

-	}

-

-	CNPC_Hunter *GetOuter() { return (CNPC_Hunter *)( BaseClass::GetOuter() ); }

-

-	void SetEscortTarget( CNPC_Strider *pLeader, bool fFinishCurSchedule = false );

-	CNPC_Strider * GetEscortTarget() { return (CNPC_Strider *)GetFollowTarget(); }

-

-	bool FarFromFollowTarget()

-	{ 

-		return ( GetFollowTarget() && (GetAbsOrigin() - GetFollowTarget()->GetAbsOrigin()).LengthSqr() > HUNTER_FOLLOW_DISTANCE_SQR ); 

-	}

-

-	void DrawDebugGeometryOverlays();

-	bool ShouldFollow();

-	void BuildScheduleTestBits();

-

-	void BeginScheduleSelection();

-

-	void GatherConditions();

-	void GatherConditionsNotActive();

-	int SelectSchedule();

-	int	FollowCallBaseSelectSchedule();

-	void StartTask( const Task_t *pTask );

-	void RunTask( const Task_t *pTask );

-

-	void CheckBreakEscort();

-

-	void OnDamage( const CTakeDamageInfo &info );

-	static void DistributeFreeHunters();

-	static void FindFreeHunters( CUtlVector<CNPC_Hunter *> *pFreeHunters );

-

-	float			m_flTimeEscortReturn;

-	CSimpleSimTimer	m_FollowAttackTimer;

-	bool			m_bEnabled;

-

-	static float	gm_flLastDefendSound; // not saved and loaded, it's okay to yell again after a load

-

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

-

-	DECLARE_DATADESC();

-};

-

-

-BEGIN_DATADESC( CAI_HunterEscortBehavior )

-	DEFINE_FIELD( m_flTimeEscortReturn, FIELD_TIME ),

-	DEFINE_EMBEDDED( m_FollowAttackTimer ),

-	DEFINE_FIELD( m_bEnabled, FIELD_BOOLEAN ),

-END_DATADESC();

-

-float CAI_HunterEscortBehavior::gm_flLastDefendSound;

-

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

-// Hunter PHYSICS DAMAGE TABLE

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

-#define HUNTER_MIN_PHYSICS_DAMAGE 10

-

-static impactentry_t s_HunterLinearTable[] =

-{

-	{ 150*150, 75 },

-	{ 350*350, 105 },

-	{ 1000*1000, 300 },

-};

-

-static impactentry_t s_HunterAngularTable[] =

-{

-	{ 100*100, 75 },

-	{ 200*200, 105 },

-	{ 300*300, 300 },

-};

-

-impactdamagetable_t s_HunterImpactDamageTable =

-{

-	s_HunterLinearTable,

-	s_HunterAngularTable,

-	

-	ARRAYSIZE(s_HunterLinearTable),

-	ARRAYSIZE(s_HunterAngularTable),

-

-	24*24,		// minimum linear speed squared

-	360*360,	// minimum angular speed squared (360 deg/s to cause spin/slice damage)

-	5,			// can't take damage from anything under 5kg

-

-	10,			// anything less than 10kg is "small"

-	HUNTER_MIN_PHYSICS_DAMAGE,			// never take more than 10 pts of damage from anything under 10kg

-	36*36,		// <10kg objects must go faster than 36 in/s to do damage

-

-	VPHYSICS_LARGE_OBJECT_MASS,		// large mass in kg 

-	4,			// large mass scale (anything over 500kg does 4X as much energy to read from damage table)

-	5,			// large mass falling scale (emphasize falling/crushing damage over sideways impacts since the stress will kill you anyway)

-	0.0f,		// min vel

-};

-

-

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

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

-class CNPC_Hunter : public CAI_BaseActor

-{

-	DECLARE_CLASS( CNPC_Hunter, CAI_BaseActor );

-

-public:

-	CNPC_Hunter();

-	~CNPC_Hunter();

-

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

-

-	void			Precache();

-	void			Spawn();

-	void			PostNPCInit();

-	void			Activate();

-	void			UpdateOnRemove();

-	void			OnRestore();

-	bool			CreateBehaviors();

-	void			IdleSound();

-	bool			ShouldPlayIdleSound();

-	bool			CanBecomeRagdoll();

-	Activity		GetDeathActivity();

-	void			StopLoopingSounds();

-

-	const impactdamagetable_t &GetPhysicsImpactDamageTable();

-

-	Class_T			Classify();

-	Vector			BodyTarget( const Vector &posSrc, bool bNoisy /*= true*/ );

-

-	int				DrawDebugTextOverlays();

-	void			DrawDebugGeometryOverlays();

-

-	void			UpdateEfficiency( bool bInPVS );

-

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

-

-	virtual Vector	GetNodeViewOffset()					{ return BaseClass::GetDefaultEyeOffset();		}

-

-	int				GetSoundInterests();

-

-	bool			IsInLargeOutdoorMap();

-

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

-	// CAI_BaseActor

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

-	const char *SelectRandomExpressionForState( NPC_STATE state );

-	void PlayExpressionForState( NPC_STATE state );

-

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

-	// CBaseAnimating

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

-	float			GetIdealAccel() const { return GetIdealSpeed(); }

-

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

-	// Behavior

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

-	void			NPCThink();

-	void			PrescheduleThink();

-	void			GatherConditions();

-	void			CollectSiegeTargets();

-	void			ManageSiegeTargets();

-	void			KillCurrentSiegeTarget();

-	bool			QueryHearSound( CSound *pSound );

-	void			OnSeeEntity( CBaseEntity *pEntity );

-	void			CheckFlinches() {} // Hunter handles on own

-	void			BuildScheduleTestBits();

-	NPC_STATE		SelectIdealState();

-	int				SelectSchedule();

-	int				SelectCombatSchedule();

-	int				SelectSiegeSchedule();

-	int				TranslateSchedule( int scheduleType );

-	void			StartTask( const Task_t *pTask );

-	void			RunTask( const Task_t *pTask );

-	Activity		NPC_TranslateActivity( Activity baseAct );

-	void			OnChangeActivity( Activity eNewActivity );

-	

-	void			HandleAnimEvent( animevent_t *pEvent );

-	bool			HandleInteraction(int interactionType, void *data, CBaseCombatCharacter *pSourceEnt);

-

-	void			PlayerHasIlluminatedNPC( CBasePlayer *pPlayer, float flDot );

-

-	void			AddEntityRelationship( CBaseEntity *pEntity, Disposition_t nDisposition, int nPriority );

-	float			EnemyDistTolerance() { return 100.0f; }

-

-	bool			ScheduledMoveToGoalEntity( int scheduleType, CBaseEntity *pGoalEntity, Activity movementActivity );

-

-	void			OnChangeHintGroup( string_t oldGroup, string_t newGroup );

-

-	bool			IsUsingSiegeTargets()	{ return m_iszSiegeTargetName != NULL_STRING; }

-	

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

-	// Inputs

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

-	void			InputDodge( inputdata_t &inputdata );

-	void			InputFlankEnemy( inputdata_t &inputdata );

-	void			InputDisableShooting( inputdata_t &inputdata );

-	void			InputEnableShooting( inputdata_t &inputdata );

-	void			InputFollowStrider( inputdata_t &inputdata );

-	void			InputUseSiegeTargets( inputdata_t &inputdata );

-	void			InputEnableSquadShootDelay( inputdata_t &inputdata );

-	void			InputDisableSquadShootDelay( inputdata_t &inputdata );

-	void			InputEnableUnplantedShooting( inputdata_t &inputdata );

-	void			InputDisableUnplantedShooting( inputdata_t &inputdata );

-

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

-	// Combat

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

-	bool			FVisible( CBaseEntity *pEntity, int traceMask = MASK_BLOCKLOS, CBaseEntity **ppBlocker = NULL );

-	bool			IsValidEnemy( CBaseEntity *pEnemy );

-	

-	Disposition_t	IRelationType( CBaseEntity *pTarget );

-	int				IRelationPriority( CBaseEntity *pTarget );

-

-	void			SetSquad( CAI_Squad *pSquad );

-

-	bool			UpdateEnemyMemory( CBaseEntity *pEnemy, const Vector &position, CBaseEntity *pInformer = NULL );

-

-	int				RangeAttack1Conditions( float flDot, float flDist );

-	int				RangeAttack2Conditions( float flDot, float flDist );

-

-	int				MeleeAttack1Conditions ( float flDot, float flDist );

-	int				MeleeAttack1ConditionsVsEnemyInVehicle( CBaseCombatCharacter *pEnemy, float flDot );

-

-	int				MeleeAttack2Conditions( float flDot, float flDist );

-

-	bool			WeaponLOSCondition(const Vector &ownerPos, const Vector &targetPos, bool bSetConditions);

-	bool			TestShootPosition(const Vector &vecShootPos, const Vector &targetPos );

-

-	Vector			Weapon_ShootPosition();

-

-	CBaseEntity *	MeleeAttack( float flDist, int iDamage, QAngle &qaViewPunch, Vector &vecVelocityPunch, int BloodOrigin );

-

-	void			MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType );

-	void			DoMuzzleFlash( int nAttachment );

-

-	bool			CanShootThrough( const trace_t &tr, const Vector &vecTarget );

-

-	int				CountRangedAttackers();

-	void 			DelayRangedAttackers( float minDelay, float maxDelay, bool bForced = false );

-

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

-	//	Sounds & speech

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

-	void			AlertSound();

-	void			PainSound( const CTakeDamageInfo &info );

-	void			DeathSound( const CTakeDamageInfo &info );

-

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

-	// Damage handling

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

-	void			TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator );

-	bool			IsHeavyDamage( const CTakeDamageInfo &info );

-	int				OnTakeDamage( const CTakeDamageInfo &info );

-	int				OnTakeDamage_Alive( const CTakeDamageInfo &info );

-	void			Event_Killed( const CTakeDamageInfo &info );

-

-	void			StartBleeding();

-	inline bool		IsBleeding() { return m_bIsBleeding; }

-	void			Explode();

-

-	void			SetupGlobalModelData();

-	

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

-	// Navigation & Movement

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

-	bool			OverrideMoveFacing( const AILocalMoveGoal_t &move, float flInterval );

-	float			MaxYawSpeed();

-	bool			IsJumpLegal(const Vector &startPos, const Vector &apex, const Vector &endPos) const;

-	float			GetJumpGravity() const		{ return 3.0f; }

-	bool			ShouldProbeCollideAgainstEntity( CBaseEntity *pEntity );

-	void            TaskFail( AI_TaskFailureCode_t code );

-	void			TaskFail( const char *pszGeneralFailText )	{ TaskFail( MakeFailCode( pszGeneralFailText ) ); }

-

-	CAI_BaseNPC *	GetEntity() { return this; }

-

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

-	// Magnade

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

-	void	StriderBusterAttached( CBaseEntity *pAttached );

-	void	StriderBusterDetached( CBaseEntity *pAttached );

-

-private:

-

-	void ConsiderFlinching( const CTakeDamageInfo &info );

-

-	void TaskFindDodgeActivity();

-

-	void GatherChargeConditions();

-	void GatherIndoorOutdoorConditions();

-

-	// Charge attack.

-	bool ShouldCharge( const Vector &startPos, const Vector &endPos, bool useTime, bool bCheckForCancel );

-	void ChargeLookAhead();

-	float ChargeSteer();

-	bool EnemyIsRightInFrontOfMe( CBaseEntity **pEntity );

-	void ChargeDamage( CBaseEntity *pTarget );

-	bool HandleChargeImpact( Vector vecImpact, CBaseEntity *pEntity );

-

-	void BeginVolley( int nNum, float flStartTime );

-	bool ShootFlechette( CBaseEntity *pTargetEntity, bool bSingleShot );

-	bool ShouldSeekTarget( CBaseEntity *pTargetEntity, bool bStriderBuster );

-	void GetShootDir( Vector &vecDir, const Vector &vecSrc, CBaseEntity *pTargetEntity, bool bStriderbuster, int nShotNum, bool bSingleShot );

-	bool ClampShootDir( Vector &vecDir );

-

-	void SetAim( const Vector &aimDir, float flInterval );

-	void RelaxAim( float flInterval );

-	void UpdateAim();

-	void UpdateEyes();

-	void LockBothEyes( float flDuration );

-	void UnlockBothEyes( float flDuration );

-

-	void TeslaThink();

-	void BleedThink();

-	void JostleVehicleThink();

-

-	void FollowStrider( const char *szStrider );

-	void FollowStrider( CNPC_Strider * pStrider );

-	int NumHuntersInMySquad();

-

-	bool CanPlantHere( const Vector &vecPos );

-

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

-	// Foot handling

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

-	Vector LeftFootHit( float eventtime );

-	Vector RightFootHit( float eventtime );

-	Vector BackFootHit( float eventtime );

-

-	void FootFX( const Vector &origin );

-

-	CBaseEntity *GetEnemyVehicle();

-	bool IsCorporealEnemy( CBaseEntity *pEnemy );

-

-	void PhysicsDamageEffect( const Vector &vecPos, const Vector &vecDir );

-	bool PlayerFlashlightOnMyEyes( CBasePlayer *pPlayer );

-

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

-	// Conditions, Schedules, Tasks

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

-	enum 

-	{

-		SCHED_HUNTER_RANGE_ATTACK1 = BaseClass::NEXT_SCHEDULE,

-		SCHED_HUNTER_RANGE_ATTACK2,

-		SCHED_HUNTER_MELEE_ATTACK1,

-		SCHED_HUNTER_DODGE,

-		SCHED_HUNTER_CHASE_ENEMY,

-		SCHED_HUNTER_CHASE_ENEMY_MELEE,

-		SCHED_HUNTER_COMBAT_FACE,

-		SCHED_HUNTER_FLANK_ENEMY,

-		SCHED_HUNTER_CHANGE_POSITION,

-		SCHED_HUNTER_CHANGE_POSITION_FINISH,

-		SCHED_HUNTER_SIDESTEP,

-		SCHED_HUNTER_PATROL,

-		SCHED_HUNTER_FLINCH_STICKYBOMB,

-		SCHED_HUNTER_STAGGER,

-		SCHED_HUNTER_PATROL_RUN,

-		SCHED_HUNTER_TAKE_COVER_FROM_ENEMY,

-		SCHED_HUNTER_HIDE_UNDER_COVER,

-		SCHED_HUNTER_FAIL_IMMEDIATE, // instant fail without waiting

-		SCHED_HUNTER_CHARGE_ENEMY,

-		SCHED_HUNTER_FAIL_CHARGE_ENEMY,

-		SCHED_HUNTER_FOUND_ENEMY,

-		SCHED_HUNTER_FOUND_ENEMY_ACK,

-		SCHED_HUNTER_RANGE_ATTACK2_VS_STRIDERBUSTER,

-		SCHED_HUNTER_RANGE_ATTACK2_VS_STRIDERBUSTER_LATENT,

-		SCHED_HUNTER_GOTO_HINT,

-		SCHED_HUNTER_CLEAR_HINTNODE,

-		SCHED_HUNTER_FAIL_DODGE,

-		SCHED_HUNTER_SIEGE_STAND,

-		SCHED_HUNTER_CHANGE_POSITION_SIEGE,

-

-		TASK_HUNTER_AIM = BaseClass::NEXT_TASK,

-		TASK_HUNTER_FIND_DODGE_POSITION,

-		TASK_HUNTER_DODGE,

-		TASK_HUNTER_PRE_RANGE_ATTACK2,

-		TASK_HUNTER_SHOOT_COMMIT,

-		TASK_HUNTER_BEGIN_FLANK,

-		TASK_HUNTER_ANNOUNCE_FLANK,

-		TASK_HUNTER_STAGGER,

-		TASK_HUNTER_CORNERED_TIMER,

-		TASK_HUNTER_FIND_SIDESTEP_POSITION,

-		TASK_HUNTER_CHARGE,

-		TASK_HUNTER_CHARGE_DELAY,

-		TASK_HUNTER_FINISH_RANGE_ATTACK,

-		TASK_HUNTER_WAIT_FOR_MOVEMENT_FACING_ENEMY,

-

-		COND_HUNTER_SHOULD_PATROL = BaseClass::NEXT_CONDITION,

-		COND_HUNTER_FORCED_FLANK_ENEMY,

-		COND_HUNTER_FORCED_DODGE,

-		COND_HUNTER_CAN_CHARGE_ENEMY,

-		COND_HUNTER_HIT_BY_STICKYBOMB,

-		COND_HUNTER_STAGGERED,

-		COND_HUNTER_IS_INDOORS,

-		COND_HUNTER_SEE_STRIDERBUSTER,

-		COND_HUNTER_INCOMING_VEHICLE,

-		COND_HUNTER_NEW_HINTGROUP,

-		COND_HUNTER_CANT_PLANT,

-		COND_HUNTER_SQUADMATE_FOUND_ENEMY,

-	};

-

-	enum HunterEyeStates_t

-	{

-		HUNTER_EYE_STATE_TOP_LOCKED = 0,

-		HUNTER_EYE_STATE_BOTTOM_LOCKED,

-		HUNTER_EYE_STATE_BOTH_LOCKED,

-		HUNTER_EYE_STATE_BOTH_UNLOCKED,

-	};

-

-	string_t		m_iszFollowTarget;		// Name of the strider we should follow.

-	CSimpleStopwatch m_BeginFollowDelay;

-

-	int				m_nKillingDamageType;

-	HunterEyeStates_t m_eEyeState;

-

-	float			m_aimYaw;

-	float			m_aimPitch;

-

-	float			m_flShootAllowInterruptTime;

-	float			m_flNextChargeTime;				// Prevents us from doing our threat display too often.

-	float			m_flNextDamageTime;

-	float			m_flNextSideStepTime;

-

-	CSimpleSimTimer m_HeavyDamageDelay;

-	CSimpleSimTimer m_FlinchTimer;

-	CSimpleSimTimer m_EyeSwitchTimer;		// Controls how often we switch which eye is focusing on our enemy.

-

-	bool			m_bTopMuzzle;	// Used to alternate between top muzzle FX and bottom muzzle FX.

-	bool			m_bEnableSquadShootDelay;

-	bool			m_bIsBleeding;

-

-	Activity		m_eDodgeActivity;

-	CSimpleSimTimer m_RundownDelay;

-	CSimpleSimTimer m_IgnoreVehicleTimer;

-

-	bool m_bDisableShooting;	// Range attack disabled via an input. Used for scripting melee attacks.

-	

-	bool m_bFlashlightInEyes;	// The player is shining the flashlight on our eyes.

-	float m_flPupilDilateTime;	// When to dilate our pupils if the flashlight is no longer on our eyes.

-

-	Vector m_vecEnemyLastSeen;

-	Vector m_vecLastCanPlantHerePos;

-	Vector m_vecStaggerDir;

-

-	bool m_bPlanted;

-	bool m_bLastCanPlantHere;

-	bool m_bMissLeft;

-	bool m_bEnableUnplantedShooting;

-

-	static float	gm_flMinigunDistZ;

-	static Vector	gm_vecLocalRelativePositionMinigun;

-

-	static int gm_nTopGunAttachment;

-	static int gm_nBottomGunAttachment;

-	static int gm_nAimYawPoseParam;

-	static int gm_nAimPitchPoseParam;

-	static int gm_nBodyYawPoseParam;

-	static int gm_nBodyPitchPoseParam;

-	static int gm_nStaggerYawPoseParam;

-	static int gm_nHeadCenterAttachment;

-	static int gm_nHeadBottomAttachment;

-	static float gm_flHeadRadius;

-

-	static int gm_nUnplantedNode;

-	static int gm_nPlantedNode;

-

-	CAI_HunterEscortBehavior m_EscortBehavior;

-

-	int m_nFlechettesQueued;

-	int m_nClampedShots;				// The number of consecutive shots fired at an out-of-max yaw target.

-

-	float m_flNextRangeAttack2Time;		// Time when we can fire another volley of flechettes.

-	float m_flNextFlechetteTime;		// Time to fire the next flechette in this volley.

-	

-	float m_flNextMeleeTime;

-	float m_flTeslaStopTime;

-

-	string_t m_iszCurrentExpression;

-

-	// buster fu	

-	CUtlVector< EHANDLE >	m_hAttachedBusters;		// List of busters attached to us

-	float m_fCorneredTimer; ///< hunter was cornered when fleeing player; it won't flee again until this time

-

-	CSimpleSimTimer m_CheckHintGroupTimer;

-

-	DEFINE_CUSTOM_AI;

-

-	DECLARE_DATADESC();

-

-	friend class CAI_HunterEscortBehavior;

-	friend class CHunterMaker;

-

-	bool	m_bInLargeOutdoorMap;

-	float	m_flTimeSawEnemyAgain;

-

-	// Sounds

-	//CSoundPatch	*m_pGunFiringSound;

-

-	CUtlVector<EHANDLE> m_pSiegeTargets;

-	string_t	m_iszSiegeTargetName;

-	float		m_flTimeNextSiegeTargetAttack;

-	EHANDLE		m_hCurrentSiegeTarget;

-	

-	EHANDLE		m_hHitByVehicle;

-};

-

-

-LINK_ENTITY_TO_CLASS( npc_hunter, CNPC_Hunter );

-

-

-BEGIN_DATADESC( CNPC_Hunter )

-

-	DEFINE_KEYFIELD( m_iszFollowTarget, FIELD_STRING, "FollowTarget" ),

-

-	DEFINE_FIELD( m_aimYaw,				FIELD_FLOAT ),

-	DEFINE_FIELD( m_aimPitch,				FIELD_FLOAT ),

-

-	DEFINE_FIELD( m_flShootAllowInterruptTime, FIELD_TIME ),

-	DEFINE_FIELD( m_flNextChargeTime, FIELD_TIME ),

-	//DEFINE_FIELD( m_flNextDamageTime, FIELD_TIME ),

-	DEFINE_FIELD( m_flNextSideStepTime, FIELD_TIME ),

-

-	DEFINE_EMBEDDED( m_HeavyDamageDelay ),

-	DEFINE_EMBEDDED( m_FlinchTimer ),

-

-	DEFINE_FIELD( m_eEyeState, FIELD_INTEGER ),

-

-	DEFINE_FIELD( m_bTopMuzzle, FIELD_BOOLEAN ),

-	DEFINE_FIELD( m_bEnableSquadShootDelay, FIELD_BOOLEAN ),

-	DEFINE_FIELD( m_bIsBleeding, FIELD_BOOLEAN ),

-

-	DEFINE_FIELD( m_bDisableShooting, FIELD_BOOLEAN ),

-	DEFINE_FIELD( m_bFlashlightInEyes, FIELD_BOOLEAN ),

-	DEFINE_FIELD( m_flPupilDilateTime, FIELD_TIME ),

-

-	DEFINE_FIELD( m_vecEnemyLastSeen, FIELD_POSITION_VECTOR ),

-	DEFINE_FIELD( m_vecLastCanPlantHerePos, FIELD_POSITION_VECTOR ),

-	DEFINE_FIELD( m_vecStaggerDir, FIELD_VECTOR ),

-	

-	DEFINE_FIELD( m_bPlanted, FIELD_BOOLEAN ),

-	DEFINE_FIELD( m_bLastCanPlantHere, FIELD_BOOLEAN ),

-	//DEFINE_FIELD( m_bMissLeft, FIELD_BOOLEAN ),

-	DEFINE_FIELD( m_bEnableUnplantedShooting, FIELD_BOOLEAN ),

-

-	DEFINE_FIELD( m_nKillingDamageType, FIELD_INTEGER ),

-	DEFINE_FIELD( m_eDodgeActivity, FIELD_INTEGER ),

-	DEFINE_EMBEDDED( m_RundownDelay ),

-	DEFINE_EMBEDDED( m_IgnoreVehicleTimer ),

-

-	DEFINE_FIELD( m_flNextMeleeTime, FIELD_TIME ),

-	DEFINE_FIELD( m_flTeslaStopTime, FIELD_TIME ),

-

-	// (auto saved by AI)

-	//DEFINE_FIELD( m_EscortBehavior, FIELD_EMBEDDED ),	

-

-	DEFINE_FIELD( m_iszCurrentExpression, FIELD_STRING ),

-

-	DEFINE_FIELD( m_fCorneredTimer, FIELD_TIME),

-

-	DEFINE_EMBEDDED( m_CheckHintGroupTimer ),

-

-	// (Recomputed in Precache())

-	//DEFINE_FIELD( m_bInLargeOutdoorMap, FIELD_BOOLEAN ), 

-	DEFINE_FIELD( m_flTimeSawEnemyAgain, FIELD_TIME ),

-

-	//DEFINE_SOUNDPATCH( m_pGunFiringSound ),

-

-	//DEFINE_UTLVECTOR( m_pSiegeTarget, FIELD_EHANDLE ),

-	DEFINE_FIELD( m_iszSiegeTargetName, FIELD_STRING ),

-	DEFINE_FIELD( m_flTimeNextSiegeTargetAttack, FIELD_TIME ),

-	DEFINE_FIELD( m_hCurrentSiegeTarget, FIELD_EHANDLE ),

-	DEFINE_FIELD( m_hHitByVehicle, FIELD_EHANDLE ),

-

-	DEFINE_EMBEDDED( m_BeginFollowDelay ),

-	DEFINE_EMBEDDED( m_EyeSwitchTimer ),

-

-	DEFINE_FIELD( m_nFlechettesQueued, FIELD_INTEGER ),

-	DEFINE_FIELD( m_nClampedShots, FIELD_INTEGER ),

-	DEFINE_FIELD( m_flNextRangeAttack2Time, FIELD_TIME ),

-	DEFINE_FIELD( m_flNextFlechetteTime, FIELD_TIME ),

-	DEFINE_UTLVECTOR( m_hAttachedBusters, FIELD_EHANDLE ),

-	DEFINE_UTLVECTOR( m_pSiegeTargets, FIELD_EHANDLE ),

-

-	// inputs

-	DEFINE_INPUTFUNC( FIELD_VOID, "Dodge", InputDodge ),

-	DEFINE_INPUTFUNC( FIELD_VOID, "FlankEnemy", InputFlankEnemy ),

-	DEFINE_INPUTFUNC( FIELD_STRING, "DisableShooting", InputDisableShooting ),

-	DEFINE_INPUTFUNC( FIELD_STRING, "EnableShooting", InputEnableShooting ),

-	DEFINE_INPUTFUNC( FIELD_STRING, "FollowStrider", InputFollowStrider ),

-	DEFINE_INPUTFUNC( FIELD_STRING, "UseSiegeTargets", InputUseSiegeTargets ),

-	DEFINE_INPUTFUNC( FIELD_VOID, "EnableSquadShootDelay", InputEnableSquadShootDelay ),

-	DEFINE_INPUTFUNC( FIELD_VOID, "DisableSquadShootDelay", InputDisableSquadShootDelay ),

-	DEFINE_INPUTFUNC( FIELD_VOID, "EnableUnplantedShooting", InputEnableUnplantedShooting ),

-	DEFINE_INPUTFUNC( FIELD_VOID, "DisableUnplantedShooting", InputDisableUnplantedShooting ),

-

-	// Function Pointers

-	DEFINE_THINKFUNC( TeslaThink ),

-	DEFINE_THINKFUNC( BleedThink ),

-	DEFINE_THINKFUNC( JostleVehicleThink ),

-

-END_DATADESC()

-

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

-

-int CNPC_Hunter::gm_nUnplantedNode = 0;

-int CNPC_Hunter::gm_nPlantedNode = 0;

-

-int CNPC_Hunter::gm_nAimYawPoseParam = -1;

-int CNPC_Hunter::gm_nAimPitchPoseParam = -1;

-int CNPC_Hunter::gm_nBodyYawPoseParam = -1;

-int CNPC_Hunter::gm_nBodyPitchPoseParam = -1;

-int CNPC_Hunter::gm_nStaggerYawPoseParam = -1;

-int CNPC_Hunter::gm_nHeadCenterAttachment = -1;

-int CNPC_Hunter::gm_nHeadBottomAttachment = -1;

-float CNPC_Hunter::gm_flHeadRadius = 0;

-

-int CNPC_Hunter::gm_nTopGunAttachment = -1;

-int CNPC_Hunter::gm_nBottomGunAttachment = -1;

-

-float CNPC_Hunter::gm_flMinigunDistZ;

-Vector CNPC_Hunter::gm_vecLocalRelativePositionMinigun;

-

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

-

-static CUtlVector<CNPC_Hunter *> g_Hunters;

-float g_TimeLastDistributeFreeHunters = -1;

-const float FREE_HUNTER_DISTRIBUTE_INTERVAL = 2;

-

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

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

-CNPC_Hunter::CNPC_Hunter()

-{

-	g_Hunters.AddToTail( this );

-	g_TimeLastDistributeFreeHunters = -1;

-	m_flTimeSawEnemyAgain = HUNTER_SEE_ENEMY_TIME_INVALID;

-}

-

-

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

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

-CNPC_Hunter::~CNPC_Hunter()

-{

-	g_Hunters.FindAndRemove( this );

-	g_TimeLastDistributeFreeHunters = -1;

-}

-

-

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

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

-void CNPC_Hunter::Precache()

-{

-	PrecacheModel( "models/hunter.mdl" );

-	PropBreakablePrecacheAll( MAKE_STRING("models/hunter.mdl") );

-

-	PrecacheScriptSound( "NPC_Hunter.Idle" );

-	PrecacheScriptSound( "NPC_Hunter.Scan" );

-	PrecacheScriptSound( "NPC_Hunter.Alert" );

-	PrecacheScriptSound( "NPC_Hunter.Pain" );

-	PrecacheScriptSound( "NPC_Hunter.PreCharge" );

-	PrecacheScriptSound( "NPC_Hunter.Angry" );

-	PrecacheScriptSound( "NPC_Hunter.Death" );

-	PrecacheScriptSound( "NPC_Hunter.FireMinigun" );

-	PrecacheScriptSound( "NPC_Hunter.Footstep" );

-	PrecacheScriptSound( "NPC_Hunter.BackFootstep" );

-	PrecacheScriptSound( "NPC_Hunter.FlechetteVolleyWarn" );

-	PrecacheScriptSound( "NPC_Hunter.FlechetteShoot" );

-	PrecacheScriptSound( "NPC_Hunter.FlechetteShootLoop" );

-	PrecacheScriptSound( "NPC_Hunter.FlankAnnounce" );

-	PrecacheScriptSound( "NPC_Hunter.MeleeAnnounce" );

-	PrecacheScriptSound( "NPC_Hunter.MeleeHit" );

-	PrecacheScriptSound( "NPC_Hunter.TackleAnnounce" );

-	PrecacheScriptSound( "NPC_Hunter.TackleHit" );

-	PrecacheScriptSound( "NPC_Hunter.ChargeHitEnemy" );

-	PrecacheScriptSound( "NPC_Hunter.ChargeHitWorld" );

-	PrecacheScriptSound( "NPC_Hunter.FoundEnemy" );

-	PrecacheScriptSound( "NPC_Hunter.FoundEnemyAck" );

-	PrecacheScriptSound( "NPC_Hunter.DefendStrider" );

-	PrecacheScriptSound( "NPC_Hunter.HitByVehicle" );

-

-	PrecacheParticleSystem( "hunter_muzzle_flash" );

-	PrecacheParticleSystem( "blood_impact_synth_01" );

-	PrecacheParticleSystem( "blood_impact_synth_01_arc_parent" );

-	PrecacheParticleSystem( "blood_spurt_synth_01" );

-	PrecacheParticleSystem( "blood_drip_synth_01" );

-

-	PrecacheInstancedScene( "scenes/npc/hunter/hunter_scan.vcd" );

-	PrecacheInstancedScene( "scenes/npc/hunter/hunter_eyeclose.vcd" );

-	PrecacheInstancedScene( "scenes/npc/hunter/hunter_roar.vcd" );

-	PrecacheInstancedScene( "scenes/npc/hunter/hunter_pain.vcd" );

-	PrecacheInstancedScene( "scenes/npc/hunter/hunter_eyedarts_top.vcd" );

-	PrecacheInstancedScene( "scenes/npc/hunter/hunter_eyedarts_bottom.vcd" );

-	

-	PrecacheMaterial( "effects/water_highlight" );

-

-	UTIL_PrecacheOther( "hunter_flechette" );

-	UTIL_PrecacheOther( "sparktrail" );

-

-	m_bInLargeOutdoorMap = false;

-	if( !Q_strnicmp( STRING(gpGlobals->mapname), "ep2_outland_12", 14) )

-	{

-		m_bInLargeOutdoorMap = true;

-	}

-

-	BaseClass::Precache();

-}

-

-

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

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

-void CNPC_Hunter::Spawn()

-{

-	Precache();

-

-	SetModel( "models/hunter.mdl" );

-	BaseClass::Spawn();

-

-	//m_debugOverlays |= OVERLAY_NPC_ROUTE_BIT | OVERLAY_BBOX_BIT | OVERLAY_PIVOT_BIT;

-

-	SetHullType( HULL_MEDIUM_TALL );

-	SetHullSizeNormal();

-	SetDefaultEyeOffset();

-	

-	SetNavType( NAV_GROUND );

-	m_flGroundSpeed	= 500;

-	m_NPCState = NPC_STATE_NONE;

-

-	SetBloodColor( DONT_BLEED );

-	

-	m_iHealth = m_iMaxHealth = sk_hunter_health.GetInt();

-

-	m_flFieldOfView = HUNTER_FOV_DOT;

-

-	SetSolid( SOLID_BBOX );

-	AddSolidFlags( FSOLID_NOT_STANDABLE );

-	SetMoveType( MOVETYPE_STEP );

-

-	SetupGlobalModelData();

-	

-	CapabilitiesAdd( bits_CAP_MOVE_GROUND | bits_CAP_SQUAD | bits_CAP_ANIMATEDFACE );

-	CapabilitiesAdd( bits_CAP_INNATE_RANGE_ATTACK1 | bits_CAP_INNATE_RANGE_ATTACK2 | bits_CAP_INNATE_MELEE_ATTACK1 );

-	CapabilitiesAdd( bits_CAP_SKIP_NAV_GROUND_CHECK );

-

-	if ( !hunter_allow_dissolve.GetBool() )

-	{

-		AddEFlags( EFL_NO_DISSOLVE );

-	}

-

-	if( hunter_allow_nav_jump.GetBool() )

-	{

-		CapabilitiesAdd( bits_CAP_MOVE_JUMP );

-	}

-

-	NPCInit();

-

-	m_bEnableSquadShootDelay = true;

-

-	m_flDistTooFar = hunter_flechette_max_range.GetFloat();

-

-	// Discard time must be greater than free knowledge duration. Make it double.

-	float freeKnowledge = hunter_free_knowledge.GetFloat();

-	if ( freeKnowledge < GetEnemies()->GetEnemyDiscardTime() )

-	{

-		GetEnemies()->SetEnemyDiscardTime( MAX( freeKnowledge + 0.1, AI_DEF_ENEMY_DISCARD_TIME ) );

-	}

-	GetEnemies()->SetFreeKnowledgeDuration( freeKnowledge );

-

-	// Find out what strider we should follow, if any.

-	if ( m_iszFollowTarget != NULL_STRING )

-	{

-		m_BeginFollowDelay.Set( .1 ); // Allow time for strider to spawn

-	}

-

-	//if ( !m_pGunFiringSound )

-	//{

-	//	CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();

-	//	CPASAttenuationFilter filter( this );

-	//

-	//	m_pGunFiringSound = controller.SoundCreate( filter, entindex(), "NPC_Hunter.FlechetteShootLoop" );

-	//	controller.Play( m_pGunFiringSound, 0.0, 100 );

-	//}

-}

-

-

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

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

-void CNPC_Hunter::UpdateEfficiency( bool bInPVS )

-{

-	SetEfficiency( ( GetSleepState() != AISS_AWAKE ) ? AIE_DORMANT : AIE_NORMAL );

-	SetMoveEfficiency( AIME_NORMAL );

-}

-

-

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

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

-bool CNPC_Hunter::CreateBehaviors()

-{

-	AddBehavior( &m_EscortBehavior );

-

-	return BaseClass::CreateBehaviors();

-}

-

-

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

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

-void CNPC_Hunter::SetupGlobalModelData()

-{

-	if ( gm_nBodyYawPoseParam != -1 )

-		return;

-

-	gm_nAimYawPoseParam = LookupPoseParameter( "aim_yaw" );

-	gm_nAimPitchPoseParam = LookupPoseParameter( "aim_pitch" );

-

-	gm_nBodyYawPoseParam = LookupPoseParameter( "body_yaw" );

-	gm_nBodyPitchPoseParam = LookupPoseParameter( "body_pitch" );

-

-	gm_nTopGunAttachment = LookupAttachment( "top_eye" );

-	gm_nBottomGunAttachment = LookupAttachment( "bottom_eye" );

-	gm_nStaggerYawPoseParam = LookupAttachment( "stagger_yaw" );

-	

-	gm_nHeadCenterAttachment = LookupAttachment( "head_center" );

-	gm_nHeadBottomAttachment = LookupAttachment( "head_radius_measure" );

-

-	// Measure the radius of the head.	

-	Vector vecHeadCenter;

-	Vector vecHeadBottom;

-	GetAttachment( gm_nHeadCenterAttachment, vecHeadCenter );

-	GetAttachment( gm_nHeadBottomAttachment, vecHeadBottom );

-	gm_flHeadRadius = ( vecHeadCenter - vecHeadBottom ).Length();

-

-	int nSequence = SelectWeightedSequence( ACT_HUNTER_RANGE_ATTACK2_UNPLANTED );

-	gm_nUnplantedNode = GetEntryNode( nSequence );

-

-	nSequence = SelectWeightedSequence( ACT_RANGE_ATTACK2 );

-	gm_nPlantedNode = GetEntryNode( nSequence );

-

-	CollisionProp()->SetSurroundingBoundsType( USE_HITBOXES );

-}

-

-

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

-// Shuts down looping sounds when we are killed in combat or deleted.

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

-void CNPC_Hunter::StopLoopingSounds()

-{

-	BaseClass::StopLoopingSounds();

-

-	//if ( m_pGunFiringSound )

-	//{

-	//	CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();

-	//	controller.SoundDestroy( m_pGunFiringSound );

-	//	m_pGunFiringSound = NULL;

-	//}

-}

-

-

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

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

-void CNPC_Hunter::OnRestore()

-{

-	BaseClass::OnRestore();

-	SetupGlobalModelData();

-	CreateVPhysics();

-	

-	if ( IsBleeding() )

-	{

-		StartBleeding();

-	}

-}

-

-

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

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

-void CNPC_Hunter::IdleSound()

-{

-	if ( HasCondition( COND_LOST_ENEMY ) )

-	{

-		EmitSound( "NPC_Hunter.Scan" );

-	}

-	else

-	{

-		EmitSound( "NPC_Hunter.Idle" );

-	}

-}

-

-

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

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

-bool CNPC_Hunter::ShouldPlayIdleSound()

-{

-	if ( random->RandomInt(0, 99) == 0 && !HasSpawnFlags( SF_NPC_GAG ) )

-		return true;

-	

-	return false;

-}

-

-

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

-// Stay facing our enemy when close enough.

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

-bool CNPC_Hunter::OverrideMoveFacing( const AILocalMoveGoal_t &move, float flInterval )

-{

-	if ( GetActivity() == ACT_TRANSITION )

-	{

-		// No turning while in transitions.

-		return true;

-	}

-

- 	bool bSideStepping = IsCurSchedule( SCHED_HUNTER_SIDESTEP, false );

- 	

-  	// FIXME: this will break scripted sequences that walk when they have an enemy

-  	if ( GetEnemy() &&

-  		( bSideStepping ||

-  		( ( ( GetNavigator()->GetMovementActivity() == ACT_RUN ) || ( GetNavigator()->GetMovementActivity() == ACT_WALK ) ) &&

-		  !IsCurSchedule( SCHED_HUNTER_TAKE_COVER_FROM_ENEMY, false ) ) ) )

-	{

-		Vector vecEnemyLKP = GetEnemyLKP();

-		

-		// Face my enemy if we're close enough

-		if ( bSideStepping || UTIL_DistApprox( vecEnemyLKP, GetAbsOrigin() ) < HUNTER_FACE_ENEMY_DIST )

-		{

-			AddFacingTarget( GetEnemy(), vecEnemyLKP, 1.0, 0.2 );

-		}

-	}

-

-	return BaseClass::OverrideMoveFacing( move, flInterval );

-}

-

-

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

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

-void CNPC_Hunter::PostNPCInit()

-{

-	BaseClass::PostNPCInit();

-

-	IPhysicsObject *pPhysObject = VPhysicsGetObject();

-	Assert( pPhysObject );

-	if ( pPhysObject )

-	{

-		pPhysObject->SetMass( 600.0 );

-	}

-}

-

-

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

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

-void CNPC_Hunter::Activate()

-{

-	BaseClass::Activate();

-

-	s_iszStriderBusterClassname = AllocPooledString( "weapon_striderbuster" );

-	s_iszStriderClassname  = AllocPooledString( "npc_strider" );

-	s_iszMagnadeClassname = AllocPooledString( "npc_grenade_magna" );

-	s_iszPhysPropClassname = AllocPooledString( "prop_physics" );

-	s_iszHuntersToRunOver = AllocPooledString( "hunters_to_run_over" );

-	

-	// If no one has initialized the hunters to run over counter, just zero it out.

-	if ( !GlobalEntity_IsInTable( s_iszHuntersToRunOver ) )

-	{

-		GlobalEntity_Add( s_iszHuntersToRunOver, gpGlobals->mapname, GLOBAL_ON );

-		GlobalEntity_SetCounter( s_iszHuntersToRunOver, 0 );

-	}

-

-	CMissile::AddCustomDetonator( this, ( GetHullMaxs().AsVector2D() - GetHullMins().AsVector2D() ).Length() * 0.5, GetHullHeight() );

-

-	SetupGlobalModelData();

-	

-	if ( gm_flMinigunDistZ == 0 )

-	{

-		// Have to create a virgin hunter to ensure proper pose

-		CNPC_Hunter *pHunter = (CNPC_Hunter *)CreateEntityByName( "npc_hunter" );

-		Assert(pHunter);

-		pHunter->Spawn();

-

-		pHunter->SetActivity( ACT_WALK );

-		pHunter->InvalidateBoneCache();

-

-		// Currently just using the gun for the vertical component!

-		Vector defEyePos;

-		pHunter->GetAttachment( "minigunbase", defEyePos );

-		gm_flMinigunDistZ = defEyePos.z - pHunter->GetAbsOrigin().z;

-

-		Vector position;

-		pHunter->GetAttachment( gm_nTopGunAttachment, position );

-		VectorITransform( position, pHunter->EntityToWorldTransform(), gm_vecLocalRelativePositionMinigun );

-		UTIL_Remove( pHunter );

-	}

-}

-

-

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

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

-void CNPC_Hunter::UpdateOnRemove()

-{

-	CMissile::RemoveCustomDetonator( this );

-	BaseClass::UpdateOnRemove();

-}

-

-

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

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

-Class_T CNPC_Hunter::Classify()

-{

-	return CLASS_COMBINE_HUNTER;

-}

-

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

-// Compensate for the hunter's long legs by moving the bodytarget up to his head.

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

-Vector CNPC_Hunter::BodyTarget( const Vector &posSrc, bool bNoisy /*= true*/ )

-{ 

-	Vector vecResult;

-	QAngle vecAngle;

-	GetAttachment( gm_nHeadCenterAttachment, vecResult, vecAngle );

-

-	if ( bNoisy )

-	{

-		float rand1 = random->RandomFloat( 0, gm_flHeadRadius ) + random->RandomFloat( 0, gm_flHeadRadius );

-		return vecResult + RandomVector( -rand1, rand1 );

-	}

-

-	return vecResult;

-}

-

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

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

-int	CNPC_Hunter::DrawDebugTextOverlays()

-{

-	int text_offset = BaseClass::DrawDebugTextOverlays();

-

-	if (m_debugOverlays & OVERLAY_TEXT_BIT)

-	{

-		EntityText( text_offset, CFmtStr("%s", m_bPlanted ? "Planted" : "Unplanted" ), 0 );

-		text_offset++;

-

-		EntityText( text_offset, CFmtStr("Eye state: %d", m_eEyeState ), 0 );

-		text_offset++;

-

-		if( IsUsingSiegeTargets() )

-		{

-			EntityText( text_offset, CFmtStr("Next Siege Attempt:%f", m_flTimeNextSiegeTargetAttack - gpGlobals->curtime ), 0 );

-			text_offset++;

-		}

-	}

-

-	return text_offset;

-}

-

-

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

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

-void CNPC_Hunter::LockBothEyes( float flDuration )

-{

-	m_eEyeState = HUNTER_EYE_STATE_BOTH_LOCKED;

-	m_EyeSwitchTimer.Set( flDuration );

-}

-

-

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

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

-void CNPC_Hunter::UnlockBothEyes( float flDuration )

-{

-	m_eEyeState = HUNTER_EYE_STATE_BOTH_UNLOCKED;

-	m_EyeSwitchTimer.Set( flDuration );

-}

-

-

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

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

-void CNPC_Hunter::OnChangeActivity( Activity eNewActivity )

-{

-	m_EyeSwitchTimer.Force();

-	

-	BaseClass::OnChangeActivity( eNewActivity );

-}

-

-

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

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

-void CNPC_Hunter::UpdateEyes()

-{

-	// If the eyes are controlled by a script, do nothing.

-	if ( GetState() == NPC_STATE_SCRIPT )

-		return;

-

-	if ( m_EyeSwitchTimer.Expired() )

-	{

-		RemoveActorFromScriptedScenes( this, false );

-		

-		if ( GetActivity() == ACT_IDLE )

-		{

-			// Idles have eye motion baked in.

-			m_eEyeState = HUNTER_EYE_STATE_BOTH_LOCKED;

-		}

-		else if ( GetEnemy() == NULL )

-		{

-			m_eEyeState = HUNTER_EYE_STATE_BOTH_UNLOCKED;

-		}

-		else if ( m_eEyeState == HUNTER_EYE_STATE_BOTH_LOCKED )

-		{

-			if ( random->RandomInt( 0, 1 ) == 0 )

-			{

-				m_eEyeState = HUNTER_EYE_STATE_TOP_LOCKED;

-			}

-			else

-			{

-				m_eEyeState = HUNTER_EYE_STATE_BOTTOM_LOCKED;

-			}

-		}

-		else if ( m_eEyeState == HUNTER_EYE_STATE_TOP_LOCKED )

-		{

-			m_eEyeState = HUNTER_EYE_STATE_BOTTOM_LOCKED;

-		}

-		else if ( m_eEyeState == HUNTER_EYE_STATE_BOTTOM_LOCKED )

-		{

-			m_eEyeState = HUNTER_EYE_STATE_TOP_LOCKED;

-		}

-

-		if ( ( m_eEyeState == HUNTER_EYE_STATE_BOTTOM_LOCKED ) || ( m_eEyeState == HUNTER_EYE_STATE_BOTH_UNLOCKED ) )

-		{

-			SetExpression( "scenes/npc/hunter/hunter_eyedarts_top.vcd" );

-		}

-

-		if ( ( m_eEyeState == HUNTER_EYE_STATE_TOP_LOCKED ) || ( m_eEyeState == HUNTER_EYE_STATE_BOTH_UNLOCKED ) )

-		{

-			SetExpression( "scenes/npc/hunter/hunter_eyedarts_bottom.vcd" );

-		}

-

-		m_EyeSwitchTimer.Set( random->RandomFloat( 1.0f, 3.0f ) );

-	}

-

-	/*Vector vecEyePos;

-	Vector vecEyeDir;

-

-	GetAttachment( gm_nTopGunAttachment, vecEyePos, &vecEyeDir );

-	NDebugOverlay::Line( vecEyePos, vecEyePos + vecEyeDir * 36, 255, 0, 0, 0, 0.1 );

-

-	GetAttachment( gm_nBottomGunAttachment, vecEyePos, &vecEyeDir );

-	NDebugOverlay::Line( vecEyePos, vecEyePos + vecEyeDir * 36, 255, 0, 0, 0, 0.1 );*/

-}

-

-

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

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

-void CNPC_Hunter::NPCThink()

-{

-	BaseClass::NPCThink();

-

-	// Update our planted/unplanted state.

-	m_bPlanted = ( GetEntryNode( GetSequence() ) == gm_nPlantedNode );

-

-	UpdateAim();

-	UpdateEyes();

-}

-

-

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

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

-void CNPC_Hunter::PrescheduleThink()

-{

-	BaseClass::PrescheduleThink();

-	

-	if ( m_BeginFollowDelay.Expired() )

-	{

-		FollowStrider( STRING( m_iszFollowTarget ) );

-		m_BeginFollowDelay.Stop();

-	}

-

-	m_EscortBehavior.CheckBreakEscort();

-

-	// If we're being blinded by the flashlight, see if we should stop

-	if ( m_bFlashlightInEyes )

-	{

-		if ( m_flPupilDilateTime < gpGlobals->curtime )

-		{

- 			CBasePlayer *pPlayer = UTIL_PlayerByIndex( 1 );

- 			if ( ( pPlayer && !pPlayer->IsIlluminatedByFlashlight( this, NULL ) ) || !PlayerFlashlightOnMyEyes( pPlayer ) )

-			{

-				//Msg( "NOT SHINING FLASHLIGHT ON ME\n" );

-			

-				// Remove the actor from the flashlight scene

-				RemoveActorFromScriptedScenes( this, true, false, "scenes/npc/hunter/hunter_eyeclose.vcd" );

-				m_bFlashlightInEyes = false;

-			}

-		}

-	}

-}

-

-

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

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

-void CNPC_Hunter::GatherChargeConditions()

-{

-	ClearCondition( COND_HUNTER_CAN_CHARGE_ENEMY );

-

-	if ( !hunter_charge.GetBool() )

-		return;

-		

-	if ( !GetEnemy() )

-		return;

-

-	if ( GetHintGroup() != NULL_STRING )

-		return;

-	

-	if ( !HasCondition( COND_SEE_ENEMY ) )

-		return;

-	

-	if ( !hunter_charge_test.GetBool() && gpGlobals->curtime < m_flNextChargeTime )

-		return;

-

-	// No charging Alyx or Barney

-	if( GetEnemy()->Classify() == CLASS_PLAYER_ALLY_VITAL )

-		return;

-

-	if ( m_EscortBehavior.GetEscortTarget() && GetEnemy()->MyCombatCharacterPointer() && !GetEnemy()->MyCombatCharacterPointer()->FInViewCone( this ) )

-		return;

-

-	if ( ShouldCharge( GetAbsOrigin(), GetEnemy()->GetAbsOrigin(), true, false ) )

-	{

-		SetCondition( COND_HUNTER_CAN_CHARGE_ENEMY );

-	}

-}

-

-

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

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

-void CNPC_Hunter::GatherConditions()

-{

-	GatherIndoorOutdoorConditions();

-	GatherChargeConditions();

-

-	BaseClass::GatherConditions();

-

-	// Enemy LKP that doesn't get updated by the free knowledge code.

-	// Used for shooting at where our enemy was when we can't see them.

-	ClearCondition( COND_HUNTER_INCOMING_VEHICLE );

-	if ( m_IgnoreVehicleTimer.Expired() && GetEnemy() && HasCondition( COND_SEE_ENEMY ) )

-	{

-		CBaseEntity *pVehicle = GetEnemyVehicle();

-		if ( ( pVehicle ) && ( GlobalEntity_GetCounter( s_iszHuntersToRunOver ) <= 0 ) )

-		{

-			static float timeDrawnArrow;

-

-			// Extrapolate the position of the vehicle and see if it's heading toward us.

-			float predictTime = hunter_dodge_warning.GetFloat();

-			Vector2D vecFuturePos = pVehicle->GetAbsOrigin().AsVector2D() + pVehicle->GetSmoothedVelocity().AsVector2D() * predictTime;

-			if ( pVehicle->GetSmoothedVelocity().LengthSqr() > Square( 200 ) )

-			{

-				float t = 0;

-				Vector2D vDirMovement = pVehicle->GetSmoothedVelocity().AsVector2D();

-				if ( hunter_dodge_debug.GetBool() )

-				{

-					NDebugOverlay::Line( pVehicle->GetAbsOrigin(), pVehicle->GetAbsOrigin() + pVehicle->GetSmoothedVelocity(), 255, 255, 255, true, .1 );

-				}

-				vDirMovement.NormalizeInPlace();

-				Vector2D vDirToHunter = GetAbsOrigin().AsVector2D() - pVehicle->GetAbsOrigin().AsVector2D();

-				vDirToHunter.NormalizeInPlace();

-				if ( DotProduct2D( vDirMovement, vDirToHunter ) > hunter_dodge_warning_cone.GetFloat() && 

-					 CalcDistanceSqrToLine2D( GetAbsOrigin().AsVector2D(), pVehicle->GetAbsOrigin().AsVector2D(), vecFuturePos, &t ) < Square( hunter_dodge_warning_width.GetFloat() * .5 ) && 

-					 t > 0.0 && t < 1.0 )

-				{

-					if ( fabs( predictTime - hunter_dodge_warning.GetFloat() ) < .05 || random->RandomInt( 0, 3 ) )

-					{

-						SetCondition( COND_HUNTER_INCOMING_VEHICLE );

-					}

-					else

-					{

-						if ( hunter_dodge_debug. GetBool() )

-						{

-							Msg( "Hunter %d failing dodge (ignore)\n", entindex() );

-						}

-					}

-

-					if ( hunter_dodge_debug. GetBool() )

-					{

-						NDebugOverlay::Cross3D( EyePosition(), 100, 255, 255, 255, true, .1 );

-						if ( timeDrawnArrow != gpGlobals->curtime )

-						{

-							timeDrawnArrow = gpGlobals->curtime;

-							Vector vEndpoint( vecFuturePos.x, vecFuturePos.y, UTIL_GetLocalPlayer()->WorldSpaceCenter().z - 24 );

-							NDebugOverlay::HorzArrow( UTIL_GetLocalPlayer()->WorldSpaceCenter() - Vector(0, 0, 24), vEndpoint, hunter_dodge_warning_width.GetFloat(), 255, 0, 0, 64, true, .1 );

-						}

-					}

-				}

-				else if ( hunter_dodge_debug.GetBool() )

-				{

-					if ( t <= 0 )

-					{

-						NDebugOverlay::Cross3D( EyePosition(), 100, 0, 0, 255, true, .1 );

-					}

-					else

-					{

-						NDebugOverlay::Cross3D( EyePosition(), 100, 0, 255, 255, true, .1 );

-					}

-				}

-			}

-			else if ( hunter_dodge_debug.GetBool() )

-			{

-				NDebugOverlay::Cross3D( EyePosition(), 100, 0, 255, 0, true, .1 );

-			}

-			if ( hunter_dodge_debug. GetBool() )

-			{

-				if ( timeDrawnArrow != gpGlobals->curtime )

-				{

-					timeDrawnArrow = gpGlobals->curtime;

-					Vector vEndpoint( vecFuturePos.x, vecFuturePos.y, UTIL_GetLocalPlayer()->WorldSpaceCenter().z - 24 );

-					NDebugOverlay::HorzArrow( UTIL_GetLocalPlayer()->WorldSpaceCenter() - Vector(0, 0, 24), vEndpoint, hunter_dodge_warning_width.GetFloat(), 127, 127, 127, 64, true, .1 );

-				}

-			}

-

-		}

-

-		m_vecEnemyLastSeen = GetEnemy()->GetAbsOrigin();

-	}

-

-	if( !HasCondition(COND_ENEMY_OCCLUDED) )

-	{

-		// m_flTimeSawEnemyAgain always tells us what time I first saw this

-		// enemy again after some period of not seeing them. This is used to

-		// compute how long the enemy has been visible to me THIS TIME. 

-		// Every time I lose sight of the enemy this time is set invalid until

-		// I see the enemy again and record that time.

-		if( m_flTimeSawEnemyAgain == HUNTER_SEE_ENEMY_TIME_INVALID )

-		{

-			m_flTimeSawEnemyAgain = gpGlobals->curtime;

-		}

-	}

-	else

-	{

-		m_flTimeSawEnemyAgain = HUNTER_SEE_ENEMY_TIME_INVALID;

-	}

-

-	ManageSiegeTargets();

-}

-

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

-// Search all entities in the map

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

-void CNPC_Hunter::CollectSiegeTargets()

-{

-	CBaseEntity *pTarget = gEntList.FindEntityByName( NULL, m_iszSiegeTargetName );

-

-	while( pTarget != NULL )

-	{

-		if( pTarget->Classify() == CLASS_BULLSEYE )

-		{

-			m_pSiegeTargets.AddToTail( pTarget );

-		}

-

-		pTarget = gEntList.FindEntityByName( pTarget, m_iszSiegeTargetName );

-	};

-

-	if( m_pSiegeTargets.Count() < 1 )

-	{

-		m_iszSiegeTargetName = NULL_STRING;		// And stop trying!

-	}

-}

-

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

-// For use when Hunters are outside and the player is inside a structure

-// Create a temporary bullseye in a location that makes it seem like

-// I am aware of the location of a player I cannot see. (Then fire at

-// at this bullseye, thus laying 'siege' to the part of the building he 

-// is in.) The locations are copied from suitable info_target entities.

-// (these should be placed in exterior windows and doorways so that 

-// the Hunter fires into the building through these apertures)

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

-void CNPC_Hunter::ManageSiegeTargets()

-{

-	if( gpGlobals->curtime < m_flTimeNextSiegeTargetAttack )

-		return;

-

-	if( m_pSiegeTargets.Count() == 0 )

-	{

-		// If my list of siege targets is empty, go and cache all of them now

-		// so that I don't have to search the world every time.

-		CollectSiegeTargets();

-

-		if( m_pSiegeTargets.Count() == 0 )

-			return;

-	}

-

-	m_flTimeNextSiegeTargetAttack = gpGlobals->curtime + (hunter_siege_frequency.GetFloat() * RandomFloat( 0.8f, 1.2f) );

-	CBasePlayer *pPlayer = AI_GetSinglePlayer();

-

-	// Start by assuming we are not going to create a siege target

-	bool bCreateSiegeTarget = false;

-	if( GetEnemy() == NULL )

-	{

-		// If I have no enemy at all, give it a try.

-		bCreateSiegeTarget = true;

-	}

-

-	if( bCreateSiegeTarget )

-	{

-		// We've decided that the situation calls for a siege target. So, we dig through all of my siege targets and

-		// take the closest one to the player that the player can see! (Obey they bullseye's FOV)

-		float flClosestDistSqr = Square( 1200.0f ); // Only use siege targets within 100 feet of player

-		CBaseEntity *pSiegeTargetLocation = NULL;

-		int iTraces = 0;

-		for( int i = 0 ; i < m_pSiegeTargets.Count() ; i++ )

-		{

-			CBaseEntity *pCandidate = m_pSiegeTargets[i];

-			if ( pCandidate == NULL )

-				continue;

-

-			float flDistSqr = pCandidate->GetAbsOrigin().DistToSqr(pPlayer->GetAbsOrigin());

-

-			if( flDistSqr < flClosestDistSqr )

-			{

-				// CollectSiegeTargets() guarantees my list is populated only with bullseye entities.

-				CNPC_Bullseye *pBullseye = dynamic_cast<CNPC_Bullseye*>(pCandidate);

-				if( !pBullseye->FInViewCone(this) )

-					continue;

-

-				if( pPlayer->FVisible(pCandidate) )

-				{

-					iTraces++;// Only counting these as a loose perf measurement

-					flClosestDistSqr = flDistSqr;

-					pSiegeTargetLocation = pCandidate;

-				}

-			}

-		}

-

-		if( pSiegeTargetLocation != NULL )

-		{

-			// Ditch any leftover siege target.

-			KillCurrentSiegeTarget();

-

-			// Create a bullseye that will live for 20 seconds. If we can't attack it within 20 seconds, it's probably

-			// out of reach anyone, so have it clean itself up after that long.

-			CBaseEntity *pSiegeTarget = CreateCustomTarget( pSiegeTargetLocation->GetAbsOrigin(), 20.0f );

-			pSiegeTarget->SetName( MAKE_STRING("siegetarget") );

-

-			m_hCurrentSiegeTarget.Set( pSiegeTarget );

-

-			AddEntityRelationship( pSiegeTarget, D_HT, 1 );

-			GetEnemies()->UpdateMemory( GetNavigator()->GetNetwork(), pSiegeTarget, pSiegeTarget->GetAbsOrigin(), 0.0f, true );

-			AI_EnemyInfo_t *pMemory = GetEnemies()->Find( pSiegeTarget );

-

-			if( pMemory )

-			{

-				// Pretend we've known about this target longer than we really have so that our AI doesn't waste time running ALERT schedules.

-				pMemory->timeFirstSeen = gpGlobals->curtime - 5.0f;

-				pMemory->timeLastSeen = gpGlobals->curtime - 1.0f;

-			}

-		}

-	}

-}

-

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

-// Destroy the bullseye that we're using as a temporary target

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

-void CNPC_Hunter::KillCurrentSiegeTarget()

-{

-	if ( m_hCurrentSiegeTarget )

-	{

-		GetEnemies()->ClearMemory( m_hCurrentSiegeTarget );

-

-		UTIL_Remove( m_hCurrentSiegeTarget );

-		m_hCurrentSiegeTarget.Set( NULL );

-	}

-}

-

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

-// Return true if this NPC can hear the specified sound

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

-bool CNPC_Hunter::QueryHearSound( CSound *pSound )

-{

-	if ( pSound->SoundContext() & SOUND_CONTEXT_EXCLUDE_COMBINE )

-		return false;

-

-	if ( pSound->SoundContext() & SOUND_CONTEXT_PLAYER_VEHICLE )

-		return false;

-

-	return BaseClass::QueryHearSound( pSound );

-}

-

-

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

-// This is a fairly bogus heuristic right now, but it works on 06a and 12 (sjb)

-//

-// Better options:	Trace infinitely and check the material we hit for sky

-//					Put some leaf info in the BSP

-//					Use volumes in the levels? (yucky for designers)

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

-// TODO: use this or nuke it!

-void CNPC_Hunter::GatherIndoorOutdoorConditions()

-{

-	// Check indoor/outdoor before calling base class, since base class calls our

-	// RangeAttackConditions() functions, and we want those functions to know 

-	// whether we're indoors or out.

-	trace_t tr;

-

-	UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + Vector( 0, 0, 40.0f * 12.0f ), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );

-	if( tr.fraction < 1.0f )

-	{

-		SetCondition( COND_HUNTER_IS_INDOORS );

-	}

-	else

-	{

-		ClearCondition( COND_HUNTER_IS_INDOORS );

-	}

-}

-

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

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

-void CNPC_Hunter::BuildScheduleTestBits()

-{

-	BaseClass::BuildScheduleTestBits();

-

-	if ( m_lifeState != LIFE_ALIVE )

-	{

-		return;

-	}

-

-	// Our range attack is uninterruptable for the first few seconds.

-	if ( IsCurSchedule( SCHED_HUNTER_RANGE_ATTACK2, false ) && ( gpGlobals->curtime < m_flShootAllowInterruptTime ) )

-	{

-		ClearCustomInterruptConditions();

-		SetCustomInterruptCondition( COND_HEAVY_DAMAGE );

-	}

-	else if ( IsCurSchedule( SCHED_HUNTER_RANGE_ATTACK2, false ) && ( GetActivity() == ACT_TRANSITION ) )

-	{

-		// Don't stop unplanting just because we can range attack again.

-		ClearCustomInterruptCondition( COND_CAN_RANGE_ATTACK1 );

-		ClearCustomInterruptCondition( COND_CAN_RANGE_ATTACK2 );

-	}

-	else if ( !IsInLargeOutdoorMap() && IsCurSchedule( SCHED_HUNTER_FLANK_ENEMY, false ) && GetEnemy() != NULL )

-	{

-		if( HasCondition(COND_CAN_RANGE_ATTACK2) && m_flTimeSawEnemyAgain != HUNTER_SEE_ENEMY_TIME_INVALID )

-		{

-			if( (gpGlobals->curtime - m_flTimeSawEnemyAgain) >= 2.0f )

-			{

-				// When we're running flank behavior, wait a moment AFTER being able to see the enemy before

-				// breaking my schedule to range attack. This helps assure that the hunter gets well inside

-				// the room before stopping to attack. Otherwise the Hunter may stop immediately in the doorway

-				// and stop the progress of any hunters behind it.

-				SetCustomInterruptCondition( COND_CAN_RANGE_ATTACK2 );

-			}

-		}

-	}

-

-	// If our enemy is anything but a striderbuster, drop everything if we see one.

-	if ( !IsStriderBuster( GetEnemy() ) )

-	{

-		SetCustomInterruptCondition( COND_HUNTER_SEE_STRIDERBUSTER );

-	}

-

-	// If we're not too busy, allow ourselves to ACK found enemy signals.

-	if ( !GetEnemy() )

-	{

-		SetCustomInterruptCondition( COND_HUNTER_SQUADMATE_FOUND_ENEMY );

-	}

-

-	// Interrupt everything if we need to dodge.

-	if ( !IsCurSchedule( SCHED_HUNTER_DODGE, false ) && 

-		 !IsCurSchedule( SCHED_HUNTER_STAGGER, false ) &&

-		 !IsCurSchedule( SCHED_ALERT_FACE_BESTSOUND, false ) )

-	{

-		SetCustomInterruptCondition( COND_HUNTER_INCOMING_VEHICLE );

-		SetCustomInterruptCondition( COND_HEAR_PHYSICS_DANGER );

-		SetCustomInterruptCondition( COND_HUNTER_FORCED_DODGE );

-	}

-

-	// Always interrupt on a flank command.	

-	SetCustomInterruptCondition( COND_HUNTER_FORCED_FLANK_ENEMY );

-

-	// Always interrupt if staggered.

-	SetCustomInterruptCondition( COND_HUNTER_STAGGERED );

-	

-	// Always interrupt if hit by a sticky bomb.

-	SetCustomInterruptCondition( COND_HUNTER_HIT_BY_STICKYBOMB );

-}

-

-

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

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

-static bool IsMovablePhysicsObject( CBaseEntity *pEntity )

-{

-	return pEntity && pEntity->GetMoveType() == MOVETYPE_VPHYSICS && pEntity->VPhysicsGetObject() && pEntity->VPhysicsGetObject()->IsMoveable();

-}

-

-

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

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

-NPC_STATE CNPC_Hunter::SelectIdealState()

-{

-	switch ( m_NPCState )

-	{

-		case NPC_STATE_COMBAT:

-		{

-			if ( GetEnemy() == NULL )

-			{

-				if ( !HasCondition( COND_ENEMY_DEAD ) && !hunter_disable_patrol.GetBool() )

-				{

-					// Lost track of my enemy. Patrol.

-					SetCondition( COND_HUNTER_SHOULD_PATROL );

-				}

-

-				return NPC_STATE_ALERT;

-			}

-			else if ( HasCondition( COND_ENEMY_DEAD ) )

-			{

-				// dvs: TODO: announce enemy kills?

-				//AnnounceEnemyKill(GetEnemy());

-			}

-		}

-

-		default:

-		{

-			return BaseClass::SelectIdealState();

-		}

-	}

-

-	return GetIdealState();

-}

-

-

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

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

-bool CNPC_Hunter::ShouldCharge( const Vector &startPos, const Vector &endPos, bool useTime, bool bCheckForCancel )

-{

-	// Must have a target

-	if ( !GetEnemy() )

-		return false;

-

-	// Don't check the distance once we start charging

-	if ( !bCheckForCancel && !hunter_charge_test.GetBool() )

-	{

-		float distance = ( startPos.AsVector2D() - endPos.AsVector2D() ).LengthSqr();

-

-		// Must be within our tolerance range

-		if ( ( distance < Square(HUNTER_CHARGE_MIN) ) || ( distance > Square(HUNTER_CHARGE_MAX) ) )

-			return false;

-	}

-

-	// FIXME: We'd like to exclude small physics objects from this check!

-

-	// We only need to hit the endpos with the edge of our bounding box

-	Vector vecDir = endPos - startPos;

-	VectorNormalize( vecDir );

-	float flWidth = WorldAlignSize().x * 0.5;

-	Vector vecTargetPos = endPos - (vecDir * flWidth);

-

-	// See if we can directly move there

-	AIMoveTrace_t moveTrace;

-	GetMoveProbe()->MoveLimit( NAV_GROUND, startPos, vecTargetPos, MASK_NPCSOLID_BRUSHONLY, GetEnemy(), &moveTrace );

-	

-	// Draw the probe

-	if ( g_debug_hunter_charge.GetInt() == 1 )

-	{

-		Vector	enemyDir	= (vecTargetPos - startPos);

-		float	enemyDist	= VectorNormalize( enemyDir );

-

-		NDebugOverlay::BoxDirection( startPos, GetHullMins(), GetHullMaxs() + Vector(enemyDist,0,0), enemyDir, 0, 255, 0, 8, 1.0f );

-	}

-

-	// If we're not blocked, charge

-	if ( IsMoveBlocked( moveTrace ) )

-	{

-		// Don't allow it if it's too close to us

-		if ( UTIL_DistApprox( WorldSpaceCenter(), moveTrace.vEndPosition ) < HUNTER_CHARGE_MIN )

-			return false;

-

-		// Allow some special cases to not block us

-		if ( moveTrace.pObstruction != NULL )

-		{

-			// If we've hit the world, see if it's a cliff

-			if ( moveTrace.pObstruction == GetContainingEntity( INDEXENT(0) ) )

-			{	

-				// Can't be too far above/below the target

-				if ( fabs( moveTrace.vEndPosition.z - vecTargetPos.z ) > StepHeight() )

-					return false;

-

-				// Allow it if we got pretty close

-				if ( UTIL_DistApprox( moveTrace.vEndPosition, vecTargetPos ) < 64 )

-					return true;

-			}

-

-			// Hit things that will take damage

-			if ( moveTrace.pObstruction->m_takedamage != DAMAGE_NO )

-				return true;

-

-			// Hit things that will move

-			if ( moveTrace.pObstruction->GetMoveType() == MOVETYPE_VPHYSICS )

-				return true;

-		}

-

-		return false;

-	}

-

-	float zDelta = endPos.z - moveTrace.vEndPosition.z;

-	if ( fabsf(zDelta) > GetHullHeight() * 0.7)

-	{

-		return false;

-	}

-

-	return true;

-}

-

-

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

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

-bool CNPC_Hunter::HandleInteraction(int interactionType, void *data, CBaseCombatCharacter *pSourceEnt)

-{

-	if ( ( pSourceEnt != this ) && ( interactionType == g_interactionHunterFoundEnemy ) )

-	{

-		SetCondition( COND_HUNTER_SQUADMATE_FOUND_ENEMY );

-		return true;

-	}

-

-	return BaseClass::HandleInteraction( interactionType, data, pSourceEnt );

-}

-

-

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

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

-int CNPC_Hunter::SelectCombatSchedule()

-{

-	// If we're here with no enemy, patrol and hope we find one.

-	CBaseEntity *pEnemy = GetEnemy();

-	if ( pEnemy == NULL )

-	{

-		if ( !hunter_disable_patrol.GetBool() )

-			return SCHED_HUNTER_PATROL_RUN;

-		else

-			return SCHED_ALERT_STAND;

-	}

-

-	if ( hunter_flechette_test.GetBool() )

-	{

-		if ( HasCondition( COND_CAN_RANGE_ATTACK2 ) )

-		{

-			return SCHED_HUNTER_RANGE_ATTACK2;

-		}

-		return SCHED_COMBAT_FACE;

-	}

-

-	bool bStriderBuster = IsStriderBuster( pEnemy );

-	if ( bStriderBuster )

-	{

-		if ( gpGlobals->curtime - CAI_HunterEscortBehavior::gm_flLastDefendSound > 10.0 )

-		{

-			EmitSound( "NPC_Hunter.DefendStrider" );

-			CAI_HunterEscortBehavior::gm_flLastDefendSound = gpGlobals->curtime;

-		}

-

-		if ( HasCondition( COND_CAN_RANGE_ATTACK2 ) || HasCondition( COND_NOT_FACING_ATTACK ) )

-		{

-			return SCHED_HUNTER_RANGE_ATTACK2;

-		}

-		return SCHED_ESTABLISH_LINE_OF_FIRE;

-	}

-

-	// Certain behaviors, like flanking and melee attacks, only make sense on visible,

-	// corporeal enemies (NOT bullseyes).

-	bool bIsCorporealEnemy = IsCorporealEnemy( pEnemy );

-

-	// Take a quick swipe at our enemy if able to do so.

-	if ( bIsCorporealEnemy && HasCondition( COND_CAN_MELEE_ATTACK1 ) )

-	{

-		return SCHED_HUNTER_MELEE_ATTACK1;

-	}

-

-	// React to newly acquired enemies.

-	if ( bIsCorporealEnemy && HasCondition( COND_NEW_ENEMY ) )

-	{

-		AI_EnemyInfo_t *pEnemyInfo = GetEnemies()->Find( pEnemy );

-

-		if ( GetSquad() && pEnemyInfo && ( pEnemyInfo->timeFirstSeen == pEnemyInfo->timeAtFirstHand ) )

-		{

-			GetSquad()->BroadcastInteraction( g_interactionHunterFoundEnemy, NULL, this );

-

-			// First contact for my squad.

-			return SCHED_HUNTER_FOUND_ENEMY;

-		}

-	}

-

-	if ( HasCondition( COND_HUNTER_SQUADMATE_FOUND_ENEMY ) )

-	{

-		// A squadmate found an enemy. Respond to their call.

-		return SCHED_HUNTER_FOUND_ENEMY_ACK;

-	}

-

-	// Fire a flechette volley. Ignore squad slots if we're attacking a striderbuster.

-	// See if there is an opportunity to charge.

-	if ( !bStriderBuster && bIsCorporealEnemy && HasCondition( COND_HUNTER_CAN_CHARGE_ENEMY ) )

-	{

-		if ( hunter_charge_test.GetBool() || random->RandomInt( 1, 100 ) < hunter_charge_pct.GetInt() )

-		{

-			if ( hunter_charge_test.GetBool() || OccupyStrategySlot( SQUAD_SLOT_HUNTER_CHARGE ) )

-			{

-				return SCHED_HUNTER_CHARGE_ENEMY;

-			}

-		}

-	}

-

-	if ( HasCondition( COND_CAN_RANGE_ATTACK2 ) )

-	{

-		if ( bStriderBuster || CountRangedAttackers() < hunter_flechette_max_concurrent_volleys.GetInt() )

-		{

-			DelayRangedAttackers( hunter_flechette_volley_start_min_delay.GetFloat(), hunter_flechette_volley_start_max_delay.GetFloat(), true );

-			return SCHED_HUNTER_RANGE_ATTACK2;

-		}

-	}

-

-	if ( pEnemy->GetGroundEntity() == this )

-	{

-		return SCHED_HUNTER_MELEE_ATTACK1;

-	}

-

-	if ( HasCondition( COND_TOO_CLOSE_TO_ATTACK ) )

-	{

-		return SCHED_MOVE_AWAY_FROM_ENEMY;

-	}

-

-	// Sidestep every so often if my enemy is nearby and facing me.

-/*

-	if ( gpGlobals->curtime > m_flNextSideStepTime )

-	{

-		if ( HasCondition( COND_ENEMY_FACING_ME ) && ( UTIL_DistApprox( GetEnemy()->GetAbsOrigin(), GetAbsOrigin() ) < HUNTER_FACE_ENEMY_DIST ) )

-		{

-			m_flNextSideStepTime = gpGlobals->curtime + random->RandomFloat( 1.0f, 3.0f );

-			return SCHED_HUNTER_SIDESTEP;

-		}

-	}

-*/

-	if ( HasCondition( COND_HEAVY_DAMAGE ) && ( gpGlobals->curtime > m_flNextSideStepTime ) )

-	{

-		m_flNextSideStepTime = gpGlobals->curtime + random->RandomFloat( 1.0f, 3.0f );

-		return SCHED_HUNTER_SIDESTEP;

-	}

-

-	if ( !bStriderBuster && bIsCorporealEnemy )

-	{

-		if ( HasCondition( COND_HUNTER_CAN_CHARGE_ENEMY ) )

-		{

-			if ( OccupyStrategySlot( SQUAD_SLOT_HUNTER_CHARGE ) )

-			{

-				return SCHED_HUNTER_CHARGE_ENEMY;

-			}

-/*

-			else

-			{

-				return SCHED_HUNTER_SIDESTEP;

-			}

-*/

-		}

-

-		// Try to be a flanker.

-		if ( ( NumHuntersInMySquad() > 1 ) && OccupyStrategySlotRange( SQUAD_SLOT_HUNTER_FLANK_FIRST, SQUAD_SLOT_HUNTER_FLANK_LAST ) )

-		{

-			return SCHED_HUNTER_FLANK_ENEMY;

-		}

-	}

-	

-	// Can't see my enemy.

-	if ( HasCondition( COND_ENEMY_OCCLUDED ) || HasCondition( COND_ENEMY_TOO_FAR ) || HasCondition( COND_TOO_FAR_TO_ATTACK ) || HasCondition( COND_NOT_FACING_ATTACK ) )

-	{

-		return SCHED_HUNTER_CHASE_ENEMY;

-	}

-

-	if ( HasCondition( COND_HUNTER_CANT_PLANT ) )

-	{

-		return SCHED_ESTABLISH_LINE_OF_FIRE;

-	}

-

-	//if ( HasCondition( COND_ENEMY_OCCLUDED ) && IsCurSchedule( SCHED_RANGE_ATTACK1, false ) )

-	//{

-	//	return SCHED_HUNTER_COMBAT_FACE;

-	//}

-

- 	return SCHED_HUNTER_CHANGE_POSITION;

-}

-

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

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

-int CNPC_Hunter::SelectSiegeSchedule()

-{

-	bool bHasEnemy = (GetEnemy() != NULL);

-

-	if( bHasEnemy )

-	{

-		// We have an enemy, so we should be making every effort to attack it.

-		if( !HasCondition(COND_SEE_ENEMY) || !HasCondition(COND_CAN_RANGE_ATTACK2) )

-			return SCHED_ESTABLISH_LINE_OF_FIRE;

-

-		if( HasCondition(COND_CAN_RANGE_ATTACK2) )

-			return SCHED_HUNTER_RANGE_ATTACK2;

-

-		return SCHED_HUNTER_SIEGE_STAND;

-	}

-	else

-	{

-		// Otherwise we are loitering in siege mode. Break line of sight with the player

-		// if they expose our position.

-		if( HasCondition( COND_SEE_PLAYER ) )

-			return SCHED_HUNTER_CHANGE_POSITION_SIEGE;

-	}

-

-	return SCHED_HUNTER_SIEGE_STAND;

-}

-

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

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

-int CNPC_Hunter::SelectSchedule()

-{

-	if ( hunter_stand_still.GetBool() )

-	{

-		m_bPlanted = false;

-		return SCHED_IDLE_STAND;

-	}

-	

-	if ( HasCondition( COND_HUNTER_FORCED_DODGE ) )

-		return SCHED_HUNTER_DODGE;

-

-	if ( HasCondition( COND_HUNTER_NEW_HINTGROUP ) || ( GetHintGroup() != NULL_STRING && m_CheckHintGroupTimer.Expired() ) )

-	{

-		CAI_Hint *pHint;

-		CHintCriteria criteria;

-		criteria.SetGroup( GetHintGroup() );

-		criteria.SetFlag( bits_HINT_NODE_NEAREST );

-

-		if ( HasCondition( COND_HUNTER_NEW_HINTGROUP ) )

-		{

-			ClearCondition( COND_HUNTER_NEW_HINTGROUP );

-			if ( GetEnemy() )

-			{

-				pHint = CAI_HintManager::FindHint( NULL, GetEnemy()->GetAbsOrigin(), criteria );

-			}

-			else

-			{

-				pHint = CAI_HintManager::FindHint( GetAbsOrigin(), criteria );

-			}

-

-			if ( pHint )

-			{

-				pHint->Lock( this );

-			}

-		} 

-		else

-		{

-			pHint = CAI_HintManager::FindHint( GetAbsOrigin(), criteria );

-			if ( pHint )

-			{

-				if ( (pHint->GetAbsOrigin() - GetAbsOrigin()).Length2DSqr() < Square( 20*12 ) )

-				{

-					m_CheckHintGroupTimer.Set( 5 );

-					pHint = NULL;

-				}

-				else

-				{

-					m_CheckHintGroupTimer.Set( 15 );

-				}

-			}

-		}

-

-		if ( pHint )

-		{

-			SetHintNode( pHint );

-			return SCHED_HUNTER_GOTO_HINT;

-		}

-	}

-

-	if ( HasCondition( COND_HUNTER_INCOMING_VEHICLE ) )

-	{

-		if ( m_RundownDelay.Expired() )

-		{

-			int iRundownCounter = 0;

-			if ( GetSquad() )

-			{

-				GetSquad()->GetSquadData( HUNTER_RUNDOWN_SQUADDATA, &iRundownCounter );

-			}

-

-			if ( iRundownCounter % 2 == 0 )

-			{

-				for ( int i = 0; i < g_Hunters.Count(); i++ )

-				{

-					if ( g_Hunters[i] != this )

-					{

-						g_Hunters[i]->m_RundownDelay.Set( 3 );

-						g_Hunters[i]->m_IgnoreVehicleTimer.Force();

-					}

-				}

-				m_IgnoreVehicleTimer.Set( hunter_dodge_warning.GetFloat() * 4 );

-				if ( hunter_dodge_debug.GetBool() )

-				{

-					Msg( "Hunter %d rundown\n", entindex() );

-				}

-

-				if ( HasCondition( COND_SEE_ENEMY ) )

-				{

-					if ( m_bPlanted && HasCondition( COND_CAN_RANGE_ATTACK2 ) )

-					{

-						return SCHED_HUNTER_RANGE_ATTACK2;

-					}

-					else if ( random->RandomInt( 0, 1 ) )

-					{

-						return SCHED_HUNTER_CHARGE_ENEMY;

-					}

-					else

-					{

-						return SCHED_MOVE_AWAY;

-					}

-				}

-				else

-				{

-					SetTarget( UTIL_GetLocalPlayer() );

-					return SCHED_TARGET_FACE;

-				}

-			}

-			else

-			{

-				if ( hunter_dodge_debug.GetBool() )

-				{

-					Msg( "Hunter %d safe from rundown\n", entindex() );

-				}

-				for ( int i = 0; i < g_Hunters.Count(); i++ )

-				{

-					g_Hunters[i]->m_RundownDelay.Set( 4 );

-					g_Hunters[i]->m_IgnoreVehicleTimer.Force();

-				}

-				if ( GetSquad() )

-				{

-					GetSquad()->SetSquadData( HUNTER_RUNDOWN_SQUADDATA, iRundownCounter + 1 );

-				}

-			}

-		}

-

-		if ( HasCondition( COND_SEE_ENEMY ) )

-		{

-			if ( hunter_dodge_debug.GetBool() )

-			{

-				Msg( "Hunter %d try dodge\n", entindex() );

-			}

-			return SCHED_HUNTER_DODGE;

-		}

-		else

-		{

-			SetTarget( UTIL_GetLocalPlayer() );

-			return SCHED_TARGET_FACE;

-		}

-

-		CSound *pBestSound = GetBestSound( SOUND_PHYSICS_DANGER );

-		if ( pBestSound && ( pBestSound->SoundContext() & SOUND_CONTEXT_PLAYER_VEHICLE ) )

-		{

-			return SCHED_ALERT_FACE_BESTSOUND;

-		}

-	}

-

-	if ( HasCondition( COND_HUNTER_FORCED_FLANK_ENEMY ) )

-	{

-		return SCHED_HUNTER_FLANK_ENEMY;

-	}

-	

-	if ( HasCondition( COND_HUNTER_STAGGERED ) /*|| HasCondition( COND_HUNTER_HIT_BY_STICKYBOMB )*/ )

-	{

-		return SCHED_HUNTER_STAGGER;

-	}

-

-	// Now that we're past all of the forced reactions to things, if we're running the siege

-	// behavior, go pick an appropriate siege schedule UNLESS we have an enemy. If we have

-	// an enemy, we should focus on attacking that enemy.

-	if( IsUsingSiegeTargets() )

-	{

-		return SelectSiegeSchedule();

-	}

-

-	// back away if there's a magnade glued to my head.

-	if ( hunter_retreat_striderbusters.GetBool() /*&& GetEnemy() && ( GetEnemy()->IsPlayer() )*/ 

-		&& (m_hAttachedBusters.Count() > 0)

-		&& m_fCorneredTimer < gpGlobals->curtime)

-	{

-		return SCHED_HUNTER_TAKE_COVER_FROM_ENEMY;

-	}

-

-	if ( !BehaviorSelectSchedule() )

-	{

-		switch ( GetState() )

-		{

-			case NPC_STATE_IDLE:

-			{

-				return SCHED_HUNTER_PATROL;

-			}

-

-			case NPC_STATE_ALERT:

-			{

-				if ( HasCondition( COND_HUNTER_SHOULD_PATROL ) )

-					return SCHED_HUNTER_PATROL;

-					

-				break;

-			}

-

-			case NPC_STATE_COMBAT:

-			{

-				return SelectCombatSchedule();

-			}

-		}

-	}

-		

-	return BaseClass::SelectSchedule();

-}

-

-

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

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

-int CNPC_Hunter::TranslateSchedule( int scheduleType )

-{

-	switch ( scheduleType )

-	{

-		case SCHED_RANGE_ATTACK1:

-		{

-			return SCHED_HUNTER_RANGE_ATTACK1;

-		}

-

-		case SCHED_RANGE_ATTACK2:

-		case SCHED_HUNTER_RANGE_ATTACK2:

-		{

-			if ( scheduleType == SCHED_RANGE_ATTACK2 )

-			{

-				Msg( "HUNTER IGNORING SQUAD SLOTS\n" );

-			}

-

-			if ( IsStriderBuster( GetEnemy() ) )

-			{

-				// Attack as FAST as possible. The point is to shoot down the buster.

-				return SCHED_HUNTER_RANGE_ATTACK2_VS_STRIDERBUSTER;

-			}

-

-			return SCHED_HUNTER_RANGE_ATTACK2;

-		}

-

-		case SCHED_MELEE_ATTACK1:

-		{

-			return SCHED_HUNTER_MELEE_ATTACK1;

-		}

-	

-		case SCHED_ESTABLISH_LINE_OF_FIRE_FALLBACK:

-		{

-			return SCHED_HUNTER_CHANGE_POSITION;

-		}

-

-		case SCHED_ALERT_STAND:

-		{

-			if ( !hunter_disable_patrol.GetBool() )

-				return SCHED_HUNTER_PATROL_RUN;

-			break;

-		}

-

-		case SCHED_COMBAT_FACE:

-		{

-			return SCHED_HUNTER_COMBAT_FACE;

-		}

-

-		case SCHED_HUNTER_PATROL:

-		{

-			if ( hunter_disable_patrol.GetBool() )

-			{

-				return SCHED_IDLE_STAND;

-			}

-			break;

-		}

-	}

-

-	return BaseClass::TranslateSchedule( scheduleType );

-}

-

-

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

-// catch blockage while escaping magnade

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

-void CNPC_Hunter::TaskFail( AI_TaskFailureCode_t code )

-{

-	if ( IsCurSchedule( SCHED_HUNTER_TAKE_COVER_FROM_ENEMY, false ) && ( code == FAIL_NO_ROUTE_BLOCKED  ) )

-	{

-		// cornered!

-		if ( m_fCorneredTimer < gpGlobals->curtime )

-		{

-			m_fCorneredTimer = gpGlobals->curtime + 6.0f;

-		}

-	}

-

-	BaseClass::TaskFail( code );

-}

-

-

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

-// The player is speeding toward us in a vehicle! Find a good activity for dodging.

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

-void CNPC_Hunter::TaskFindDodgeActivity()

-{

-	if ( GetEnemy() == NULL )

-	{

-		TaskFail( "No enemy to dodge" );

-		return;

-	}

-

-	Vector vecUp;

-	Vector vecRight;

-	GetVectors( NULL, &vecRight, &vecUp );

-

-	// TODO: find most perpendicular 8-way dodge when we get the anims

-	Vector vecEnemyDir = GetEnemy()->GetAbsOrigin() - GetAbsOrigin();

-	//Vector vecDir = CrossProduct( vecEnemyDir, vecUp );

-	VectorNormalize( vecEnemyDir );

-	if ( fabs( DotProduct( vecEnemyDir, vecRight ) ) > 0.7 )

-	{

-		TaskFail( "Can't dodge, enemy approaching perpendicularly" );

-		return;

-	}

-

-	// Check left or right randomly first.

-	bool bDodgeLeft = false;

-	CBaseEntity *pVehicle = GetEnemyVehicle();

-	if ( pVehicle  )

-	{

-		Ray_t enemyRay;

-		Ray_t perpendicularRay;

-		enemyRay.Init( pVehicle->GetAbsOrigin(), pVehicle->GetAbsOrigin() + pVehicle->GetSmoothedVelocity() );

-		Vector vPerpendicularPt = vecEnemyDir;

-		vPerpendicularPt.y = -vPerpendicularPt.y;

-		perpendicularRay.Init( GetAbsOrigin(), GetAbsOrigin() + vPerpendicularPt );

-

-		enemyRay.m_Start.z = enemyRay.m_Delta.z = enemyRay.m_StartOffset.z;

-		perpendicularRay.m_Start.z = perpendicularRay.m_Delta.z = perpendicularRay.m_StartOffset.z;

-

-		float t, s;

-

-		IntersectRayWithRay( perpendicularRay, enemyRay, t, s );

-

-		if ( t > 0 )

-		{

-			bDodgeLeft = true;

-		}

-	}

-	else if ( random->RandomInt( 0, 1 ) == 0 )

-	{

-		bDodgeLeft = true;

-	}

-

-	bool bFoundDir = false;

-	int nTries = 0;

-

-	while ( !bFoundDir && ( nTries < 2 ) )

-	{

-		// Pick a dodge activity to try.

-		if ( bDodgeLeft )

-		{

-			m_eDodgeActivity = ACT_HUNTER_DODGEL;

-		}

-		else

-		{

-			m_eDodgeActivity = ACT_HUNTER_DODGER;

-		}

-

-		// See where the dodge will put us.

-		Vector vecLocalDelta;

-		int nSeq = SelectWeightedSequence( m_eDodgeActivity );

-		GetSequenceLinearMotion( nSeq, &vecLocalDelta );

-

-		// Transform the sequence delta into local space.

-		matrix3x4_t fRotateMatrix;

-		AngleMatrix( GetLocalAngles(), fRotateMatrix );

-		Vector vecDelta;

-		VectorRotate( vecLocalDelta, fRotateMatrix, vecDelta );

-

-		// Trace a bit high so this works better on uneven terrain.

-		Vector testHullMins = GetHullMins();

-		testHullMins.z += ( StepHeight() * 2 );

-

-		// See if all is clear in that direction.

-		trace_t tr;

-		HunterTraceHull_SkipPhysics( GetAbsOrigin(), GetAbsOrigin() + vecDelta, testHullMins, GetHullMaxs(), MASK_NPCSOLID, this, GetCollisionGroup(), &tr, VPhysicsGetObject()->GetMass() * 0.5f );

-

-		// TODO: dodge anyway if we'll make it a certain percentage of the way through the dodge?

-		if ( tr.fraction == 1.0f )

-		{

-			//NDebugOverlay::SweptBox( GetAbsOrigin(), GetAbsOrigin() + vecDelta, testHullMins, GetHullMaxs(), QAngle( 0, 0, 0 ), 0, 255, 0, 128, 5 );

-			bFoundDir = true;

-			TaskComplete();

-		}

-		else

-		{

-			//NDebugOverlay::SweptBox( GetAbsOrigin(), GetAbsOrigin() + vecDelta, testHullMins, GetHullMaxs(), QAngle( 0, 0, 0 ), 255, 0, 0, 128, 5 );

-			nTries++;

-			bDodgeLeft = !bDodgeLeft;

-		}

-	}

-

-	if ( nTries < 2 )

-	{

-		TaskComplete();

-	}

-	else

-	{

-		TaskFail( "Couldn't find dodge position\n" );

-	}

-}

-

-

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

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

-void CNPC_Hunter::StartTask( const Task_t *pTask )

-{

-	switch ( pTask->iTask )

-	{

-		case TASK_HUNTER_FINISH_RANGE_ATTACK:

-		{

-			if( GetEnemy() != NULL && GetEnemy()->Classify() == CLASS_PLAYER_ALLY_VITAL )

-			{

-				// Just finished shooting at Alyx! So forget her for a little while and get back on the player

-				// !!!LATER - make sure there's someone else in enemy memory to go bother.

-				GetEnemies()->SetTimeValidEnemy( GetEnemy(), gpGlobals->curtime + 10.0f );

-			}

-

-			if( m_hCurrentSiegeTarget )

-			{

-				// We probably just fired at our siege target, so dump it.

-				KillCurrentSiegeTarget();

-			}

-

-			TaskComplete();

-		}

-

-		case TASK_HUNTER_WAIT_FOR_MOVEMENT_FACING_ENEMY:

-		{

-			ChainStartTask( TASK_WAIT_FOR_MOVEMENT, pTask->flTaskData );

-			break;

-		}

-

-		case TASK_HUNTER_BEGIN_FLANK:

-		{

-			if ( IsInSquad() && GetSquad()->NumMembers() > 1 )

-			{

-				// Flank relative to the other shooter in our squad.

-				// If there's no other shooter, just flank relative to any squad member.

-				AISquadIter_t iter;

-				CAI_BaseNPC *pNPC = GetSquad()->GetFirstMember( &iter );

-				while ( pNPC == this )

-				{

-					pNPC = GetSquad()->GetNextMember( &iter );

-				}

-

-				m_vSavePosition = pNPC->GetAbsOrigin();

-			}

-			else

-			{

-				// Flank relative to our current position.

-				m_vSavePosition = GetAbsOrigin();

-			}

-			

-			TaskComplete();

-			break;

-		}

-

-		case TASK_HUNTER_ANNOUNCE_FLANK:

-		{

-			EmitSound( "NPC_Hunter.FlankAnnounce" );

-			TaskComplete();

-			break;

-		}

-

-		case TASK_HUNTER_DODGE:

-		{

-			if ( hunter_dodge_debug. GetBool() )

-			{

-				Msg( "Hunter %d dodging\n", entindex() );

-			}

-			SetIdealActivity( m_eDodgeActivity );

-			break;

-		}

-		

-		// Guarantee a certain delay between volleys. If we aren't already planted,

-		// the plant transition animation will take care of that.

-		case TASK_HUNTER_PRE_RANGE_ATTACK2:

-		{

-			if ( !m_bPlanted  || ( GetEnemy() && IsStriderBuster( GetEnemy() ) ) )

-			{

-				TaskComplete();

-			}

-			else

-			{

-				SetIdealActivity( ACT_HUNTER_ANGRY );

-			}

-			break;

-		}

-

-		case TASK_HUNTER_SHOOT_COMMIT:

-		{

-			// We're committing to shooting. Don't allow interrupts until after we've shot a bit (see TASK_RANGE_ATTACK1).

-			m_flShootAllowInterruptTime = gpGlobals->curtime + 100.0f;

-			TaskComplete();

-			break;

-		}

-		

-		case TASK_RANGE_ATTACK2:

-		{

-			if ( GetEnemy() )

-			{

-				bool bIsBuster = IsStriderBuster( GetEnemy() );

-				if ( bIsBuster )

-				{

-					AddFacingTarget( GetEnemy(), GetEnemy()->GetAbsOrigin() + GetEnemy()->GetSmoothedVelocity() * .5, 1.0, 0.8 );

-				}

-

-				// Start the firing sound.

-				//CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();

-				//controller.SoundChangeVolume( m_pGunFiringSound, 1.0, hunter_first_flechette_delay.GetFloat() );

-

-				SetIdealActivity( ACT_RANGE_ATTACK2 );

-

-				// Decide how many shots to fire.

-				int nShots = hunter_flechette_volley_size.GetInt();

-				if ( g_pGameRules->IsSkillLevel( SKILL_EASY ) )

-				{

-					nShots--;

-				}

-

-				// Decide when to fire the first shot.

-				float initialDelay = hunter_first_flechette_delay.GetFloat();

-				if ( bIsBuster )

-				{

-					initialDelay = 0; //*= 0.5;

-				}

-

-				BeginVolley( nShots, gpGlobals->curtime + initialDelay );

-

-				// In case we need to miss on purpose, pick a direction now.

-				m_bMissLeft = false;

-				if ( random->RandomInt( 0, 1 ) == 0 )

-				{

-					m_bMissLeft = true;

-				}

-

-				LockBothEyes( initialDelay + ( nShots * hunter_flechette_delay.GetFloat() ) );

-			}

-			else

-			{

-				TaskFail( FAIL_NO_ENEMY );

-			}

-			

-			break;

-		}

-

-		case TASK_HUNTER_STAGGER:

-		{

-			// Stagger in the direction the impact force would push us.

-			VMatrix worldToLocalRotation = EntityToWorldTransform();

-			Vector vecLocalStaggerDir = worldToLocalRotation.InverseTR().ApplyRotation( m_vecStaggerDir );

-			

-			float flStaggerYaw = VecToYaw( vecLocalStaggerDir );

-			SetPoseParameter( gm_nStaggerYawPoseParam, flStaggerYaw );

-

-			// Go straight there!

-			SetActivity( ACT_RESET );

-			SetActivity( ( Activity )ACT_HUNTER_STAGGER );

-			break;

-		}

-	

-		case TASK_MELEE_ATTACK1:

-		{

-			SetLastAttackTime( gpGlobals->curtime );

-			

-			if ( GetEnemy() && GetEnemy()->IsPlayer() )

-			{

-				ResetIdealActivity( ( Activity )ACT_HUNTER_MELEE_ATTACK1_VS_PLAYER );

-			}

-			else

-			{

-				ResetIdealActivity( ACT_MELEE_ATTACK1 );

-			}

-			

-			break;

-		}

-

-		case TASK_HUNTER_CORNERED_TIMER:

-		{

-			m_fCorneredTimer = gpGlobals->curtime + pTask->flTaskData;

-

-			break;

-		}

-

-		case TASK_HUNTER_FIND_SIDESTEP_POSITION:

-		{

-			if ( GetEnemy() == NULL )

-			{

-				TaskFail( "No enemy to sidestep" );

-			}

-			else

-			{

-				Vector vecUp;

-				GetVectors( NULL, NULL, &vecUp );

-				

-				Vector vecEnemyDir = GetEnemy()->GetAbsOrigin() - GetAbsOrigin();

-				Vector vecDir = CrossProduct( vecEnemyDir, vecUp );

-				VectorNormalize( vecDir );

-

-				// Sidestep left or right randomly.				

-				if ( random->RandomInt( 0, 1 ) == 0 )

-				{

-					vecDir *= -1;

-				}

-

-				// Start high and then trace down so that it works on uneven terrain.

-				Vector vecPos = GetAbsOrigin() + Vector( 0, 0, 64 ) + random->RandomFloat( 120, 200 ) * vecDir;

-				

-				// Try to find the ground at the sidestep position.

-				trace_t tr;

-				UTIL_TraceLine( vecPos, vecPos + Vector( 0, 0, -128 ), MASK_NPCSOLID, NULL, COLLISION_GROUP_NONE, &tr );

-				if ( tr.fraction < 1.0f )

-				{

-					//NDebugOverlay::Line( vecPos, tr.endpos, 0, 255, 0, true, 10 ); 

-		

-					m_vSavePosition = tr.endpos;

-									

-					TaskComplete();

-				}

-				else

-				{

-					TaskFail( "Couldn't find sidestep position\n" );

-				}

-			}

-			

-			break;

-		}

-

-		case TASK_HUNTER_FIND_DODGE_POSITION:

-		{

-			TaskFindDodgeActivity();

-			break;

-		}

-

-		case TASK_HUNTER_CHARGE:

-		{

-			SetIdealActivity( ( Activity )ACT_HUNTER_CHARGE_START );

-			break;

-		}

-

-		case TASK_HUNTER_CHARGE_DELAY:

-		{

-			m_flNextChargeTime = gpGlobals->curtime + pTask->flTaskData;

-			TaskComplete();

-			break;

-		}

-	

-		case TASK_DIE:

-		{

-			GetNavigator()->StopMoving();	

-			ResetActivity();

-			SetIdealActivity( GetDeathActivity() );

-			m_lifeState = LIFE_DYING;

-

-			break;

-		}

-

-		//case TASK_HUNTER_END_FLANK:

-		//{

-		//	

-		//}

-	

-		default:

-		{

-			BaseClass::StartTask( pTask );

-			break;

-		}

-	}

-}

-

-

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

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

-void CNPC_Hunter::RunTask( const Task_t *pTask )

-{

-	switch ( pTask->iTask )

-	{

-		case TASK_HUNTER_PRE_RANGE_ATTACK2:

-		{

-			if ( IsActivityFinished() )

-			{

-				TaskComplete();

-			}

-			break;

-		}

-

-		case TASK_RANGE_ATTACK2:

-		{

-			if( !hunter_hate_thrown_striderbusters.GetBool() && GetEnemy() != NULL && IsStriderBuster( GetEnemy() ) )

-			{

-				if( !IsValidEnemy(GetEnemy()) )

-				{

-					TaskFail("No longer hate this StriderBuster");

-				}

-			}

-

-			bool bIsBuster = IsStriderBuster( GetEnemy() );

-			if ( bIsBuster )

-			{

-				Vector vFuturePosition = GetEnemy()->GetAbsOrigin() + GetEnemy()->GetSmoothedVelocity() * .3;

-				AddFacingTarget( GetEnemy(), vFuturePosition, 1.0, 0.8 );

-

-				Vector2D vToFuturePositon = ( vFuturePosition.AsVector2D() - GetAbsOrigin().AsVector2D() );

-				vToFuturePositon.NormalizeInPlace();

-				Vector2D facingDir = BodyDirection2D().AsVector2D();

-

-				float flDot = DotProduct2D( vToFuturePositon, facingDir );

-

-				if ( flDot < .4 )

-				{

-					GetMotor()->SetIdealYawToTarget( vFuturePosition );

-					GetMotor()->UpdateYaw();

-					break;

-				}

-			}

-

-			if ( gpGlobals->curtime >= m_flNextFlechetteTime )

-			{

-				// Must have an enemy and a shot queued up.

-				bool bDone = false;

-				if ( GetEnemy() != NULL && m_nFlechettesQueued > 0 )

-				{

-					if ( ShootFlechette( GetEnemy(), false ) )

-					{

-						m_nClampedShots++;

-					}

-					else

-					{

-						m_nClampedShots = 0;

-					}

-

-					m_nFlechettesQueued--;

-

-					// If we fired three or more clamped shots in a row, call it quits so we don't look dumb.

-					if ( ( m_nClampedShots >= 3 ) || ( m_nFlechettesQueued == 0 ) )

-					{

-						bDone = true;

-					}

-					else

-					{

-						// More shooting to do. Schedule our next flechette.

-						m_flNextFlechetteTime = gpGlobals->curtime + hunter_flechette_delay.GetFloat();

-					}

-				}

-				else

-				{

-					bDone = true;

-				}

-				

-				if ( bDone )     

-				{

-					// Stop the firing sound.

-					//CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();

-					//controller.SoundChangeVolume( m_pGunFiringSound, 0.0f, 0.1f );

-

-					DelayRangedAttackers( hunter_flechette_volley_end_min_delay.GetFloat(), hunter_flechette_volley_end_max_delay.GetFloat(), true );

-					TaskComplete();

-				}

-			}

-

-			break;

-		}

-	

-		case TASK_GET_PATH_TO_ENEMY_LOS:

-		{

-			ChainRunTask( TASK_GET_PATH_TO_ENEMY_LKP_LOS, pTask->flTaskData );

-			break;

-		}

-

-		case TASK_HUNTER_DODGE:

-		{

-			AutoMovement();

-

-			if ( IsActivityFinished() )

-			{

-				TaskComplete();

-			}

-			break;

-		}

-

-		case TASK_HUNTER_CORNERED_TIMER:

-		{

-			TaskComplete();

-			break;

-		}

-		

-		case TASK_HUNTER_STAGGER:

-		{

-			if ( IsActivityFinished() )

-			{

-				TaskComplete();

-			}

-			break;

-		}

-				

-		case TASK_HUNTER_CHARGE:

-		{

-			Activity eActivity = GetActivity();

-

-			// See if we're trying to stop after hitting/missing our target

-			if ( eActivity == ACT_HUNTER_CHARGE_STOP || eActivity == ACT_HUNTER_CHARGE_CRASH ) 

-			{

-				if ( IsActivityFinished() )

-				{

-					m_flNextChargeTime = gpGlobals->curtime + hunter_charge_min_delay.GetFloat() + random->RandomFloat( 0, 2.5 ) + random->RandomFloat( 0, 2.5 );

-					float delayMultiplier = ( g_pGameRules->IsSkillLevel( SKILL_EASY ) ) ? 1.5 : 1.0;

-					float groupDelay = gpGlobals->curtime +  ( 2.0  + random->RandomFloat( 0, 2 ) ) * delayMultiplier;

-					for ( int i = 0; i < g_Hunters.Count(); i++ )

-					{

-						if ( g_Hunters[i] != this && g_Hunters[i]->m_flNextChargeTime < groupDelay )

-						{

-							g_Hunters[i]->m_flNextChargeTime = groupDelay;

-						}

-					}

-					TaskComplete();

-					return;

-				}

-

-				// Still in the process of slowing down. Run movement until it's done.

-				AutoMovement();

-				return;

-			}

-

-			// Check for manual transition

-			if ( ( eActivity == ACT_HUNTER_CHARGE_START ) && ( IsActivityFinished() ) )

-			{

-				SetIdealActivity( ACT_HUNTER_CHARGE_RUN );

-			}

-

-			// See if we're still running

-			if ( eActivity == ACT_HUNTER_CHARGE_RUN || eActivity == ACT_HUNTER_CHARGE_START ) 

-			{

-				if ( HasCondition( COND_NEW_ENEMY ) || HasCondition( COND_LOST_ENEMY ) || HasCondition( COND_ENEMY_DEAD ) )

-				{

-					SetIdealActivity( ACT_HUNTER_CHARGE_STOP );

-					return;

-				}

-				else 

-				{

-					if ( GetEnemy() != NULL )

-					{

-						Vector	goalDir = ( GetEnemy()->GetAbsOrigin() - GetAbsOrigin() );

-						VectorNormalize( goalDir );

-

-						if ( DotProduct( BodyDirection2D(), goalDir ) < 0.25f )

-						{

-							SetIdealActivity( ACT_HUNTER_CHARGE_STOP );

-						}

-					}

-				}

-			}

-

-			// Steer towards our target

-			float idealYaw;

-			if ( GetEnemy() == NULL )

-			{

-				idealYaw = GetMotor()->GetIdealYaw();

-			}

-			else

-			{

-				idealYaw = CalcIdealYaw( GetEnemy()->GetAbsOrigin() );

-			}

-

-			// Add in our steering offset

-			idealYaw += ChargeSteer();

-			

-			// Turn to face

-			GetMotor()->SetIdealYawAndUpdate( idealYaw );

-

-			// See if we're going to run into anything soon

-			ChargeLookAhead();

-

-			// Let our animations simply move us forward. Keep the result

-			// of the movement so we know whether we've hit our target.

-			AIMoveTrace_t moveTrace;

-			if ( AutoMovement( GetEnemy(), &moveTrace ) == false )

-			{

-				// Only stop if we hit the world

-				if ( HandleChargeImpact( moveTrace.vEndPosition, moveTrace.pObstruction ) )

-				{

-					// If we're starting up, this is an error

-					if ( eActivity == ACT_HUNTER_CHARGE_START )

-					{

-						TaskFail( "Unable to make initial movement of charge\n" );

-						return;

-					}

-

-					// Crash unless we're trying to stop already

-					if ( eActivity != ACT_HUNTER_CHARGE_STOP )

-					{

-						if ( moveTrace.fStatus == AIMR_BLOCKED_WORLD && moveTrace.vHitNormal == vec3_origin )

-						{

-							SetIdealActivity( ACT_HUNTER_CHARGE_STOP );

-						}

-						else

-						{

-							// Shake the screen

-							if ( moveTrace.fStatus != AIMR_BLOCKED_NPC )

-							{

-								EmitSound( "NPC_Hunter.ChargeHitWorld" );

-								UTIL_ScreenShake( GetAbsOrigin(), 16.0f, 4.0f, 1.0f, 400.0f, SHAKE_START );

-							}

-							SetIdealActivity( ACT_HUNTER_CHARGE_CRASH );

-						}

-					}

-				}

-				else if ( moveTrace.pObstruction )

-				{

-					// If we hit another hunter, stop

-					if ( moveTrace.pObstruction->Classify() == CLASS_COMBINE_HUNTER )

-					{

-						// Crash unless we're trying to stop already

-						if ( eActivity != ACT_HUNTER_CHARGE_STOP )

-						{

-							SetIdealActivity( ACT_HUNTER_CHARGE_STOP );

-						}

-					}

-					// If we hit an antlion, don't stop, but kill it

-					// We never have hunters and antlions together, but you never know.

-					else if (moveTrace.pObstruction->Classify() == CLASS_ANTLION )

-					{

-						if ( FClassnameIs( moveTrace.pObstruction, "npc_antlionguard" ) )

-						{

-							// Crash unless we're trying to stop already

-							if ( eActivity != ACT_HUNTER_CHARGE_STOP )

-							{

-								SetIdealActivity( ACT_HUNTER_CHARGE_STOP );

-							}

-						}

-						else

-						{

-							Hunter_ApplyChargeDamage( this, moveTrace.pObstruction, moveTrace.pObstruction->GetHealth() );

-						}

-					}

-				}

-			}

-

-			break;

-		}

-				

-		case TASK_HUNTER_WAIT_FOR_MOVEMENT_FACING_ENEMY:

-		{

-			if ( GetEnemy() )

-			{

-				Vector vecEnemyLKP = GetEnemyLKP();

-				AddFacingTarget( GetEnemy(), vecEnemyLKP, 1.0, 0.8 );

-			}

-			ChainRunTask( TASK_WAIT_FOR_MOVEMENT, pTask->flTaskData );

-			break;

-		}

-

-		default:

-		{

-			BaseClass::RunTask( pTask );

-			break;		

-		}

-	}

-}

-

-

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

-// Return true if our charge target is right in front of the hunter.

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

-bool CNPC_Hunter::EnemyIsRightInFrontOfMe( CBaseEntity **pEntity )

-{

-	if ( !GetEnemy() )

-		return false;

-

-	if ( (GetEnemy()->WorldSpaceCenter() - WorldSpaceCenter()).LengthSqr() < (156*156) )

-	{

-		Vector vecLOS = ( GetEnemy()->GetAbsOrigin() - GetAbsOrigin() );

-		vecLOS.z = 0;

-		VectorNormalize( vecLOS );

-		Vector vBodyDir = BodyDirection2D();

-		if ( DotProduct( vecLOS, vBodyDir ) > 0.8 )

-		{

-			// He's in front of me, and close. Make sure he's not behind a wall.

-			trace_t tr;

-			UTIL_TraceHull( WorldSpaceCenter(), GetEnemy()->WorldSpaceCenter(), GetHullMins() * 0.5, GetHullMaxs() * 0.5, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );

-			if ( tr.m_pEnt == GetEnemy() )

-			{

-				*pEntity = tr.m_pEnt;

-				return true;

-			}

-		}

-	}

-

-	return false;

-}

-

-

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

-// While charging, look ahead and see if we're going to run into anything.

-// If we are, start the gesture so it looks like we're anticipating the hit.

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

-void CNPC_Hunter::ChargeLookAhead( void )

-{

-#if 0

-	trace_t	tr;

-	Vector vecForward;

-	GetVectors( &vecForward, NULL, NULL );

-	Vector vecTestPos = GetAbsOrigin() + ( vecForward * m_flGroundSpeed * 0.75 );

-	Vector testHullMins = GetHullMins();

-	testHullMins.z += (StepHeight() * 2);

-	HunterTraceHull_SkipPhysics( GetAbsOrigin(), vecTestPos, testHullMins, GetHullMaxs(), MASK_SHOT_HULL, this, COLLISION_GROUP_NONE, &tr, VPhysicsGetObject()->GetMass() * 0.5 );

-

-	//NDebugOverlay::Box( tr.startpos, testHullMins, GetHullMaxs(), 0, 255, 0, true, 0.1f );

-	//NDebugOverlay::Box( vecTestPos, testHullMins, GetHullMaxs(), 255, 0, 0, true, 0.1f );

-

-	if ( tr.fraction != 1.0 )

-	{

-		// dvs: TODO:

-		// Start playing the hit animation

-		//AddGesture( ACT_HUNTER_CHARGE_ANTICIPATION );

-	}

-#endif

-}

-

-

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

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

-float CNPC_Hunter::ChargeSteer()

-{

-	trace_t	tr;

-	Vector	testPos, steer, forward, right;

-	QAngle	angles;

-	const float	testLength = m_flGroundSpeed * 0.15f;

-

-	//Get our facing

-	GetVectors( &forward, &right, NULL );

-

-	steer = forward;

-

-	const float faceYaw	= UTIL_VecToYaw( forward );

-

-	//Offset right

-	VectorAngles( forward, angles );

-	angles[YAW] += 45.0f;

-	AngleVectors( angles, &forward );

-

-	// Probe out

-	testPos = GetAbsOrigin() + ( forward * testLength );

-

-	// Offset by step height

-	Vector testHullMins = GetHullMins();

-	testHullMins.z += (StepHeight() * 2);

-

-	// Probe

-	HunterTraceHull_SkipPhysics( GetAbsOrigin(), testPos, testHullMins, GetHullMaxs(), MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr, VPhysicsGetObject()->GetMass() * 0.5f );

-

-	// Debug info

-	if ( g_debug_hunter_charge.GetInt() == 1 )

-	{

-		if ( tr.fraction == 1.0f )

-		{

-  			NDebugOverlay::BoxDirection( GetAbsOrigin(), testHullMins, GetHullMaxs() + Vector(testLength,0,0), forward, 0, 255, 0, 8, 0.1f );

-   		}

-   		else

-   		{

-  			NDebugOverlay::BoxDirection( GetAbsOrigin(), testHullMins, GetHullMaxs() + Vector(testLength,0,0), forward, 255, 0, 0, 8, 0.1f );

-		}

-	}

-

-	// Add in this component

-	steer += ( right * 0.5f ) * ( 1.0f - tr.fraction );

-

-	// Offset left

-	angles[YAW] -= 90.0f;

-	AngleVectors( angles, &forward );

-

-	// Probe out

-	testPos = GetAbsOrigin() + ( forward * testLength );

-	HunterTraceHull_SkipPhysics( GetAbsOrigin(), testPos, testHullMins, GetHullMaxs(), MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr, VPhysicsGetObject()->GetMass() * 0.5f );

-

-	// Debug

-	if ( g_debug_hunter_charge.GetInt() == 1 )

-	{

-		if ( tr.fraction == 1.0f )

-		{

-			NDebugOverlay::BoxDirection( GetAbsOrigin(), testHullMins, GetHullMaxs() + Vector(testLength,0,0), forward, 0, 255, 0, 8, 0.1f );

-		}

-		else

-		{

-			NDebugOverlay::BoxDirection( GetAbsOrigin(), testHullMins, GetHullMaxs() + Vector(testLength,0,0), forward, 255, 0, 0, 8, 0.1f );

-		}

-	}

-

-	// Add in this component

-	steer -= ( right * 0.5f ) * ( 1.0f - tr.fraction );

-

-	// Debug

-	if ( g_debug_hunter_charge.GetInt() == 1 )

-	{

-		NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + ( steer * 512.0f ), 255, 255, 0, true, 0.1f );

-		NDebugOverlay::Cross3D( GetAbsOrigin() + ( steer * 512.0f ), Vector(2,2,2), -Vector(2,2,2), 255, 255, 0, true, 0.1f );

-

-		NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + ( BodyDirection3D() * 256.0f ), 255, 0, 255, true, 0.1f );

-		NDebugOverlay::Cross3D( GetAbsOrigin() + ( BodyDirection3D() * 256.0f ), Vector(2,2,2), -Vector(2,2,2), 255, 0, 255, true, 0.1f );

-	}

-

-	return UTIL_AngleDiff( UTIL_VecToYaw( steer ), faceYaw );

-}

-

-

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

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

-void CNPC_Hunter::ChargeDamage( CBaseEntity *pTarget )

-{

-	if ( pTarget == NULL )

-		return;

-

-	CBasePlayer *pPlayer = ToBasePlayer( pTarget );

-

-	if ( pPlayer != NULL )

-	{

-		//Kick the player angles

-		pPlayer->ViewPunch( QAngle( 20, 20, -30 ) );	

-

-		Vector	dir = pPlayer->WorldSpaceCenter() - WorldSpaceCenter();

-		VectorNormalize( dir );

-		dir.z = 0.0f;

-		

-		Vector vecNewVelocity = dir * 250.0f;

-		vecNewVelocity[2] += 128.0f;

-		pPlayer->SetAbsVelocity( vecNewVelocity );

-

-		color32 red = {128,0,0,128};

-		UTIL_ScreenFade( pPlayer, red, 1.0f, 0.1f, FFADE_IN );

-	}

-	

-	// Player takes less damage

-	float flDamage = ( pPlayer == NULL ) ? 250 : sk_hunter_dmg_charge.GetFloat();

-	

-	// If it's being held by the player, break that bond

-	Pickup_ForcePlayerToDropThisObject( pTarget );

-

-	// Calculate the physics force

-	Hunter_ApplyChargeDamage( this, pTarget, flDamage );

-}

-

-

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

-// Handles the hunter charging into something. Returns true if it hit the world.

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

-bool CNPC_Hunter::HandleChargeImpact( Vector vecImpact, CBaseEntity *pEntity )

-{

-	// Cause a shock wave from this point which will disrupt nearby physics objects

-	//ImpactShock( vecImpact, 128, 350 );

-

-	// Did we hit anything interesting?

-	if ( !pEntity || pEntity->IsWorld() )

-	{

-		// Robin: Due to some of the finicky details in the motor, the hunter will hit

-		//		  the world when it is blocked by our enemy when trying to step up 

-		//		  during a moveprobe. To get around this, we see if the enemy's within

-		//		  a volume in front of the hunter when we hit the world, and if he is,

-		//		  we hit him anyway.

-		EnemyIsRightInFrontOfMe( &pEntity );

-

-		// Did we manage to find him? If not, increment our charge miss count and abort.

-		if ( pEntity->IsWorld() )

-		{

-			return true;

-		}

-	}

-

-	// Hit anything we don't like

-	if ( IRelationType( pEntity ) == D_HT && ( GetNextAttack() < gpGlobals->curtime ) )

-	{

-		EmitSound( "NPC_Hunter.ChargeHitEnemy" );

-

-		// dvs: TODO:

-		//if ( !IsPlayingGesture( ACT_HUNTER_CHARGE_HIT ) )

-		//{

-		//	RestartGesture( ACT_HUNTER_CHARGE_HIT );

-		//}

-		

-		ChargeDamage( pEntity );

-

-		if ( !pEntity->IsNPC() )

-		{

-			pEntity->ApplyAbsVelocityImpulse( ( BodyDirection2D() * 400 ) + Vector( 0, 0, 200 ) );

-		}

-

-		if ( !pEntity->IsAlive() && GetEnemy() == pEntity )

-		{

-			SetEnemy( NULL );

-		}

-

-		SetNextAttack( gpGlobals->curtime + 2.0f );

-

-		if ( !pEntity->IsAlive() || !pEntity->IsNPC() )

-		{

-			SetIdealActivity( ACT_HUNTER_CHARGE_STOP );

-			return false;

-		}

-		else

-			return true;

-

-	}

-

-	// Hit something we don't hate. If it's not moveable, crash into it.

-	if ( pEntity->GetMoveType() == MOVETYPE_NONE || pEntity->GetMoveType() == MOVETYPE_PUSH )

-	{		

-		CBreakable *pBreakable = dynamic_cast<CBreakable *>(pEntity);

-		if ( pBreakable  && pBreakable->IsBreakable() && pBreakable->m_takedamage == DAMAGE_YES && pBreakable->GetHealth() > 0 )

-		{

-			ChargeDamage( pEntity );

-		}

-		return true;

-	}

-

-	// If it's a vphysics object that's too heavy, crash into it too.

-	if ( pEntity->GetMoveType() == MOVETYPE_VPHYSICS )

-	{

-		IPhysicsObject *pPhysics = pEntity->VPhysicsGetObject();

-		if ( pPhysics )

-		{

-			// If the object is being held by the player, knock it out of his hands

-			if ( pPhysics->GetGameFlags() & FVPHYSICS_PLAYER_HELD )

-			{

-				Pickup_ForcePlayerToDropThisObject( pEntity );

-				return false;

-			}

-

-			if ( !pPhysics->IsMoveable() )

-				return true;

-

-			float entMass = PhysGetEntityMass( pEntity ) ;

-			float minMass = VPhysicsGetObject()->GetMass() * 0.5f;

-			if ( entMass < minMass )

-			{

-				if ( entMass < minMass * 0.666f || pEntity->CollisionProp()->BoundingRadius() < GetHullHeight() )

-				{

-					if ( pEntity->GetHealth() > 0 )

-					{

-						CBreakableProp *pBreakable = dynamic_cast<CBreakableProp *>(pEntity);

-						if ( pBreakable && pBreakable->m_takedamage == DAMAGE_YES && pBreakable->GetHealth() > 0 && pBreakable->GetHealth() <= 50 )

-						{

-							ChargeDamage( pEntity );

-						}

-					}

-					pEntity->SetNavIgnore( 2.0 );

-					return false;

-				}

-			}

-			return true;

-

-		}

-	}

-

-	return false;

-}

-

-

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

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

-void CNPC_Hunter::Explode()

-{

-	Vector			velocity = vec3_origin;

-	AngularImpulse	angVelocity = RandomAngularImpulse( -150, 150 );

-

-	PropBreakableCreateAll( GetModelIndex(), NULL, EyePosition(), GetAbsAngles(), velocity, angVelocity, 1.0, 150, COLLISION_GROUP_NPC, this );

-

-	ExplosionCreate( EyePosition(), GetAbsAngles(), this, 500, 256, (SF_ENVEXPLOSION_NOPARTICLES|SF_ENVEXPLOSION_NOSPARKS|SF_ENVEXPLOSION_NODLIGHTS|SF_ENVEXPLOSION_NODAMAGE|SF_ENVEXPLOSION_NOSMOKE), false );

-

-	// Create liquid fountain gushtacular effect here!

-	CEffectData	data;

-

-	data.m_vOrigin = EyePosition();

-	data.m_vNormal = Vector( 0, 0, 1 );

-	data.m_flScale = 4.0f;

-

-	DispatchEffect( "StriderBlood", data );

-	

-	// Go away

-	m_lifeState = LIFE_DEAD;

-

-	SetThink( &CNPC_Hunter::SUB_Remove );

-	SetNextThink( gpGlobals->curtime + 0.1f );

-

-	AddEffects( EF_NODRAW );

-}

-

-

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

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

-Activity CNPC_Hunter::NPC_TranslateActivity( Activity baseAct )

-{

-	if ( ( baseAct == ACT_WALK ) || ( baseAct == ACT_RUN ) )

-	{

-  		if ( GetEnemy() )

-  		{

-			Vector vecEnemyLKP = GetEnemyLKP();

-			

-			// Only start facing when we're close enough

-			if ( UTIL_DistApprox( vecEnemyLKP, GetAbsOrigin() ) < HUNTER_FACE_ENEMY_DIST )

-			{

-				return (Activity)ACT_HUNTER_WALK_ANGRY;

-			}

-		}

-	}

-	else if ( ( baseAct == ACT_IDLE ) && m_bPlanted )

-	{

-		return ( Activity )ACT_HUNTER_IDLE_PLANTED;

-	}

-	else if ( baseAct == ACT_RANGE_ATTACK2 )

-	{

-		if ( !m_bPlanted && ( m_bEnableUnplantedShooting || IsStriderBuster( GetEnemy() ) ) )

-		{

-			return (Activity)ACT_HUNTER_RANGE_ATTACK2_UNPLANTED;

-		}

-	}

-	

-	return BaseClass::NPC_TranslateActivity( baseAct );

-}

-

-

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

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

-void CNPC_Hunter::HandleAnimEvent( animevent_t *pEvent )

-{

-	Vector footPosition;

-	QAngle angles;

-	

-	if ( pEvent->event == AE_HUNTER_FOOTSTEP_LEFT )

-	{

-		LeftFootHit( pEvent->eventtime );

-		return;

-	}

-

-	if ( pEvent->event == AE_HUNTER_FOOTSTEP_RIGHT )

-	{

-		RightFootHit( pEvent->eventtime );

-		return;

-	}

-

-	if ( pEvent->event == AE_HUNTER_FOOTSTEP_BACK )

-	{

-		BackFootHit( pEvent->eventtime );

-		return;

-	}

-	

-	if ( pEvent->event == AE_HUNTER_START_EXPRESSION )

-	{

-		if ( pEvent->options && Q_strlen( pEvent->options ) )

-		{

-			//m_iszCurrentExpression = AllocPooledString( pEvent->options );

-			//SetExpression( pEvent->options );

-		}

-		return;

-	}

-

-	if ( pEvent->event == AE_HUNTER_END_EXPRESSION )

-	{

-		if ( pEvent->options && Q_strlen( pEvent->options ) )

-		{

-			//m_iszCurrentExpression = NULL_STRING;

-			//RemoveActorFromScriptedScenes( this, true, false, pEvent->options );

-		}

-		return;

-	}

-

-	if ( pEvent->event == AE_HUNTER_MELEE_ANNOUNCE )

-	{

-		EmitSound( "NPC_Hunter.MeleeAnnounce" );

-		return;

-	}

-		

-	if ( pEvent->event == AE_HUNTER_MELEE_ATTACK_LEFT )

-	{

-		Vector right, forward, dir;

-		AngleVectors( GetLocalAngles(), &forward, &right, NULL );

-

-		right = right * -100;

-		forward = forward * 600;

-		dir = right + forward;

-		QAngle angle( 25, 30, -20 );

-

-		MeleeAttack( HUNTER_MELEE_REACH, sk_hunter_dmg_one_slash.GetFloat(), angle, dir, HUNTER_BLOOD_LEFT_FOOT );

-		return;

-	}

-

-	if ( pEvent->event == AE_HUNTER_MELEE_ATTACK_RIGHT )

-	{

-		Vector right, forward,dir;

-		AngleVectors( GetLocalAngles(), &forward, &right, NULL );

-

-		right = right * 100;

-		forward = forward * 600;

-		dir = right + forward;

-		

-		QAngle angle( 25, -30, 20 );

-

-		MeleeAttack( HUNTER_MELEE_REACH, sk_hunter_dmg_one_slash.GetFloat(), angle, dir, HUNTER_BLOOD_LEFT_FOOT );

-		return;

-	}

-

-	if ( pEvent->event == AE_HUNTER_SPRAY_BLOOD )

-	{

-		Vector vecOrigin;

-		Vector vecDir;

-	

-		// spray blood from the attachment point

-		bool bGotAttachment = false;

-		if ( pEvent->options )

-		{

-			QAngle angDir;

-			if ( GetAttachment( pEvent->options, vecOrigin, angDir ) )

-			{

-				bGotAttachment = true;

-				AngleVectors( angDir, &vecDir, NULL, NULL );

-			}

-		}

-

-		// fall back to our center, tracing forward

-		if ( !bGotAttachment )

-		{	

-			vecOrigin = WorldSpaceCenter();

-			GetVectors( &vecDir, NULL, NULL );

-		}

-		

-		UTIL_BloodSpray( vecOrigin, vecDir, BLOOD_COLOR_RED, 4, FX_BLOODSPRAY_ALL );

-

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

-		{

-			Vector vecTraceDir = vecDir;

-			vecTraceDir.x += random->RandomFloat( -0.1, 0.1 );

-			vecTraceDir.y += random->RandomFloat( -0.1, 0.1 );

-			vecTraceDir.z += random->RandomFloat( -0.1, 0.1 );

-

-			trace_t tr;

-			AI_TraceLine( vecOrigin, vecOrigin + ( vecTraceDir * 192.0f ), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );

-			if ( tr.fraction != 1.0 )

-			{

-				UTIL_BloodDecalTrace( &tr, BLOOD_COLOR_RED );

-			}

-		}

-

-		return;

-	}

-

-	BaseClass::HandleAnimEvent( pEvent );

-}

-

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

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

-void CNPC_Hunter::AddEntityRelationship( CBaseEntity *pEntity, Disposition_t nDisposition, int nPriority )

-{

-	if ( nDisposition ==  D_HT && pEntity->ClassMatches("npc_bullseye") )

-		UpdateEnemyMemory( pEntity, pEntity->GetAbsOrigin() );

-	BaseClass::AddEntityRelationship( pEntity, nDisposition, nPriority );

-}

-

-

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

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

-bool CNPC_Hunter::ScheduledMoveToGoalEntity( int scheduleType, CBaseEntity *pGoalEntity, Activity movementActivity )

-{

-	if ( IsCurSchedule( SCHED_HUNTER_RANGE_ATTACK1, false ) )

-	{

-		SetGoalEnt( pGoalEntity );

-		return true;

-	}

-	return BaseClass::ScheduledMoveToGoalEntity( scheduleType, pGoalEntity, movementActivity );

-}

-

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

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

-void CNPC_Hunter::OnChangeHintGroup( string_t oldGroup, string_t newGroup )

-{

-	SetCondition( COND_HUNTER_NEW_HINTGROUP );

-	m_CheckHintGroupTimer.Set( 10 );

-}

-

-

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

-// Tells whether any given hunter is in a squad that contains other hunters.

-// This is useful for preventing timid behavior for Hunters that are not 

-// supported by other hunters.

-//

-// NOTE:	This counts the self! So a hunter that is alone in his squad

-//			receives a result of 1.

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

-int CNPC_Hunter::NumHuntersInMySquad()

-{

-	AISquadIter_t iter;

-	CAI_BaseNPC *pSquadmate = m_pSquad ? m_pSquad->GetFirstMember( &iter ) : NULL;

-

-	if( !pSquadmate )

-	{

-		// Not in a squad at all, but the caller is not concerned with that. Just

-		// tell them that we're in a squad of one (ourself)

-		return 1;

-	}

-	

-	int count = 0;

-

-	while ( pSquadmate )

-	{

-		if( pSquadmate->m_iClassname == m_iClassname )

-			count++;

-

-		pSquadmate = m_pSquad->GetNextMember( &iter );

-	}

-

-	return count;

-}

-

-

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

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

-void CNPC_Hunter::FollowStrider( const char *szStrider )

-{

-	if ( !szStrider )

-		return;

-

-	CBaseEntity *pEnt = gEntList.FindEntityByName( NULL, szStrider, this );

-	CNPC_Strider *pStrider = dynamic_cast <CNPC_Strider *>( pEnt );

-	FollowStrider(pStrider);

-}

-

-

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

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

-void CNPC_Hunter::FollowStrider( CNPC_Strider * pStrider )

-{

-	if ( !IsAlive() )

-	{

-		return;

-	}

-

-	if ( pStrider )

-	{

-		if ( m_EscortBehavior.GetFollowTarget() != pStrider )

-		{

-			m_iszFollowTarget = pStrider->GetEntityName();

-			if ( m_iszFollowTarget == NULL_STRING )

-			{

-				m_iszFollowTarget = AllocPooledString( "unnamed_strider" );

-			}

-			m_EscortBehavior.SetEscortTarget( pStrider );

-		}

-	}

-	else

-	{

-		DevWarning("Hunter set to follow entity %s that is not a strider\n", STRING( m_iszFollowTarget ) );

-		m_iszFollowTarget = AllocPooledString( "unknown_strider" );

-	}

-}

-

-void CAI_HunterEscortBehavior::SetEscortTarget( CNPC_Strider *pStrider, bool fFinishCurSchedule )

-{

-	m_bEnabled = true;

-

-	if ( GetOuter()->GetSquad() )

-	{

-		GetOuter()->GetSquad()->RemoveFromSquad( GetOuter() );

-	}

-

-	for ( int i = 0; i < g_Hunters.Count(); i++ )

-	{

-		if ( g_Hunters[i]->m_EscortBehavior.GetFollowTarget() == pStrider )

-		{

-			Assert( g_Hunters[i]->GetSquad() );

-			g_Hunters[i]->GetSquad()->AddToSquad( GetOuter() );

-			break;

-		}

-	}

-

-	if ( !GetOuter()->GetSquad() )

-	{

-		GetOuter()->AddToSquad( AllocPooledString( CFmtStr( "%s_hunter_squad", STRING( pStrider->GetEntityName() ) ) ) );

-	}

-

-	BaseClass::SetFollowTarget( pStrider );

-	m_flTimeEscortReturn = gpGlobals->curtime;

-}

-

-

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

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

-void CNPC_Hunter::InputEnableUnplantedShooting( inputdata_t &inputdata )

-{

-	m_bEnableUnplantedShooting = true;

-}

-

-

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

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

-void CNPC_Hunter::InputDisableUnplantedShooting( inputdata_t &inputdata )

-{

-	m_bEnableUnplantedShooting = false;

-}

-

-

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

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

-void CNPC_Hunter::InputFollowStrider( inputdata_t &inputdata )

-{

-	m_iszFollowTarget = inputdata.value.StringID();

-	if ( m_iszFollowTarget == s_iszStriderClassname )

-	{

-		m_EscortBehavior.m_bEnabled = true;

-		m_iszFollowTarget = NULL_STRING;

-	}

-	m_BeginFollowDelay.Start( .1 ); // Allow time for strider to spawn

-}

-

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

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

-void CNPC_Hunter::InputUseSiegeTargets( inputdata_t &inputdata )

-{

-	m_iszSiegeTargetName = inputdata.value.StringID();

-	m_flTimeNextSiegeTargetAttack = gpGlobals->curtime + random->RandomFloat( 1, hunter_siege_frequency.GetFloat() );

-

-	if( m_iszSiegeTargetName == NULL_STRING )

-	{

-		// Turning the feature off. Restore m_flDistTooFar to default.

-		m_flDistTooFar = hunter_flechette_max_range.GetFloat();

-		m_pSiegeTargets.RemoveAll();

-	}

-	else

-	{

-		// We're going into siege mode. Adjust range accordingly.

-		m_flDistTooFar = hunter_flechette_max_range.GetFloat() * HUNTER_SIEGE_MAX_DIST_MODIFIER;

-	}

-}

-

-

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

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

-void CNPC_Hunter::InputDodge( inputdata_t &inputdata )

-{

-	SetCondition( COND_HUNTER_FORCED_DODGE );

-}

-

-

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

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

-void CNPC_Hunter::InputFlankEnemy( inputdata_t &inputdata )

-{

-	SetCondition( COND_HUNTER_FORCED_FLANK_ENEMY );

-}

-

-

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

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

-void CNPC_Hunter::InputDisableShooting( inputdata_t &inputdata )

-{

-	m_bDisableShooting = true;

-}

-

-

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

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

-void CNPC_Hunter::InputEnableShooting( inputdata_t &inputdata )

-{

-	m_bDisableShooting = false;

-}

-

-

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

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

-void CNPC_Hunter::InputEnableSquadShootDelay( inputdata_t &inputdata )

-{

-	m_bEnableSquadShootDelay = true;

-}

-

-

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

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

-void CNPC_Hunter::InputDisableSquadShootDelay( inputdata_t &inputdata )

-{

-	m_bEnableSquadShootDelay = false;

-}

-

-

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

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

-bool CNPC_Hunter::FVisible( CBaseEntity *pEntity, int traceMask, CBaseEntity **ppBlocker )

-{

-	return BaseClass::FVisible( pEntity, traceMask, ppBlocker );

-}

-

-

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

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

-bool CNPC_Hunter::IsValidEnemy( CBaseEntity *pTarget )

-{

-	if ( IsStriderBuster( pTarget) )

-	{

-		if ( !m_EscortBehavior.m_bEnabled || !m_EscortBehavior.GetEscortTarget() )

-		{

-			// We only hate striderbusters when we are actively protecting a strider.

-			return false;

-		}

-

-		if ( pTarget->VPhysicsGetObject() )

-		{

-			if ( ( pTarget->VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_PLAYER_HELD ) &&

-				hunter_hate_held_striderbusters.GetBool() )

-			{

-				if ( gpGlobals->curtime - StriderBuster_GetPickupTime( pTarget ) > hunter_hate_held_striderbusters_delay.GetFloat())

-				{

-					if ( StriderBuster_NumFlechettesAttached( pTarget ) <= 2 )

-					{

-						if ( m_EscortBehavior.GetEscortTarget() && 

-							( m_EscortBehavior.GetEscortTarget()->GetAbsOrigin().AsVector2D() - pTarget->GetAbsOrigin().AsVector2D() ).LengthSqr() < Square( hunter_hate_held_striderbusters_tolerance.GetFloat() ) )

-						{

-							return true;

-						}

-					}

-				}

-				return false;

-			}

-

-			bool bThrown = ( pTarget->VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_WAS_THROWN ) != 0;

-			bool bAttached = StriderBuster_IsAttachedStriderBuster( pTarget );

-

-			if ( ( bThrown && !bAttached ) && hunter_hate_thrown_striderbusters.GetBool() )

-			{

-				float t;

-				float dist = CalcDistanceSqrToLineSegment2D( m_EscortBehavior.GetEscortTarget()->GetAbsOrigin().AsVector2D(), 

-					pTarget->GetAbsOrigin().AsVector2D(), 

-					pTarget->GetAbsOrigin().AsVector2D() + pTarget->GetSmoothedVelocity().AsVector2D(), &t );

-

-				if ( t > 0 && dist < Square( hunter_hate_thrown_striderbusters_tolerance.GetFloat() ))

-				{

-					return true;

-				}

-				return false;

-			}

-

-			if ( bAttached && StriderBuster_IsAttachedStriderBuster( pTarget, m_EscortBehavior.GetEscortTarget() ) && hunter_hate_attached_striderbusters.GetBool() )

-			{

-				return true;

-			}

-		}

-		return false;

-	}

-

-	return BaseClass::IsValidEnemy( pTarget );

-}

-

-

-

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

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

-Disposition_t CNPC_Hunter::IRelationType( CBaseEntity *pTarget )

-{

-	if ( !pTarget )

-		return D_NU;

-

-	if ( IsStriderBuster( pTarget ) )

-	{

-		if ( HateThisStriderBuster( pTarget ) )

-			return D_HT;

-

-		return D_NU;

-	}

-

-	if ( hunter_retreat_striderbusters.GetBool() )

-	{

-		if ( pTarget->IsPlayer() && (m_hAttachedBusters.Count() > 0) )

-		{

-			return D_FR;

-		}

-	}

-		

-	return BaseClass::IRelationType( pTarget );

-}

-

-

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

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

-int CNPC_Hunter::IRelationPriority( CBaseEntity *pTarget )

-{

-	if ( IsStriderBuster( pTarget ) )

-	{

-		// If we're here, we already know that we hate striderbusters.

-		return 1000.0f;

-	}

-

-	return BaseClass::IRelationPriority( pTarget );

-}

-

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

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

-void CNPC_Hunter::SetSquad( CAI_Squad *pSquad )

-{

-	BaseClass::SetSquad( pSquad );

-	if ( pSquad && pSquad->NumMembers() == 1 )

-	{

-		pSquad->SetSquadData( HUNTER_RUNDOWN_SQUADDATA, 0 );

-	}

-}

-

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

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

-void CNPC_Hunter::OnSeeEntity( CBaseEntity *pEntity )

-{

-	BaseClass::OnSeeEntity(pEntity);

-

-	if ( IsStriderBuster( pEntity ) && IsValidEnemy( pEntity ) )

-	{

-		SetCondition( COND_HUNTER_SEE_STRIDERBUSTER );

-	}

-}

-

-

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

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

-bool CNPC_Hunter::UpdateEnemyMemory( CBaseEntity *pEnemy, const Vector &position, CBaseEntity *pInformer )

-{

-	//EmitSound( "NPC_Hunter.Alert" );

-	return BaseClass::UpdateEnemyMemory( pEnemy, position, pInformer );

-}

-

-

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

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

-bool CNPC_Hunter::CanPlantHere( const Vector &vecPos )

-{

-	// TODO: cache results?

-	//if ( vecPos == m_vecLastCanPlantHerePos )

-	//{

-	//	return m_bLastCanPlantHere;

-	//}

-

-	Vector vecMins = GetHullMins();

-	Vector vecMaxs = GetHullMaxs();

-	

-	vecMins.x -= 16;

-	vecMins.y -= 16;

-

-	vecMaxs.x += 16;

-	vecMaxs.y += 16;

-	vecMaxs.z -= hunter_plant_adjust_z.GetInt();

-	

-	bool bResult = false;

-

-	trace_t tr;

-	UTIL_TraceHull( vecPos, vecPos, vecMins, vecMaxs, MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );

-	if ( tr.startsolid )

-	{

-		// Try again, tracing down from above.

-		Vector vecStart = vecPos;

-		vecStart.z += hunter_plant_adjust_z.GetInt();

-		

-		UTIL_TraceHull( vecStart, vecPos, vecMins, vecMaxs, MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );

-	}

-	

-	if ( tr.startsolid )

-	{

-		//NDebugOverlay::Box( vecPos, vecMins, vecMaxs, 255, 0, 0, 0, 0 );

-	}

-	else

-	{	

-		//NDebugOverlay::Box( vecPos, vecMins, vecMaxs, 0, 255, 0, 0, 0 );

-		bResult = true;

-	}

-

-	// Cache the results in case we ask again for the same spot.	

-	//m_vecLastCanPlantHerePos = vecPos;

-	//m_bLastCanPlantHere = bResult;

-

-	return bResult;

-}

-

-

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

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

-int CNPC_Hunter::MeleeAttack1ConditionsVsEnemyInVehicle( CBaseCombatCharacter *pEnemy, float flDot )

-{

-	if( !IsCorporealEnemy( GetEnemy() ) )

-		return COND_NONE;

-

-	// Try and trace a box to the player, and if I hit the vehicle, attack it

-	Vector vecDelta = (pEnemy->WorldSpaceCenter() - WorldSpaceCenter());

-	VectorNormalize( vecDelta );

-	trace_t	tr;

-	AI_TraceHull( WorldSpaceCenter(), WorldSpaceCenter() + (vecDelta * 64), -Vector(8,8,8), Vector(8,8,8), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );

-	if ( tr.fraction != 1.0 && tr.m_pEnt == pEnemy->GetVehicleEntity() )

-	{

-		// We're near the vehicle. Are we facing it?

-		if (flDot < 0.7)

-			return COND_NOT_FACING_ATTACK;

-

-		return COND_CAN_MELEE_ATTACK1;

-	}

-

-	return COND_TOO_FAR_TO_ATTACK;

-}

-

-

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

-// For innate melee attack

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

-int CNPC_Hunter::MeleeAttack1Conditions ( float flDot, float flDist )

-{

-	if ( !IsCorporealEnemy( GetEnemy() ) )

-		return COND_NONE;

-		

-	if ( ( gpGlobals->curtime < m_flNextMeleeTime ) && // allow berzerk bashing if cornered

-		!( m_hAttachedBusters.Count() > 0 && gpGlobals->curtime < m_fCorneredTimer ) )

-	{

-		return COND_NONE;

-	}

-

-	if ( GetEnemy()->Classify() == CLASS_PLAYER_ALLY_VITAL )

-	{

-		return COND_NONE;

-	}

-		

-	if ( flDist > HUNTER_MELEE_REACH )

-	{

-		// Translate a hit vehicle into its passenger if found

-		if ( GetEnemy() != NULL )

-		{

-			CBaseCombatCharacter *pCCEnemy = GetEnemy()->MyCombatCharacterPointer();

-			if ( pCCEnemy != NULL && pCCEnemy->IsInAVehicle() )

-			{

-				return MeleeAttack1ConditionsVsEnemyInVehicle( pCCEnemy, flDot );

-			}

-

-#if defined(HL2_DLL) && !defined(HL2MP)

-			// If the player is holding an object, knock it down.

-			if ( GetEnemy()->IsPlayer() )

-			{

-				CBasePlayer *pPlayer = ToBasePlayer( GetEnemy() );

-

-				Assert( pPlayer != NULL );

-

-				// Is the player carrying something?

-				CBaseEntity *pObject = GetPlayerHeldEntity(pPlayer);

-

-				if ( !pObject )

-				{

-					pObject = PhysCannonGetHeldEntity( pPlayer->GetActiveWeapon() );

-				}

-

-				if ( pObject )

-				{

-					float flDist = pObject->WorldSpaceCenter().DistTo( WorldSpaceCenter() );

-

-					if ( flDist <= HUNTER_MELEE_REACH )

-					{

-						return COND_CAN_MELEE_ATTACK1;

-					}

-				}

-			}

-#endif

-		}

-	

-		return COND_TOO_FAR_TO_ATTACK;

-	}

-

-	if (flDot < 0.7)

-	{

-		return COND_NOT_FACING_ATTACK;

-	}

-

-	// Build a cube-shaped hull, the same hull that MeleeAttack is going to use.

-	Vector vecMins = GetHullMins();

-	Vector vecMaxs = GetHullMaxs();

-	vecMins.z = vecMins.x;

-	vecMaxs.z = vecMaxs.x;

-

-	Vector forward;

-	GetVectors( &forward, NULL, NULL );

-

-	trace_t	tr;

-	AI_TraceHull( WorldSpaceCenter(), WorldSpaceCenter() + forward * HUNTER_MELEE_REACH, vecMins, vecMaxs, MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );

-

-	if ( tr.fraction == 1.0 || !tr.m_pEnt )

-	{

-		// This attack would miss completely. Trick the hunter into moving around some more.

-		return COND_TOO_FAR_TO_ATTACK;

-	}

-

-	if ( tr.m_pEnt == GetEnemy() || tr.m_pEnt->IsNPC() || (tr.m_pEnt->m_takedamage == DAMAGE_YES && (dynamic_cast<CBreakableProp*>(tr.m_pEnt))) )

-	{

-		// Let the hunter swipe at his enemy if he's going to hit them.

-		// Also let him swipe at NPC's that happen to be between the hunter and the enemy. 

-		// This makes mobs of hunters seem more rowdy since it doesn't leave guys in the back row standing around.

-		// Also let him swipe at things that takedamage, under the assumptions that they can be broken.

-		return COND_CAN_MELEE_ATTACK1;

-	}

-

-	// dvs TODO: incorporate this

-	/*if ( tr.m_pEnt->IsBSPModel() )

-	{

-		// The trace hit something solid, but it's not the enemy. If this item is closer to the hunter than

-		// the enemy is, treat this as an obstruction.

-		Vector vecToEnemy = GetEnemy()->WorldSpaceCenter() - WorldSpaceCenter();

-		Vector vecTrace = tr.endpos - tr.startpos;

-

-		if ( vecTrace.Length2DSqr() < vecToEnemy.Length2DSqr() )

-		{

-			return COND_HUNTER_LOCAL_MELEE_OBSTRUCTION;

-		}

-	}*/

-

-	if ( !tr.m_pEnt->IsWorld() && GetEnemy() && GetEnemy()->GetGroundEntity() == tr.m_pEnt )

-	{

-		// Try to swat whatever the player is standing on instead of acting like a dill.

-		return COND_CAN_MELEE_ATTACK1;

-	}

-

-	// Move around some more

-	return COND_TOO_FAR_TO_ATTACK;

-}

-

-

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

-// For innate melee attack

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

-int CNPC_Hunter::MeleeAttack2Conditions ( float flDot, float flDist )

-{

-	return COND_NONE;

-}

-

-

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

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

-bool CNPC_Hunter::IsCorporealEnemy( CBaseEntity *pEnemy ) 

-{

-	if( !pEnemy )

-		return false;

-

-	// Generally speaking, don't melee attack anything the player can't see.

-	if( pEnemy->IsEffectActive( EF_NODRAW ) )

-		return false;

-

-	// Don't flank, melee attack striderbusters.

-	if ( IsStriderBuster( pEnemy ) )

-		return false;

-

-	return true;

-}

-

-

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

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

-int CNPC_Hunter::RangeAttack1Conditions( float flDot, float flDist )

-{

-	return COND_NONE;

-}

-

-

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

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

-int CNPC_Hunter::RangeAttack2Conditions( float flDot, float flDist )

-{

-	bool bIsBuster = IsStriderBuster( GetEnemy() );

-	bool bIsPerfectBullseye = ( GetEnemy() && dynamic_cast<CNPC_Bullseye *>(GetEnemy()) && ((CNPC_Bullseye *)GetEnemy())->UsePerfectAccuracy() );

-

-	if ( !bIsPerfectBullseye && !bIsBuster && !hunter_flechette_test.GetBool() && ( gpGlobals->curtime < m_flNextRangeAttack2Time ) )

-	{

-		return COND_NONE;

-	}

-

-	if ( m_bDisableShooting )

-	{

-		return COND_NONE;

-	}

-

-	if ( !HasCondition( COND_SEE_ENEMY ) )

-	{

-		return COND_NONE;

-	}

-

-	float flMaxFlechetteRange = hunter_flechette_max_range.GetFloat();

-

-	if ( IsUsingSiegeTargets() )

-	{

-		flMaxFlechetteRange *= HUNTER_SIEGE_MAX_DIST_MODIFIER;

-	}

-

- 	if ( !bIsBuster && ( flDist > flMaxFlechetteRange ) )

-	{

-		return COND_TOO_FAR_TO_ATTACK;

-	}

-	else if ( !bIsBuster && ( !GetEnemy() || !GetEnemy()->ClassMatches( "npc_bullseye" ) ) && flDist < hunter_flechette_min_range.GetFloat() )

-	{

-		return COND_TOO_CLOSE_TO_ATTACK;

-	}

-	else if ( flDot < HUNTER_FACING_DOT )

-	{

-		return COND_NOT_FACING_ATTACK;

-	}

-	

-	if ( !bIsBuster && !m_bEnableUnplantedShooting && !hunter_flechette_test.GetBool() && !CanPlantHere( GetAbsOrigin() ) )

-	{

-		return COND_HUNTER_CANT_PLANT;

-	}

-

-	return COND_CAN_RANGE_ATTACK2;

-}

-

-

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

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

-bool CNPC_Hunter::WeaponLOSCondition(const Vector &ownerPos, const Vector &targetPos, bool bSetConditions)

-{

-	CBaseEntity *pTargetEnt;

-

-	pTargetEnt = GetEnemy();

-

-	trace_t tr;

-	Vector vFrom = ownerPos + GetViewOffset();

-	AI_TraceLine( vFrom, targetPos, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );

-

-	if ( ( pTargetEnt && tr.m_pEnt == pTargetEnt) || tr.fraction == 1.0 || CanShootThrough( tr, targetPos ) )

-	{

-		static Vector vMins( -2.0, -2.0, -2.0 );

-		static Vector vMaxs( -vMins);

-		// Hit the enemy, or hit nothing (traced all the way to a nonsolid enemy like a bullseye)

-		AI_TraceHull( vFrom - Vector( 0, 0, 18 ), targetPos, vMins, vMaxs, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);

-

-		if ( ( pTargetEnt && tr.m_pEnt == pTargetEnt) || tr.fraction == 1.0 || CanShootThrough( tr, targetPos ) )

-		{

-			if ( hunter_show_weapon_los_condition.GetBool() )

-			{

-				NDebugOverlay::Line( vFrom, targetPos, 255, 0, 255, false, 0.1 );

-				NDebugOverlay::Line( vFrom - Vector( 0, 0, 18 ), targetPos, 0, 0, 255, false, 0.1 );

-			}

-			return true;

-		}

-	}

-	else if ( bSetConditions )

-	{

-		SetCondition( COND_WEAPON_SIGHT_OCCLUDED );

-		SetEnemyOccluder( tr.m_pEnt );

-	}

-

-	return false;

-}

-

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

-// Look in front and see if the claw hit anything.

-//

-// Input  :	flDist				distance to trace		

-//			iDamage				damage to do if attack hits

-//			vecViewPunch		camera punch (if attack hits player)

-//			vecVelocityPunch	velocity punch (if attack hits player)

-//

-// Output : The entity hit by claws. NULL if nothing.

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

-CBaseEntity *CNPC_Hunter::MeleeAttack( float flDist, int iDamage, QAngle &qaViewPunch, Vector &vecVelocityPunch, int BloodOrigin  )

-{

-	// Added test because claw attack anim sometimes used when for cases other than melee

-	if ( GetEnemy() )

-	{

-		trace_t	tr;

-		AI_TraceHull( WorldSpaceCenter(), GetEnemy()->WorldSpaceCenter(), -Vector(8,8,8), Vector(8,8,8), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );

-

-		if ( tr.fraction < 1.0f )

-			return NULL;

-	}

-

-	//

-	// Trace out a cubic section of our hull and see what we hit.

-	//

-	Vector vecMins = GetHullMins();

-	Vector vecMaxs = GetHullMaxs();

-	vecMins.z = vecMins.x;

-	vecMaxs.z = vecMaxs.x;

-

-	CBaseEntity *pHurt = CheckTraceHullAttack( flDist, vecMins, vecMaxs, iDamage, DMG_SLASH );

-

-	if ( pHurt )

-	{

-		EmitSound( "NPC_Hunter.MeleeHit" );

-		EmitSound( "NPC_Hunter.TackleHit" );

-

-		CBasePlayer *pPlayer = ToBasePlayer( pHurt );

-

-		if ( pPlayer != NULL && !(pPlayer->GetFlags() & FL_GODMODE ) )

-		{

-			pPlayer->ViewPunch( qaViewPunch );

-			pPlayer->VelocityPunch( vecVelocityPunch );

-			

-			// Shake the screen

-			UTIL_ScreenShake( pPlayer->GetAbsOrigin(), 100.0, 1.5, 1.0, 2, SHAKE_START );

-

-			// Red damage indicator

-			color32 red = { 128, 0, 0, 128 };

-			UTIL_ScreenFade( pPlayer, red, 1.0f, 0.1f, FFADE_IN );

-

-			/*if ( UTIL_ShouldShowBlood( pPlayer->BloodColor() ) )

-			{

-				// Spray some of the player's blood on the hunter.			

-				trace_t tr;

-				

-				Vector vecHunterEyePos; // = EyePosition();

-				QAngle angDiscard;

-				GetBonePosition( LookupBone( "MiniStrider.top_eye_bone" ), vecHunterEyePos, angDiscard );

-

-				Vector vecPlayerEyePos = pPlayer->EyePosition();

-				

-				Vector vecDir = vecHunterEyePos - vecPlayerEyePos;

-				float flLen = VectorNormalize( vecDir );

-				

-				Vector vecStart = vecPlayerEyePos - ( vecDir * 64 );

-				Vector vecEnd = vecPlayerEyePos + ( vecDir * ( flLen + 64 ) );

-				

-				NDebugOverlay::HorzArrow( vecStart, vecEnd, 16, 255, 255, 0, 255, false, 10 );

-				

-				UTIL_TraceLine( vecStart, vecEnd, MASK_SHOT, pPlayer, COLLISION_GROUP_NONE, &tr );

-	

-				if ( tr.m_pEnt )

-				{

-					Msg( "Hit %s!!!\n", tr.m_pEnt->GetDebugName() );

-					UTIL_DecalTrace( &tr, "Blood" );

-				}

-			}*/

-		}

-		else if ( !pPlayer )

-		{

-			if ( IsMovablePhysicsObject( pHurt ) )

-			{

-				// If it's a vphysics object that's too heavy, crash into it too.

-				IPhysicsObject *pPhysics = pHurt->VPhysicsGetObject();

-				if ( pPhysics )

-				{

-					// If the object is being held by the player, break it or make them drop it.

-					if ( pPhysics->GetGameFlags() & FVPHYSICS_PLAYER_HELD )

-					{

-						// If it's breakable, break it.

-						if ( pHurt->m_takedamage == DAMAGE_YES )

-						{

-							CBreakableProp *pBreak = dynamic_cast<CBreakableProp*>(pHurt);

-							if ( pBreak )

-							{

-								CTakeDamageInfo info( this, this, 20, DMG_SLASH );

-								pBreak->Break( this, info );

-							}

-						}

-					}

-				}

-			}		

-		

-			if ( UTIL_ShouldShowBlood(pHurt->BloodColor()) )

-			{

-				// Hit an NPC. Bleed them!

-				Vector vecBloodPos;

-

-				switch ( BloodOrigin )

-				{

-					case HUNTER_BLOOD_LEFT_FOOT:

-					{

-						if ( GetAttachment( "blood_left", vecBloodPos ) )

-						{

-							SpawnBlood( vecBloodPos, g_vecAttackDir, pHurt->BloodColor(), MIN( iDamage, 30 ) );

-						}

-						

-						break;

-					}

-				}

-			}

-		}

-	}

-	else 

-	{

-		// TODO:

-		//AttackMissSound();

-	}

-

-	m_flNextMeleeTime = gpGlobals->curtime + hunter_melee_delay.GetFloat();

-

-	return pHurt;

-}

-

-

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

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

-bool CNPC_Hunter::TestShootPosition(const Vector &vecShootPos, const Vector &targetPos )	

-{ 

-	if ( !CanPlantHere(vecShootPos ) )

-	{

-		return false;

-	}

-

-	return BaseClass::TestShootPosition( vecShootPos, targetPos );

-}

-

-

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

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

-Vector CNPC_Hunter::Weapon_ShootPosition( )

-{

-	matrix3x4_t gunMatrix;

-	GetAttachment( gm_nTopGunAttachment, gunMatrix );

-

-	Vector vecShootPos;

-	MatrixGetColumn( gunMatrix, 3, vecShootPos );

-

-	return vecShootPos;

-}

-

-

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

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

-void CNPC_Hunter::MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType )

-{

-	float flTracerDist;

-	Vector vecDir;

-	Vector vecEndPos;

-

-	vecDir = tr.endpos - vecTracerSrc;

-

-	flTracerDist = VectorNormalize( vecDir );

-

-	int nAttachment = LookupAttachment( "MiniGun" );

-

-	UTIL_Tracer( vecTracerSrc, tr.endpos, nAttachment, TRACER_FLAG_USEATTACHMENT, 5000, true, "HunterTracer" );

-}

-

-

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

-// Trace didn't hit the intended target, but should the hunter

-// shoot anyway? We use this to get the hunter to destroy 

-// breakables that are between him and his target.

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

-bool CNPC_Hunter::CanShootThrough( const trace_t &tr, const Vector &vecTarget )

-{

-	if ( !tr.m_pEnt )

-	{

-		return false;

-	}

-

-	if ( !tr.m_pEnt->GetHealth() )

-	{

-		return false;

-	}

-	

-	// Don't try to shoot through allies.

-	CAI_BaseNPC *pNPC = tr.m_pEnt->MyNPCPointer();

-	if ( pNPC && ( IRelationType( pNPC ) == D_LI ) )

-	{

-		return false;

-	}

-

-	// Would a trace ignoring this entity continue to the target?

-	trace_t continuedTrace;

-	AI_TraceLine( tr.endpos, vecTarget, MASK_SHOT, tr.m_pEnt, COLLISION_GROUP_NONE, &continuedTrace );

-

-	if ( continuedTrace.fraction != 1.0 )

-	{

-		if ( continuedTrace.m_pEnt != GetEnemy() )

-		{

-			return false;

-		}

-	}

-

-	return true;

-}

-

-

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

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

-int CNPC_Hunter::GetSoundInterests()

-{

-	return SOUND_WORLD | SOUND_COMBAT | SOUND_PLAYER | SOUND_DANGER | SOUND_PHYSICS_DANGER | SOUND_PLAYER_VEHICLE | SOUND_BULLET_IMPACT | SOUND_MOVE_AWAY;

-}

-

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

-// Tells us whether the Hunter is acting in a large, outdoor map, 

-// currently only ep2_outland_12. This allows us to create logic

-// branches here in the AI code so that we can make choices that

-// tailor behavior to larger and smaller maps.

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

-bool CNPC_Hunter::IsInLargeOutdoorMap()

-{

-	return m_bInLargeOutdoorMap;

-}

-

-

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

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

-void CNPC_Hunter::AlertSound()

-{

-	EmitSound( "NPC_Hunter.Alert" );

-}

-

-

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

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

-void CNPC_Hunter::PainSound( const CTakeDamageInfo &info )

-{

-	if ( gpGlobals->curtime > m_flNextDamageTime )

-	{

-		EmitSound( "NPC_Hunter.Pain" );

-		m_flNextDamageTime = gpGlobals->curtime + random->RandomFloat( 0.5, 1.2 ); 

-	}

-}

-

-

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

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

-void CNPC_Hunter::DeathSound( const CTakeDamageInfo &info )

-{

-	EmitSound( "NPC_Hunter.Death" );

-}

-

-

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

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

-void CNPC_Hunter::TraceAttack( const CTakeDamageInfo &inputInfo, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )

-{

-	CTakeDamageInfo info = inputInfo;

-

-	// Even though the damage might not hurt us, we want to react to it

-	// if it's from the player.

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

-	{

-		if ( !HasMemory( bits_MEMORY_PROVOKED ) )

-		{

-			GetEnemies()->ClearMemory( info.GetAttacker() );

-			Remember( bits_MEMORY_PROVOKED );

-			SetCondition( COND_LIGHT_DAMAGE );

-		}

-	}

-

-	// HUnters have special resisitance to some types of damage.

-	if ( ( info.GetDamageType() & DMG_BULLET ) ||

-		 ( info.GetDamageType() & DMG_BUCKSHOT ) ||

-		 ( info.GetDamageType() & DMG_CLUB ) ||

-		 ( info.GetDamageType() & DMG_NEVERGIB ) )

-	{

-		float flScale = 1.0;

-		

-		if ( info.GetDamageType() & DMG_BUCKSHOT )

-		{

-			flScale = sk_hunter_buckshot_damage_scale.GetFloat();

-		}

-		else if ( ( info.GetDamageType() & DMG_BULLET ) || ( info.GetDamageType() & DMG_NEVERGIB ) )

-		{

-			// Hunters resist most bullet damage, but they are actually vulnerable to .357 rounds, 

-			// since players regard that weapon as one of the game's truly powerful weapons.

-			if( info.GetAmmoType() == GetAmmoDef()->Index("357") )

-			{

-				flScale = 1.16f;

-			}

-			else

-			{

-				flScale = sk_hunter_bullet_damage_scale.GetFloat();

-			}

-		}

-

-		if ( GetActivity() == ACT_HUNTER_CHARGE_RUN )

-		{

-			flScale *= sk_hunter_charge_damage_scale.GetFloat();

-		}

-		

-		if ( flScale != 0 )

-		{

-			float flDamage = info.GetDamage() * flScale;

-			info.SetDamage( flDamage );

-		}

-		

-		QAngle vecAngles;

-		VectorAngles( ptr->plane.normal, vecAngles );

-		DispatchParticleEffect( "blood_impact_synth_01", ptr->endpos, vecAngles );

-		DispatchParticleEffect( "blood_impact_synth_01_arc_parent", PATTACH_POINT_FOLLOW, this, gm_nHeadCenterAttachment );

-	}

-

-	BaseClass::TraceAttack( info, vecDir, ptr, pAccumulator );

-}

-

-

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

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

-const impactdamagetable_t &CNPC_Hunter::GetPhysicsImpactDamageTable()

-{

-	return s_HunterImpactDamageTable;

-}

-

-

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

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

-void CNPC_Hunter::PhysicsDamageEffect( const Vector &vecPos, const Vector &vecDir )

-{

-	CEffectData data;

-	data.m_vOrigin = vecPos;

-	data.m_vNormal = vecDir;

-	DispatchEffect( "HunterDamage", data );

-

-	if ( random->RandomInt( 0, 1 ) == 0 )

-	{

-		CBaseEntity *pTrail = CreateEntityByName( "sparktrail" );

-		pTrail->SetOwnerEntity( this );

-		pTrail->Spawn();

-	}

-}

-

-

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

-// We were hit by a strider buster. Do the tesla effect on our hitboxes.

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

-void CNPC_Hunter::TeslaThink()

-{

-	CEffectData data;

-	data.m_nEntIndex = entindex();

-	data.m_flMagnitude = 3;

-	data.m_flScale = 0.5f;

-	DispatchEffect( "TeslaHitboxes", data );

-	EmitSound( "RagdollBoogie.Zap" );

-

-	if ( gpGlobals->curtime < m_flTeslaStopTime )

-	{

-		SetContextThink( &CNPC_Hunter::TeslaThink, gpGlobals->curtime + random->RandomFloat( 0.1f, 0.3f ), HUNTER_ZAP_THINK ); 

-	}

-}

-

-

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

-// Our health is low. Show damage effects.

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

-void CNPC_Hunter::BleedThink()

-{

-	// Spurt blood from random points on the hunter's head.

-	Vector vecOrigin;

-	QAngle angDir;

-	GetAttachment( gm_nHeadCenterAttachment, vecOrigin, angDir );

-	

-	Vector vecDir = RandomVector( -1, 1 );

-	VectorNormalize( vecDir );

-	VectorAngles( vecDir, Vector( 0, 0, 1 ), angDir );

-

-	vecDir *= gm_flHeadRadius;

-	DispatchParticleEffect( "blood_spurt_synth_01", vecOrigin + vecDir, angDir );

-

-	SetNextThink( gpGlobals->curtime + random->RandomFloat( 0.6, 1.5 ), HUNTER_BLEED_THINK );

-}

-

-

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

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

-bool CNPC_Hunter::IsHeavyDamage( const CTakeDamageInfo &info )

-{

-	if ( info.GetDamage() < 45 )

-	{

-		return false;

-	}

-

-	if ( info.GetDamage() < 180 )

-	{

-		if ( !m_HeavyDamageDelay.Expired() || !BaseClass::IsHeavyDamage( info ) )

-		{

-			return false;

-		}

-	}

-

-	m_HeavyDamageDelay.Set( 15, 25 );

-	return true;

-

-}

-

-

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

-// We've taken some damage. Maybe we should flinch because of it.

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

-void CNPC_Hunter::ConsiderFlinching( const CTakeDamageInfo &info )

-{

-	if ( !m_FlinchTimer.Expired() )

-	{

-		// Someone is whaling on us. Push out the timer so we don't keep flinching.

-		m_FlinchTimer.Set( random->RandomFloat( 0.3 ) );

-		return;

-	}

-

-	if ( GetState() == NPC_STATE_SCRIPT )

-	{

-		return;

-	}

-

-	Activity eGesture = ACT_HUNTER_FLINCH_N;

-

-	Vector forward;

-	GetVectors( &forward, NULL, NULL );

-	

-	Vector vecForceDir = info.GetDamageForce();

-	VectorNormalize( vecForceDir );

-	

-	float flDot = DotProduct( forward, vecForceDir );

-	

-	if ( flDot > 0.707 )

-	{

-		// flinch forward

-		eGesture = ACT_HUNTER_FLINCH_N;

-	}

-	else if ( flDot < -0.707 )

-	{

-		// flinch back

-		eGesture = ACT_HUNTER_FLINCH_S;

-	}

-	else

-	{

-		// flinch left or right

-		Vector cross = CrossProduct( forward, vecForceDir );

-		

-		if ( cross.z > 0 )

-		{

-			eGesture = ACT_HUNTER_FLINCH_W;

-		}

-		else

-		{

-			eGesture = ACT_HUNTER_FLINCH_E;

-		}

-	}

-

-	if ( !IsPlayingGesture( eGesture ) )

-	{

-		RestartGesture( eGesture );

-		m_FlinchTimer.Set( random->RandomFloat( 0.3, 1.0 ) );

-	}

-}

-

-

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

-// This is done from a think function because when the hunter is killed,

-// the physics code puts the vehicle's pre-collision velocity back so the jostle

-// is basically discared.

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

-void CNPC_Hunter::JostleVehicleThink()

-{

-	CBaseEntity *pInflictor = m_hHitByVehicle;

-	if ( !pInflictor )

-		return;

-

-	Vector vecVelDir = pInflictor->GetSmoothedVelocity();

-	float flSpeed = VectorNormalize( vecVelDir );

-	Vector vecForce = CrossProduct( vecVelDir, Vector( 0, 0, 1 ) );

-	if ( DotProduct( vecForce, GetAbsOrigin() ) < DotProduct( vecForce, pInflictor->GetAbsOrigin() ) )

-	{

-		// We're to the left of the vehicle that's hitting us.

-		vecForce *= -1;

-	}

-

-	VectorNormalize( vecForce );

-	vecForce.z = 1.0;

-

-	float flForceScale = RemapValClamped( flSpeed, hunter_jostle_car_min_speed.GetFloat(), hunter_jostle_car_max_speed.GetFloat(), 50.0f, 150.0f );

-

-	vecForce *= ( flForceScale * pInflictor->VPhysicsGetObject()->GetMass() );

-

-	pInflictor->VPhysicsGetObject()->ApplyForceOffset( vecForce, WorldSpaceCenter() );

-}

-

-

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

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

-int CNPC_Hunter::OnTakeDamage( const CTakeDamageInfo &info )

-{

-	CTakeDamageInfo myInfo = info;

-

-	if ( ( info.GetDamageType() & DMG_CRUSH ) && !( info.GetDamageType() & DMG_VEHICLE ) )

-	{

-		// Don't take damage from physics objects that weren't thrown by the player.

-		CBaseEntity *pInflictor = info.GetInflictor();

-

-		IPhysicsObject *pObj = pInflictor->VPhysicsGetObject();

-		//Assert( pObj );

-

-		if ( !pObj || !pInflictor->HasPhysicsAttacker( 4.0 ) )

-		{

-			myInfo.SetDamage( 0 );

-		}

-		else

-		{

-			// Physics objects that have flechettes stuck in them spoof

-			// a flechette hitting us so we dissolve when killed and award

-			// the achievement of killing a hunter with its flechettes.

-			CUtlVector<CBaseEntity *> children;

-			GetAllChildren( pInflictor, children );

-			for (int i = 0; i < children.Count(); i++ )

-			{

-				CBaseEntity *pent = children.Element( i );

-				if ( dynamic_cast<CHunterFlechette *>( pent ) )

-				{

-					myInfo.SetInflictor( pent );

-					myInfo.SetDamageType( myInfo.GetDamageType() | DMG_DISSOLVE );

-				}

-			}

-		}

-	}

-	

-	return BaseClass::OnTakeDamage( myInfo );

-}

-

-

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

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

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

-{

-	CTakeDamageInfo myInfo = info;

-

-	// don't take damage from my own weapons!!!

-	// Exception: I "own" a magnade if it's glued to me.

-	CBaseEntity *pInflictor = info.GetInflictor();

-	CBaseEntity *pAttacker = info.GetAttacker();

-	if ( pInflictor )

-	{

-		if ( IsStriderBuster( pInflictor ) )

-		{

-			// Get a tesla effect on our hitboxes for a little while.

-			SetContextThink( &CNPC_Hunter::TeslaThink, gpGlobals->curtime, HUNTER_ZAP_THINK ); 

-			m_flTeslaStopTime = gpGlobals->curtime + 2.0f;

-			

-			myInfo.SetDamage( sk_hunter_dmg_from_striderbuster.GetFloat() ) ;

-

-			SetCondition( COND_HUNTER_STAGGERED );

-		}

-		else if ( pInflictor->ClassMatches( GetClassname() ) && !( info.GetDamageType() == DMG_GENERIC ) )

-		{

-			return 0;

-		}

-		else if ( pInflictor->ClassMatches( "hunter_flechette" ) ) 

-		{

-			if ( !( ( CHunterFlechette *)pInflictor )->WasThrownBack() )

-			{

-				// Flechettes only hurt us if they were thrown back at us by the player. This prevents

-				// hunters from hurting themselves when they walk into their own flechette clusters.

-				return 0;

-			}

-		}

-	}

-

-	if ( m_EscortBehavior.GetFollowTarget() && m_EscortBehavior.GetFollowTarget() == pAttacker )

-	{

-		return 0;

-	}

-

-	bool bHitByUnoccupiedCar = false;

-	if ( ( ( info.GetDamageType() & DMG_CRUSH ) && ( pAttacker && pAttacker->IsPlayer() ) ) ||

-		 ( info.GetDamageType() & DMG_VEHICLE ) )

-	{

-		// myInfo, not info! it may have been modified above.

-		float flDamage = myInfo.GetDamage();

-		if ( flDamage < HUNTER_MIN_PHYSICS_DAMAGE )

-		{

-			//DevMsg( "hunter: <<<< ZERO PHYSICS DAMAGE: %f\n", flDamage );

-			myInfo.SetDamage( 0 );

-		}

-		else

-		{

-			CBaseEntity *pInflictor = info.GetInflictor();

-			if ( ( info.GetDamageType() & DMG_VEHICLE ) || 

-				 ( pInflictor && pInflictor->GetServerVehicle() && 

-				   ( ( bHitByUnoccupiedCar = ( dynamic_cast<CPropVehicleDriveable *>(pInflictor) && static_cast<CPropVehicleDriveable *>(pInflictor)->GetDriver() == NULL ) )  == false ) ) )

-			{

-				// Adjust the damage from vehicles.

-				flDamage *= sk_hunter_vehicle_damage_scale.GetFloat();

-				myInfo.SetDamage( flDamage );

-

-				// Apply a force to jostle the vehicle that hit us.

-				// Pick a force direction based on which side we're on relative to the vehicle's motion.

-				Vector vecVelDir = pInflictor->GetSmoothedVelocity();

-				if ( vecVelDir.Length() >= hunter_jostle_car_min_speed.GetFloat() )

-				{

-					EmitSound( "NPC_Hunter.HitByVehicle" );

-					m_hHitByVehicle = pInflictor;

-					SetContextThink( &CNPC_Hunter::JostleVehicleThink, gpGlobals->curtime, HUNTER_JOSTLE_VEHICLE_THINK );

-				}

-			}

-

-			if ( !bHitByUnoccupiedCar )

-			{

-				SetCondition( COND_HUNTER_STAGGERED );

-			}

-		}

-		

-		//DevMsg( "hunter: >>>> PHYSICS DAMAGE: %f (was %f)\n", flDamage, info.GetDamage() );

-	}

-

-	// Show damage effects if we actually took damage.

-	if ( ( myInfo.GetDamageType() & ( DMG_CRUSH | DMG_BLAST ) ) && ( myInfo.GetDamage() > 0 ) )

-	{

-		if ( !bHitByUnoccupiedCar )

-			SetCondition( COND_HUNTER_STAGGERED );

-	}

-	

-	if ( HasCondition( COND_HUNTER_STAGGERED ) )

-	{

-		// Throw a bunch of gibs out

-		Vector vecForceDir = -myInfo.GetDamageForce();

-		VectorNormalize( vecForceDir );

-		PhysicsDamageEffect( myInfo.GetDamagePosition(), vecForceDir );

-

-		// Stagger away from the direction the damage came from.

-		m_vecStaggerDir = myInfo.GetDamageForce();

-		VectorNormalize( m_vecStaggerDir );

-	}

-

-	// Take less damage from citizens and Alyx, otherwise hunters go down too easily.

-	float flScale = 1.0;

-

-	if ( pAttacker &&

-		( ( pAttacker->Classify() == CLASS_CITIZEN_REBEL ) ||

-		  ( pAttacker->Classify() == CLASS_PLAYER_ALLY ) || 

-		  ( pAttacker->Classify() == CLASS_PLAYER_ALLY_VITAL ) ) )

-	{

-		flScale *= sk_hunter_citizen_damage_scale.GetFloat();

-	}

-	

-	if ( flScale != 0 )

-	{

-		// We're taking a nonzero amount of damage.

-

-		// If we're not staggering, consider flinching!

-		if ( !HasCondition( COND_HUNTER_STAGGERED ) )

-		{

-			ConsiderFlinching( info );

-		}

-		

-		if( pAttacker && pAttacker->IsPlayer() )

-		{

-			// This block of code will distract the Hunter back to the player if the 

-			// player does harm to the Hunter but is not the Hunter's current enemy.

-			// This is achieved by updating the Hunter's enemy memory of the player and 

-			// making the Hunter's current enemy invalid for a short time.

-			if( !GetEnemy() || !GetEnemy()->IsPlayer() )

-			{

-				UpdateEnemyMemory( pAttacker, pAttacker->GetAbsOrigin(), this );

-

-				if( GetEnemy() )

-				{

-					// Gotta forget about this person for a little bit.

-					GetEnemies()->SetTimeValidEnemy( GetEnemy(), gpGlobals->curtime + HUNTER_IGNORE_ENEMY_TIME );

-				}

-			}

-		}

-

-		float flDamage = myInfo.GetDamage() * flScale;

-		myInfo.SetDamage( flDamage );

-	}

-

-	int nRet = BaseClass::OnTakeDamage_Alive( myInfo );

-

-	m_EscortBehavior.OnDamage( myInfo );

-

-	// Spark at 30% health.

-	if ( !IsBleeding() && ( GetHealth() <= sk_hunter_health.GetInt() * 0.3 ) )

-	{

-		StartBleeding();

-	}

-	

-	if ( IsUsingSiegeTargets() && info.GetAttacker() != NULL && info.GetAttacker()->IsPlayer() )

-	{

-		// Defend myself. Try to siege attack immediately.

-		m_flTimeNextSiegeTargetAttack = gpGlobals->curtime;

-	}

-	

-	return nRet;

-}

-

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

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

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

-{

-	// Remember the killing blow to make decisions about ragdolling.

-	m_nKillingDamageType = info.GetDamageType();

-

-	if ( m_EscortBehavior.GetFollowTarget() )

-	{

-		if ( AIGetNumFollowers( m_EscortBehavior.GetFollowTarget(), m_iClassname ) == 1 )

-		{

-			m_EscortBehavior.GetEscortTarget()->AlertSound();

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

-			{

-				m_EscortBehavior.GetEscortTarget()->UpdateEnemyMemory( UTIL_GetLocalPlayer(), UTIL_GetLocalPlayer()->GetAbsOrigin(), this );

-			}

-		}

-	}

-	

-	if ( info.GetDamageType() & DMG_VEHICLE )

-	{

-		bool bWasRunDown = false;

-		int iRundownCounter = 0;

-		if ( GetSquad() )

-		{

-			if ( !m_IgnoreVehicleTimer.Expired() )

-			{

-				GetSquad()->GetSquadData( HUNTER_RUNDOWN_SQUADDATA, &iRundownCounter );

-				GetSquad()->SetSquadData( HUNTER_RUNDOWN_SQUADDATA, iRundownCounter + 1 );

-				bWasRunDown = true;

-			}

-		}

-

-		if ( hunter_dodge_debug.GetBool() )

-			Msg( "Hunter %d was%s run down\n", entindex(), ( bWasRunDown ) ? "" : " not" );

-

-		// Death by vehicle! Decrement the hunters to run over counter.

-		// When the counter reaches zero hunters will start dodging.

-		if ( GlobalEntity_GetCounter( s_iszHuntersToRunOver ) > 0 )

-		{

-			GlobalEntity_AddToCounter( s_iszHuntersToRunOver, -1 );

-		}

-	}

-

-	// Stop all our thinks

-	SetContextThink( NULL, 0, HUNTER_BLEED_THINK );

-

-	StopParticleEffects( this );

-

-	BaseClass::Event_Killed( info );

-}

-

-

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

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

-void CNPC_Hunter::StartBleeding()

-{

-	// Do this even if we're already bleeding (see OnRestore).

-	m_bIsBleeding = true;

-

-	// Start gushing blood from our... anus or something.

-	DispatchParticleEffect( "blood_drip_synth_01", PATTACH_POINT_FOLLOW, this, gm_nHeadBottomAttachment );

-

-	// Emit spurts of our blood

-	SetContextThink( &CNPC_Hunter::BleedThink, gpGlobals->curtime + 0.1, HUNTER_BLEED_THINK );

-}

-

-

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

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

-float CNPC_Hunter::MaxYawSpeed()

-{

-	if ( IsStriderBuster( GetEnemy() ) )

-	{

-		return 60;

-	}

-

-	if ( GetActivity() == ACT_HUNTER_ANGRY )

-		return 0;

-

-	if ( GetActivity() == ACT_HUNTER_CHARGE_RUN )

-		return 5;

-

-	if ( GetActivity() == ACT_HUNTER_IDLE_PLANTED )

-		return 0;

-

-	if ( GetActivity() == ACT_HUNTER_RANGE_ATTACK2_UNPLANTED )

-		return 180;

-

-	switch ( GetActivity() )

-	{

-		case ACT_RANGE_ATTACK2:

-		{

-			return 0;

-		}

-		

-		case ACT_90_LEFT:

-		case ACT_90_RIGHT:

-		{

-			return 45;

-		}

-		

-		case ACT_TURN_LEFT:

-		case ACT_TURN_RIGHT:

-		{

-			return 45;

-		}

-		

-		case ACT_WALK:

-		{

-			return 25;

-		}

-		

-		default:

-		{

-			return 35;

-		}

-	}

-}

-

-

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

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

-bool CNPC_Hunter::IsJumpLegal(const Vector &startPos, const Vector &apex, const Vector &endPos) const

-{

-	float MAX_JUMP_RISE		= 220.0f;

-	float MAX_JUMP_DISTANCE	= 512.0f;

-	float MAX_JUMP_DROP		= 384.0f;

-

-	trace_t tr;	

-	UTIL_TraceHull( startPos, startPos, GetHullMins(), GetHullMaxs(), MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );

-	if ( tr.startsolid )

-	{

-		// Trying to start a jump in solid! Consider checking for this in CAI_MoveProbe::JumpMoveLimit.

-		Assert( 0 );

-		return false;

-	}

-

-	if ( BaseClass::IsJumpLegal( startPos, apex, endPos, MAX_JUMP_RISE, MAX_JUMP_DROP, MAX_JUMP_DISTANCE ) )

-	{

-		return true;

-	}

-	return false;

-}

-

-

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

-// Let the probe know I can run through small debris

-// Stolen shamelessly from the Antlion Guard

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

-bool CNPC_Hunter::ShouldProbeCollideAgainstEntity( CBaseEntity *pEntity )

-{

-	if ( s_iszPhysPropClassname != pEntity->m_iClassname )

-		return BaseClass::ShouldProbeCollideAgainstEntity( pEntity );

-

-	if ( pEntity->GetMoveType() == MOVETYPE_VPHYSICS )

-	{

-		IPhysicsObject *pPhysObj = pEntity->VPhysicsGetObject();

-

-		if( pPhysObj && pPhysObj->GetMass() <= 500.0f )

-		{

-			return false;

-		}

-	}

-

-	return BaseClass::ShouldProbeCollideAgainstEntity( pEntity );

-}

-

-

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

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

-void CNPC_Hunter::DoMuzzleFlash( int nAttachment )

-{

-	BaseClass::DoMuzzleFlash();

-	

-	DispatchParticleEffect( "hunter_muzzle_flash", PATTACH_POINT_FOLLOW, this, nAttachment );

-

-	// Dispatch the elight	

-	CEffectData data;

-	data.m_nAttachmentIndex = nAttachment;

-	data.m_nEntIndex = entindex();

-	DispatchEffect( "HunterMuzzleFlash", data );

-}

-

-

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

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

-int CNPC_Hunter::CountRangedAttackers()

-{

-	CBaseEntity *pEnemy = GetEnemy();

-	if ( !pEnemy )

-	{

-		return 0;

-	}

-

-	int nAttackers = 0;

-	for ( int i = 0; i < g_Hunters.Count(); i++ )

-	{

-		CNPC_Hunter *pOtherHunter = g_Hunters[i];

-		if ( pOtherHunter->GetEnemy() == pEnemy )

-		{

-			if ( pOtherHunter->IsCurSchedule( SCHED_HUNTER_RANGE_ATTACK2 ) )

-			{

-				nAttackers++;

-			}

-		}

-	}

-	return nAttackers;

-}

-

-

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

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

-void CNPC_Hunter::DelayRangedAttackers( float minDelay, float maxDelay, bool bForced )

-{

-	float delayMultiplier = ( g_pGameRules->IsSkillLevel( SKILL_EASY ) ) ? 1.25 : 1.0;

-	if ( !m_bEnableSquadShootDelay && !bForced )

-	{

-		m_flNextRangeAttack2Time = gpGlobals->curtime + random->RandomFloat( minDelay, maxDelay ) * delayMultiplier;

-		return;

-	}

-

-	CBaseEntity *pEnemy = GetEnemy();

-	for ( int i = 0; i < g_Hunters.Count(); i++ )

-	{

-		CNPC_Hunter *pOtherHunter = g_Hunters[i];

-		if ( pOtherHunter->GetEnemy() == pEnemy )

-		{

-			float nextTime = gpGlobals->curtime + random->RandomFloat( minDelay, maxDelay ) * delayMultiplier;

-			if ( nextTime > pOtherHunter->m_flNextRangeAttack2Time )

-				pOtherHunter->m_flNextRangeAttack2Time = nextTime;

-		}

-	}

-}

-

-

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

-// Given a target to shoot at, decide where to aim.

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

-void CNPC_Hunter::GetShootDir( Vector &vecDir, const Vector &vecSrc, CBaseEntity *pTargetEntity, bool bStriderBuster, int nShotNum, bool bSingleShot )

-{

-	//RestartGesture( ACT_HUNTER_GESTURE_SHOOT );

-

-	EmitSound( "NPC_Hunter.FlechetteShoot" );

-

-	Vector vecBodyTarget;

-

-	if( pTargetEntity->Classify() == CLASS_PLAYER_ALLY_VITAL )

-	{

-		// Shooting at Alyx, most likely (in EP2). The attack is designed to displace

-		// her, not necessarily actually harm her. So shoot at the area around her feet.

-		vecBodyTarget = pTargetEntity->GetAbsOrigin();

-	}

-	else

-	{

-		vecBodyTarget = pTargetEntity->BodyTarget( vecSrc );

-	}

-

-	Vector vecTarget = vecBodyTarget;

-

-	Vector vecDelta = pTargetEntity->GetAbsOrigin() - GetAbsOrigin();

-	float flDist = vecDelta.Length();

-

-	if ( !bStriderBuster )

-	{

-		// If we're not firing at a strider buster, miss in an entertaining way for the 

-		// first three shots of each volley.

-		if ( ( nShotNum < 3 ) && ( flDist > 200 ) )

-		{

-			Vector vecTargetForward;

-			Vector vecTargetRight;

-			pTargetEntity->GetVectors( &vecTargetForward, &vecTargetRight, NULL );

-

-			Vector vecForward;

-			GetVectors( &vecForward, NULL, NULL );

-

-			float flDot = DotProduct( vecTargetForward, vecForward );

-

-			if ( flDot < -0.8f )

-			{

-				// Our target is facing us, shoot the ground between us.

-				float flPerc = 0.7 + ( 0.1 * nShotNum );

-				vecTarget = GetAbsOrigin() + ( flPerc * ( pTargetEntity->GetAbsOrigin() - GetAbsOrigin() ) );

-			}

-			else if ( flDot > 0.8f )

-			{

-				// Our target is facing away from us, shoot to the left or right.

-				Vector vecMissDir = vecTargetRight;

-				if ( m_bMissLeft )

-				{

-					vecMissDir *= -1.0f;

-				}

-

-				vecTarget = pTargetEntity->EyePosition() +  ( 36.0f * ( 3 - nShotNum ) ) * vecMissDir;

-			}

-			else

-			{

-				// Our target is facing vaguely perpendicular to us, shoot across their view.

-				vecTarget = pTargetEntity->EyePosition() +  ( 36.0f * ( 3 - nShotNum ) ) * vecTargetForward;

-			}

-		}	

-		// If we can't see them, shoot where we last saw them.

-		else if ( !HasCondition( COND_SEE_ENEMY ) )

-		{

-			Vector vecDelta = vecTarget - pTargetEntity->GetAbsOrigin();

-			vecTarget = m_vecEnemyLastSeen + vecDelta;

-		}

-	}

-	else

-	{

-		// If we're firing at a striderbuster, lead it.

-		float flSpeed = hunter_flechette_speed.GetFloat();

-		if ( !flSpeed )

-		{

-			flSpeed = 2500.0f;

-		}

-

-		flSpeed *= 1.5;

-

-		float flDeltaTime = flDist / flSpeed;

-		vecTarget = vecTarget + flDeltaTime * pTargetEntity->GetSmoothedVelocity();

-	}

-

-	vecDir = vecTarget - vecSrc;

-	VectorNormalize( vecDir );

-}

-

-

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

-// Ensures that we don't exceed our pitch/yaw limits when shooting flechettes.

-// Returns true if we had to clamp, false if not.

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

-bool CNPC_Hunter::ClampShootDir( Vector &vecDir )

-{

-	Vector vecDir2D = vecDir;

-	vecDir2D.z = 0;

-	

-	Vector vecForward;

-	GetVectors( &vecForward, NULL, NULL );

-

-	Vector vecForward2D = vecForward;

-	vecForward2D.z = 0;

-	

-	float flDot = DotProduct( vecForward2D, vecDir2D );

-	if ( flDot >= HUNTER_SHOOT_MAX_YAW_COS )

-	{

-		// No need to clamp.

-		return false;		

-	}

-	

-	Vector vecAxis;

-	CrossProduct( vecDir, vecForward, vecAxis );

-	VectorNormalize( vecAxis );

-

-	Quaternion q;

-	AxisAngleQuaternion( vecAxis, -HUNTER_SHOOT_MAX_YAW_DEG, q );

-

-	matrix3x4_t rot;

-	QuaternionMatrix( q, rot );

-	VectorRotate( vecForward, rot, vecDir );

-	VectorNormalize( vecDir );

-	

-	return true;

-}

-

-

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

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

-bool CNPC_Hunter::ShouldSeekTarget( CBaseEntity *pTargetEntity, bool bStriderBuster )

-{

-	bool bSeek = false;

-

-	if ( bStriderBuster )

-	{

-		bool bSeek = false;

-

-		if ( pTargetEntity->VPhysicsGetObject() && ( pTargetEntity->VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_PLAYER_HELD ) )

-		{

-			bSeek = true;

-		}

-		else if ( StriderBuster_NumFlechettesAttached( pTargetEntity ) == 0 )

-		{

-			if ( StriderBuster_IsAttachedStriderBuster(pTargetEntity) )

-			{

-				bSeek = true;

-			}

-			else if ( hunter_seek_thrown_striderbusters_tolerance.GetFloat() > 0.0 )

-			{

-				CNPC_Strider *pEscortTarget = m_EscortBehavior.GetEscortTarget();

-				if ( pEscortTarget && ( pEscortTarget->GetAbsOrigin() - pTargetEntity->GetAbsOrigin() ).LengthSqr() < Square( hunter_seek_thrown_striderbusters_tolerance.GetFloat() ) )

-				{

-					bSeek = true;

-				}

-			}

-		}

-	}

-

-	return bSeek;

-}	

-

-

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

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

-void CNPC_Hunter::BeginVolley( int nNum, float flStartTime )

-{

-	m_nFlechettesQueued = nNum;

-	m_nClampedShots = 0;

-	m_flNextFlechetteTime = flStartTime;

-}

-

-

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

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

-bool CNPC_Hunter::ShootFlechette( CBaseEntity *pTargetEntity, bool bSingleShot )

-{

-	if ( !pTargetEntity )

-	{

-		Assert( false );

-		return false;

-	}

-

-	int nShotNum = hunter_flechette_volley_size.GetInt() - m_nFlechettesQueued;

-

-	bool bStriderBuster = IsStriderBuster( pTargetEntity );

-

-	// Choose the next muzzle to shoot from.

-	Vector vecSrc;

-	QAngle angMuzzle;

-

-	if ( m_bTopMuzzle )

-	{

-		GetAttachment( gm_nTopGunAttachment, vecSrc, angMuzzle );

-		DoMuzzleFlash( gm_nTopGunAttachment );

-	}

-	else

-	{

-		GetAttachment( gm_nBottomGunAttachment, vecSrc, angMuzzle );

-		DoMuzzleFlash( gm_nBottomGunAttachment );

-	}

-

-	m_bTopMuzzle = !m_bTopMuzzle;

-

-	Vector vecDir;

-	GetShootDir( vecDir, vecSrc, pTargetEntity, bStriderBuster, nShotNum, bSingleShot );

-

-	bool bClamped = false;

-	if ( hunter_clamp_shots.GetBool() )

-	{

-		bClamped = ClampShootDir( vecDir );

-	}

-

-	CShotManipulator manipulator( vecDir );

-	Vector vecShoot;

-

-	if( IsUsingSiegeTargets() && nShotNum >= 2 && (nShotNum % 2) == 0 )

-	{

-		// Near perfect accuracy for these three shots, so they are likely to fly right into the windows.

-		// NOTE! In siege behavior in the map that this behavior was designed for (ep2_outland_10), the

-		// Hunters will only ever shoot at siege targets in siege mode. If you allow Hunters in siege mode

-		// to attack players or other NPCs, this accuracy bonus will apply unless we apply a bit more logic to it.

-		vecShoot = manipulator.ApplySpread( VECTOR_CONE_1DEGREES * 0.5, 1.0f );

-	}

-	else

-	{

-		vecShoot = manipulator.ApplySpread( VECTOR_CONE_4DEGREES, 1.0f );

-	}

-

-	QAngle angShoot;

-	VectorAngles( vecShoot, angShoot );

-

-	CHunterFlechette *pFlechette = CHunterFlechette::FlechetteCreate( vecSrc, angShoot, this );

-

-	pFlechette->AddEffects( EF_NOSHADOW );

-

-	vecShoot *= hunter_flechette_speed.GetFloat();

-

-	pFlechette->Shoot( vecShoot, bStriderBuster );

-

-	if ( ShouldSeekTarget( pTargetEntity, bStriderBuster ) )

-	{

-		pFlechette->SetSeekTarget( pTargetEntity );

-	}

-

-	if( nShotNum == 1 && pTargetEntity->Classify() == CLASS_PLAYER_ALLY_VITAL )

-	{

-		// Make this person afraid and react to ME, not to the flechettes. 

-		// Otherwise they could be scared into running towards the hunter.

-		CSoundEnt::InsertSound( SOUND_DANGER|SOUND_CONTEXT_REACT_TO_SOURCE|SOUND_CONTEXT_EXCLUDE_COMBINE, pTargetEntity->EyePosition(), 180.0f, 2.0f, this );

-	}

-

-	return bClamped;

-}

-

-

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

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

-Vector CNPC_Hunter::LeftFootHit( float eventtime )

-{

-	Vector footPosition;

-

-	GetAttachment( "left foot", footPosition );

-	CPASAttenuationFilter filter( this );

-	EmitSound( filter, entindex(), "NPC_Hunter.Footstep", &footPosition, eventtime );

-

-	FootFX( footPosition );

-

-	return footPosition;

-}

-

-

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

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

-Vector CNPC_Hunter::RightFootHit( float eventtime )

-{

-	Vector footPosition;

-

-	GetAttachment( "right foot", footPosition );

-	CPASAttenuationFilter filter( this );

-	EmitSound( filter, entindex(), "NPC_Hunter.Footstep", &footPosition, eventtime );

-	FootFX( footPosition );

-

-	return footPosition;

-}

-

-

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

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

-Vector CNPC_Hunter::BackFootHit( float eventtime )

-{

-	Vector footPosition;

-

-	GetAttachment( "back foot", footPosition );

-	CPASAttenuationFilter filter( this );

-	EmitSound( filter, entindex(), "NPC_Hunter.BackFootstep", &footPosition, eventtime );

-	FootFX( footPosition );

-

-	return footPosition;

-}

-

-

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

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

-void CNPC_Hunter::FootFX( const Vector &origin )

-{

-	return;

-

-	// dvs TODO: foot dust? probably too expensive for these guys

-	/*trace_t tr;

-	AI_TraceLine( origin, origin - Vector(0,0,100), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );

-	float yaw = random->RandomInt(0,120);

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

-	{

-		Vector dir = UTIL_YawToVector( yaw + i*120 ) * 10;

-		VectorNormalize( dir );

-		dir.z = 0.25;

-		VectorNormalize( dir );

-		g_pEffects->Dust( tr.endpos, dir, 12, 50 );

-	}*/

-}

-

-

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

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

-CBaseEntity *CNPC_Hunter::GetEnemyVehicle()

-{

-	if ( GetEnemy() == NULL )

-		return NULL;

-

-	CBaseCombatCharacter *pCCEnemy = GetEnemy()->MyCombatCharacterPointer();

-	if ( pCCEnemy != NULL )

-		return pCCEnemy->GetVehicleEntity();

-

-	return NULL;

-}

-

-

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

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

-void CNPC_Hunter::DrawDebugGeometryOverlays()

-{

-	if (m_debugOverlays & OVERLAY_BBOX_BIT) 

-	{	

-		float flViewRange	= acos(0.8);

-		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;

-

-		int nSeq = GetSequence();

-		if ( ( GetEntryNode( nSeq ) == gm_nPlantedNode ) && ( GetExitNode( nSeq ) == gm_nPlantedNode ) )

-		{

-			// planted - green

-			NDebugOverlay::Box( GetAbsOrigin(), GetHullMins(), GetHullMaxs(), 0, 255, 0, 128, 0 );

-		}

-		else if ( ( GetEntryNode( nSeq ) == gm_nUnplantedNode ) && ( GetExitNode( nSeq ) == gm_nUnplantedNode ) )

-		{

-			// unplanted - blue

-			NDebugOverlay::Box( GetAbsOrigin(), GetHullMins(), GetHullMaxs(), 0, 0, 255, 128, 0 );

-		}

-		else if ( ( GetEntryNode( nSeq ) == gm_nUnplantedNode ) && ( GetExitNode( nSeq ) == gm_nPlantedNode ) )

-		{

-			// planting transition - cyan

-			NDebugOverlay::Box( GetAbsOrigin(), GetHullMins(), GetHullMaxs(), 0, 255, 255, 128, 0 );

-		}

-		else if ( ( GetEntryNode( nSeq ) == gm_nPlantedNode ) && ( GetExitNode( nSeq ) == gm_nUnplantedNode ) ) 

-		{

-			// unplanting transition - purple

-			NDebugOverlay::Box( GetAbsOrigin(), GetHullMins(), GetHullMaxs(), 255, 0, 255, 128, 0 );

-		}

-		else

-		{

-			// unknown / other node - red

-			Msg( "UNKNOWN: %s\n", GetSequenceName( GetSequence() ) );

-			NDebugOverlay::Box( GetAbsOrigin(), GetHullMins(), GetHullMaxs(), 255, 0, 0, 128, 0 );

-		}

-

-		NDebugOverlay::BoxDirection(EyePosition(), Vector(0,0,-1), Vector(200,0,1), vLeftDir, 255, 0, 0, 50, 0 );

-		NDebugOverlay::BoxDirection(EyePosition(), Vector(0,0,-1), Vector(200,0,1), vRightDir, 255, 0, 0, 50, 0 );

-		NDebugOverlay::BoxDirection(EyePosition(), Vector(0,0,-1), Vector(200,0,1), vEyeDir, 0, 255, 0, 50, 0 );

-		NDebugOverlay::Box(EyePosition(), -Vector(2,2,2), Vector(2,2,2), 0, 255, 0, 128, 0 );

-	}	

-	

-	m_EscortBehavior.DrawDebugGeometryOverlays();

-	

-	BaseClass::DrawDebugGeometryOverlays();

-}

-

-

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

-// Player has illuminated this NPC with the flashlight

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

-void CNPC_Hunter::PlayerHasIlluminatedNPC( CBasePlayer *pPlayer, float flDot )

-{

-	if ( m_bFlashlightInEyes )

-		return;

-

-	// Ignore the flashlight if it's not shining at my eyes

-	if ( PlayerFlashlightOnMyEyes( pPlayer ) )

-	{

-		//Msg( ">>>> SHINING FLASHLIGHT ON ME\n" );

-		m_bFlashlightInEyes = true;

-		SetExpression( "scenes/npc/hunter/hunter_eyeclose.vcd" );

-		m_flPupilDilateTime = gpGlobals->curtime + 0.2f;

-	}

-}

-

-

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

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

-bool CNPC_Hunter::PlayerFlashlightOnMyEyes( CBasePlayer *pPlayer )

-{

-	Vector vecEyes, vecEyeForward, vecPlayerForward;

- 	GetAttachment( gm_nTopGunAttachment, vecEyes, &vecEyeForward );

- 	pPlayer->EyeVectors( &vecPlayerForward );

-

-	Vector vecToEyes = (vecEyes - pPlayer->EyePosition());

-	//float flDist = VectorNormalize( vecToEyes ); 

-

-	float flDot = DotProduct( vecPlayerForward, vecToEyes );

-	if ( flDot < 0.98 )

-		return false;

-

-	// Check facing to ensure we're in front of her

- 	Vector los = ( pPlayer->EyePosition() - EyePosition() );

-	los.z = 0;

-	VectorNormalize( los );

-	Vector facingDir = EyeDirection2D();

- 	flDot = DotProduct( los, facingDir );

-	return ( flDot > 0.3 );

-}

-

-

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

-// Return a random expression for the specified state to play over 

-// the state's expression loop.

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

-const char *CNPC_Hunter::SelectRandomExpressionForState( NPC_STATE state )

-{

-	if ( m_bFlashlightInEyes )

-		return NULL;

-		

-	if ( !hunter_random_expressions.GetBool() )

-		return NULL;

-

-	char *szExpressions[4] =

-	{

-		"scenes/npc/hunter/hunter_scan.vcd",

-		"scenes/npc/hunter/hunter_eyeclose.vcd",

-		"scenes/npc/hunter/hunter_roar.vcd",

-		"scenes/npc/hunter/hunter_pain.vcd"

-	};

-	

-	int nIndex = random->RandomInt( 0, 3 );

-	//Msg( "RANDOM Expression: %s\n", szExpressions[nIndex] );

-	return szExpressions[nIndex];

-}

-

-

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

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

-void CNPC_Hunter::PlayExpressionForState( NPC_STATE state )

-{

-	if ( m_bFlashlightInEyes )

-	{

-		return;

-	}

-

-	BaseClass::PlayExpressionForState( state );

-}

-

-

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

-// TODO: remove if we're not doing striderbuster stuff

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

-void CNPC_Hunter::StriderBusterAttached( CBaseEntity *pAttached )

-{

-	// Add another to the list

-	m_hAttachedBusters.AddToTail( pAttached );

-

-	SetCondition( COND_HUNTER_HIT_BY_STICKYBOMB );

-	if (m_hAttachedBusters.Count() == 1)

-	{

-		EmitSound( "NPC_Hunter.Alert" );

-	}

-}

-

-

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

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

-void CNPC_Hunter::StriderBusterDetached( CBaseEntity *pAttached )

-{

-	int elem = m_hAttachedBusters.Find(pAttached);

-	if (elem >= 0)

-	{

-		m_hAttachedBusters.FastRemove(elem);

-	}

-}

-

-

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

-// Set direction that the hunter aims his body and eyes (guns).

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

-void CNPC_Hunter::SetAim( const Vector &aimDir, float flInterval )

-{

-	QAngle angDir;

-	VectorAngles( aimDir, angDir );

-	float curPitch = GetPoseParameter( gm_nBodyPitchPoseParam );

-	float curYaw = GetPoseParameter( gm_nBodyYawPoseParam );

-

-	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 );

-		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 );

-

-	//Msg( "pitch=%f, yaw=%f\n", newPitch, newYaw );

-

-	SetPoseParameter( gm_nAimPitchPoseParam, 0 );

-	SetPoseParameter( gm_nAimYawPoseParam, 0 );

-

-	SetPoseParameter( gm_nBodyPitchPoseParam, clamp( newPitch, -45, 45 ) );

-	SetPoseParameter( gm_nBodyYawPoseParam, clamp( newYaw, -45, 45 ) );

-}

-

-

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

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

-void CNPC_Hunter::RelaxAim( float flInterval )

-{

-	float curPitch = GetPoseParameter( gm_nBodyPitchPoseParam );

-	float curYaw = GetPoseParameter( gm_nBodyYawPoseParam );

-

-	// dampen existing aim

-	float newPitch = AngleNormalize( UTIL_ApproachAngle( 0, curPitch, 3 ) );

-	float newYaw = AngleNormalize( UTIL_ApproachAngle( 0, curYaw, 2 ) );

-

-	SetPoseParameter( gm_nAimPitchPoseParam, 0 );

-	SetPoseParameter( gm_nAimYawPoseParam, 0 );

-

-	SetPoseParameter( gm_nBodyPitchPoseParam, clamp( newPitch, -45, 45 ) );

-	SetPoseParameter( gm_nBodyYawPoseParam, clamp( newYaw, -45, 45 ) );

-}

-

-

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

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

-void CNPC_Hunter::UpdateAim()

-{

-	if ( !GetModelPtr() || !GetModelPtr()->SequencesAvailable() )

-		return;

-		

-	float flInterval = GetAnimTimeInterval();

-

-	// Some activities look bad if we're giving our enemy the stinkeye.

-	int eActivity = GetActivity();

-

-	if ( GetEnemy() &&

-		 GetState() != NPC_STATE_SCRIPT && 

-		 ( eActivity != ACT_HUNTER_CHARGE_CRASH ) &&

-		 ( eActivity != ACT_HUNTER_CHARGE_HIT ) )

-	{

-		Vector vecShootOrigin;

-

-		vecShootOrigin = Weapon_ShootPosition();

-		Vector vecShootDir = GetShootEnemyDir( vecShootOrigin, false );

-

-		SetAim( vecShootDir, flInterval );

-	}

-	else

-	{

-		RelaxAim( flInterval );

-	}

-}

-

-

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

-// Don't become a ragdoll until we've finished our death anim

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

-bool CNPC_Hunter::CanBecomeRagdoll()

-{

-	return ( m_nKillingDamageType & DMG_CRUSH ) ||

-		IsCurSchedule( SCHED_DIE, false ) ||								// Finished playing death anim, time to ragdoll

-		IsCurSchedule( SCHED_HUNTER_CHARGE_ENEMY, false ) ||				// While moving, it looks better to ragdoll instantly

-		IsCurSchedule( SCHED_SCRIPTED_RUN, false ) ||

-		( GetActivity() == ACT_WALK ) || ( GetActivity() == ACT_RUN ) ||

-		GetCurSchedule() == NULL;											// Failsafe

-}

-

-

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

-// Determines the best type of death anim to play based on how we died.

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

-Activity CNPC_Hunter::GetDeathActivity()

-{

-	return ACT_DIESIMPLE;

-}

-

-

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

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

-void CAI_HunterEscortBehavior::OnDamage( const CTakeDamageInfo &info )

-{

-	if ( info.GetDamage() > 0 && info.GetAttacker()->IsPlayer() &&

-		GetFollowTarget() && ( AIGetNumFollowers( GetFollowTarget() ) > 1 ) &&

-		( GetOuter()->GetSquad()->GetSquadSoundWaitTime() <= gpGlobals->curtime ) ) // && !FarFromFollowTarget()

-	{

-		// Start the clock ticking. We'll return the the strider when the timer elapses.

-		m_flTimeEscortReturn = gpGlobals->curtime + random->RandomFloat( 15.0f, 25.0f );

-		GetOuter()->GetSquad()->SetSquadSoundWaitTime( m_flTimeEscortReturn + 1.0 ); // prevent others from breaking escort

-	}

-}

-

-

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

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

-void CAI_HunterEscortBehavior::BuildScheduleTestBits()

-{

-	BaseClass::BuildScheduleTestBits();

-

-	if ( ( m_flTimeEscortReturn != 0 ) && ( gpGlobals->curtime > m_flTimeEscortReturn ) )

-	{

-		// We're delinquent! Return to strider!

-		GetOuter()->ClearCustomInterruptCondition( COND_NEW_ENEMY );

-		GetOuter()->ClearCustomInterruptCondition( COND_SEE_ENEMY );

-		GetOuter()->ClearCustomInterruptCondition( COND_SEE_HATE );

-		GetOuter()->ClearCustomInterruptCondition( COND_CAN_RANGE_ATTACK1 );

-		GetOuter()->ClearCustomInterruptCondition( COND_CAN_RANGE_ATTACK2 );

-	}

-}

-

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

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

-void CAI_HunterEscortBehavior::CheckBreakEscort()

-{

-	if ( m_flTimeEscortReturn != 0 && ( FarFromFollowTarget() || gpGlobals->curtime >= m_flTimeEscortReturn ) )

-	{

-		if ( FarFromFollowTarget() )

-		{

-			m_flTimeEscortReturn = gpGlobals->curtime;

-		}

-		else

-		{

-			m_flTimeEscortReturn = 0;

-		}

-		if ( GetOuter()->GetSquad() )

-		{

-			GetOuter()->GetSquad()->SetSquadSoundWaitTime( gpGlobals->curtime + random->RandomFloat( 5.0f, 12.0f ) );

-		}

-	}

-}

-

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

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

-void CAI_HunterEscortBehavior::GatherConditionsNotActive( void )

-{

-	if ( m_bEnabled )

-	{

-		DistributeFreeHunters();

-	}

-

-	BaseClass::GatherConditionsNotActive();

-}

-

-

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

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

-void CAI_HunterEscortBehavior::GatherConditions( void )

-{

-	m_bEnabled = true;

-

-	DistributeFreeHunters();

-

-	BaseClass::GatherConditions();

-

-	if ( GetEnemy() && GetEnemy()->IsPlayer() && HasCondition( COND_SEE_ENEMY ) )

-	{

-		if ( GetOuter()->GetSquad()->GetSquadSoundWaitTime() <= gpGlobals->curtime && ((CBasePlayer *)GetEnemy())->IsInAVehicle() )

-		{

-			m_flTimeEscortReturn = gpGlobals->curtime + random->RandomFloat( 15.0f, 25.0f );

-			GetOuter()->GetSquad()->SetSquadSoundWaitTime( m_flTimeEscortReturn + 1.0 ); // prevent others from breaking escort

-		}

-	}

-}

-

-	

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

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

-bool CAI_HunterEscortBehavior::ShouldFollow()

-{

-	if ( IsStriderBuster( GetEnemy() ) )

-		return false;

-

-	if ( HasCondition( COND_HEAR_PHYSICS_DANGER ) )

-		return false;

-

-	if ( m_flTimeEscortReturn <= gpGlobals->curtime )

-	{

-		return CAI_FollowBehavior::ShouldFollow();

-	}

-

-	return false;

-}

-

-

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

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

-void CAI_HunterEscortBehavior::BeginScheduleSelection()

-{

-	BaseClass::BeginScheduleSelection();

-	Assert( m_SavedDistTooFar == GetOuter()->m_flDistTooFar );

-	GetOuter()->m_flDistTooFar *= 2;

-}	

-

-

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

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

-int CAI_HunterEscortBehavior::SelectSchedule()

-{

-	if( m_FollowDelay.IsRunning() && !m_FollowDelay.Expired() )

-	{

-		return FollowCallBaseSelectSchedule();

-	}

-	return BaseClass::SelectSchedule();

-}

-

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

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

-int CAI_HunterEscortBehavior::FollowCallBaseSelectSchedule() 

-{

-	if ( GetOuter()->GetState() == NPC_STATE_COMBAT )

-	{

-		return GetOuter()->SelectCombatSchedule();

-	}

-

-	return BaseClass::FollowCallBaseSelectSchedule(); 

-}

-

-

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

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

-void CAI_HunterEscortBehavior::StartTask( const Task_t *pTask )

-{

-	switch( pTask->iTask )

-	{

-	case TASK_MOVE_TO_FOLLOW_POSITION:

-		{

-			if ( GetEnemy() )

-			{

-				if ( GetOuter()->OccupyStrategySlot( SQUAD_SLOT_RUN_SHOOT ) )

-				{

-					if ( GetOuter()->GetSquad()->GetSquadMemberNearestTo( GetEnemy()->GetAbsOrigin() ) == GetOuter() )

-					{

-						GetOuter()->BeginVolley( NUM_FLECHETTE_VOLLEY_ON_FOLLOW, gpGlobals->curtime + 1.0 + random->RandomFloat( 0, .25 ) + random->RandomFloat( 0, .25 ) );

-					}

-					else

-					{

-						GetOuter()->VacateStrategySlot();

-					}

-				}

-			}

-			BaseClass::StartTask( pTask );

-			break;

-		}

-

-	default:

-		BaseClass::StartTask( pTask );

-	}

-}

-

-

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

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

-void CAI_HunterEscortBehavior::RunTask( const Task_t *pTask )

-{

-	switch( pTask->iTask )

-	{

-	case TASK_MOVE_TO_FOLLOW_POSITION:

-		{

-			if ( !GetFollowTarget() )

-			{

-				TaskFail( FAIL_NO_TARGET );

-			}

-			else

-			{

-				if ( GetEnemy() )

-				{

-					CNPC_Hunter *pHunter = GetOuter();

-					Vector vecEnemyLKP = pHunter->GetEnemyLKP();

-					pHunter->AddFacingTarget( pHunter->GetEnemy(), vecEnemyLKP, 1.0, 0.8 );

-					bool bVacate = false;

-

-					bool bHasSlot = pHunter->HasStrategySlot( SQUAD_SLOT_RUN_SHOOT );

-					if ( HasCondition( COND_SEE_ENEMY ) )

-					{

-						float maxDist = hunter_flechette_max_range.GetFloat() * 3;

-						float distSq = ( pHunter->GetAbsOrigin() - pHunter->GetEnemy()->GetAbsOrigin() ).Length2DSqr();

-

-						if ( distSq < Square( maxDist ) )

-						{

-							if ( gpGlobals->curtime >= pHunter->m_flNextFlechetteTime )

-							{

-								if ( !bHasSlot )

-								{

-									if ( GetOuter()->OccupyStrategySlot( SQUAD_SLOT_RUN_SHOOT ) )

-									{

-										if ( GetOuter()->GetSquad()->GetSquadMemberNearestTo( GetEnemy()->GetAbsOrigin() ) == GetOuter() )

-										{

-											bHasSlot = true;

-										}

-										else

-										{

-											GetOuter()->VacateStrategySlot();

-										}

-									}

-								}

-

-								if ( bHasSlot )

-								{

-									// Start the firing sound.

-									//CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();

-									//if ( controller.SoundGetVolume( pHunter->m_pGunFiringSound ) == 0.0f )

-									//{

-									//	controller.SoundChangeVolume( pHunter->m_pGunFiringSound, 1.0f, 0.0f );

-									//}

-									

-									pHunter->ShootFlechette( GetEnemy(), true );

-

-									if ( --pHunter->m_nFlechettesQueued > 0 )

-									{

-										pHunter->m_flNextFlechetteTime = gpGlobals->curtime + hunter_flechette_delay.GetFloat();

-									}

-									else

-									{

-										// Stop the firing sound.

-										//CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();

-										//controller.SoundChangeVolume( pHunter->m_pGunFiringSound, 0, 0.01f );

-

-										bVacate = true;

-										pHunter->BeginVolley( NUM_FLECHETTE_VOLLEY_ON_FOLLOW, gpGlobals->curtime + 1.0 + random->RandomFloat( 0, .25 ) + random->RandomFloat( 0, .25 ) );

-									}

-								}

-							}

-						}

-						else if ( bHasSlot )

-						{

-							bVacate = true;

-						}

-					}

-					else if ( bHasSlot )

-					{

-						bVacate = true;

-					}

-

-					if ( bVacate )

-					{

-						pHunter->VacateStrategySlot();

-					}

-				}

-

-				if ( m_FollowAttackTimer.Expired() && IsFollowTargetInRange( .8 )) 

-				{

-					m_FollowAttackTimer.Set( 8, 24 );

-					TaskComplete();

-				}

-				else

-				{

-					BaseClass::RunTask( pTask );

-				}

-			}

-			break;

-		}

-

-	default:

-		BaseClass::RunTask( pTask );

-	}

-}

-

-

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

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

-void CAI_HunterEscortBehavior::FindFreeHunters( CUtlVector<CNPC_Hunter *> *pFreeHunters )

-{

-	pFreeHunters->EnsureCapacity( g_Hunters.Count() );

-	int i;

-

-	for ( i = 0; i < g_Hunters.Count(); i++ )

-	{

-		CNPC_Hunter *pHunter = g_Hunters[i];

-		if ( pHunter->IsAlive() && pHunter->m_EscortBehavior.m_bEnabled )

-		{

-			if ( pHunter->m_EscortBehavior.GetFollowTarget() == NULL || !pHunter->m_EscortBehavior.GetFollowTarget()->IsAlive() )

-			{

-				pFreeHunters->AddToTail( pHunter);

-			}

-		}

-	}

-}

-

-

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

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

-void CAI_HunterEscortBehavior::DistributeFreeHunters()

-{

-	if ( g_TimeLastDistributeFreeHunters != -1 && gpGlobals->curtime - g_TimeLastDistributeFreeHunters < FREE_HUNTER_DISTRIBUTE_INTERVAL )

-	{

-		return;

-	}

-

-	g_TimeLastDistributeFreeHunters = gpGlobals->curtime;

-

-	CUtlVector<CNPC_Hunter *> freeHunters;

-	int i;

-	FindFreeHunters( &freeHunters );

-

-	CAI_BaseNPC **ppNPCs = g_AI_Manager.AccessAIs();

-	for ( i = 0; i < g_AI_Manager.NumAIs() && freeHunters.Count(); i++ )

-	{

-		int nToAdd;

-		CNPC_Strider *pStrider = ( ppNPCs[i]->IsAlive() ) ? dynamic_cast<CNPC_Strider *>( ppNPCs[i] ) : NULL;

-		if ( pStrider && !pStrider->CarriedByDropship() )

-		{

-			if ( ( nToAdd = 3 - AIGetNumFollowers( pStrider ) ) > 0 )

-			{

-				for ( int j = freeHunters.Count() - 1; j >= 0 && nToAdd > 0; --j )

-				{

-					DevMsg( "npc_hunter %d assigned to npc_strider %d\n", freeHunters[j]->entindex(), pStrider->entindex() );

-					freeHunters[j]->FollowStrider( pStrider );

-					freeHunters.FastRemove( j );

-					nToAdd--;

-				}

-			}

-		}

-	}

-

-	for ( i = 0; i < freeHunters.Count(); i++ )

-	{

-		//DevMsg( "npc_hunter %d assigned to free_hunters_squad\n", freeHunters[i]->entindex() );

-		freeHunters[i]->m_EscortBehavior.SetFollowTarget( NULL );

-		freeHunters[i]->AddToSquad( AllocPooledString( "free_hunters_squad" ) );

-	}

-

-#if 0

-	CBaseEntity *pHunterMaker = gEntList.FindEntityByClassname( NULL, "npc_hunter_maker" ); // TODO: this picks the same one every time!

-	if ( pHunterMaker )

-	{

-		for ( i = 0; i < freeHunters.Count(); i++ )

-		{

-			freeHunters[i]->m_EscortBehavior.SetFollowTarget( pHunterMaker );

-		}

-	}

-#endif

-}

-

-

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

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

-void CAI_HunterEscortBehavior::DrawDebugGeometryOverlays()

-{

-	if ( !GetFollowTarget() )

-		return;

-

-	Vector vecFollowPos = GetGoalPosition();

-	if ( FarFromFollowTarget() )

-	{

-		if ( gpGlobals->curtime >= m_flTimeEscortReturn )

-		{

-			NDebugOverlay::HorzArrow( GetOuter()->GetAbsOrigin(), vecFollowPos, 16.0f, 255, 0, 0, 0, true, 0 );

-		}

-		else

-		{

-			NDebugOverlay::HorzArrow( GetOuter()->GetAbsOrigin(), vecFollowPos, 16.0f, 255, 255, 0, 0, true, 0 );

-		}

-	}

-	else

-	{

-		NDebugOverlay::HorzArrow( GetOuter()->GetAbsOrigin(), vecFollowPos, 16.0f, 0, 255, 0, 0, true, 0 );

-	}

-}

-

-

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

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

-bool Hunter_IsHunter(CBaseEntity *pEnt)

-{

-	return dynamic_cast<CNPC_Hunter *>(pEnt) != NULL;

-}

-

-

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

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

-void Hunter_StriderBusterLaunched( CBaseEntity *pBuster )

-{

-	CAI_BaseNPC **ppAIs = g_AI_Manager.AccessAIs();

-	int nAIs = g_AI_Manager.NumAIs();

-

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

-	{

-		CAI_BaseNPC *pNPC = ppAIs[ i ];

-		if ( pNPC && ( pNPC->Classify() == CLASS_COMBINE_HUNTER ) && pNPC->m_lifeState == LIFE_ALIVE )

-		{

-			if ( !pNPC->GetEnemy() || !IsStriderBuster( pNPC->GetEnemy() ) )

-			{

-				Vector vecDelta = pNPC->GetAbsOrigin() - pBuster->GetAbsOrigin();

-				if ( vecDelta.Length2DSqr() < 9437184.0f ) // 3072 * 3072

-				{

-					pNPC->SetEnemy( pBuster );

-					pNPC->SetState( NPC_STATE_COMBAT );

-					pNPC->UpdateEnemyMemory( pBuster, pBuster->GetAbsOrigin() );

-

-					// Stop whatever we're doing.

-					pNPC->SetCondition( COND_SCHEDULE_DONE );

-				}

-			}

-		}

-	}

-}

-

-

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

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

-void Hunter_StriderBusterAttached( CBaseEntity *pHunter, CBaseEntity *pAttached )

-{

-	Assert(dynamic_cast<CNPC_Hunter *>(pHunter));

-

-	static_cast<CNPC_Hunter *>(pHunter)->StriderBusterAttached(pAttached);

-}

-

-

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

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

-void Hunter_StriderBusterDetached( CBaseEntity *pHunter, CBaseEntity *pAttached )

-{

-	Assert(dynamic_cast<CNPC_Hunter *>(pHunter));

-

-	static_cast<CNPC_Hunter *>(pHunter)->StriderBusterDetached(pAttached);

-}

-

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

-//

-// ep2_outland_12 custom npc makers

-//

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

-

-class CHunterMaker : public CTemplateNPCMaker

-{

-	typedef CTemplateNPCMaker BaseClass;

-public:

-	void MakeMultipleNPCS( int nNPCs )

-	{

-		const float MIN_HEALTH_PCT = 0.2;

-

-		CUtlVector<CNPC_Hunter *> candidates;

-		CUtlVectorFixed<CNPC_Hunter *, 3> freeHunters;

-		CAI_HunterEscortBehavior::FindFreeHunters( &candidates );

-

-		freeHunters.EnsureCapacity( 3 );

-		int i;

-

-		for ( i = 0; i < candidates.Count() && freeHunters.Count() < 3; i++ )

-		{

-			if ( candidates[i]->GetHealth() > candidates[i]->GetMaxHealth() * MIN_HEALTH_PCT )

-			{

-				freeHunters.AddToTail( candidates[i] );

-			}

-		}

-

-		int nRequested = nNPCs;

-		if ( nNPCs < 3 )

-		{

-			nNPCs = MIN( 3, nNPCs + freeHunters.Count() );

-		}

-

-		int nSummoned = 0;

-		for ( i = 0; i < freeHunters.Count() && nNPCs; i++ )

-		{

-			freeHunters[i]->m_EscortBehavior.SetFollowTarget( this ); // this will make them not "free"

-			freeHunters[i]->SetName( m_iszTemplateName ); // this will force the hunter to get the FollowStrider input

-			nNPCs--;

-			nSummoned++;

-		}

-

-		DevMsg( "Requested %d to spawn, Summoning %d free hunters, spawning %d new hunters\n", nRequested, nSummoned, nNPCs );

-		if ( nNPCs )

-		{

-			BaseClass::MakeMultipleNPCS( nNPCs );

-		}

-	}

-};

-

-LINK_ENTITY_TO_CLASS( npc_hunter_maker, CHunterMaker );

-

-

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

-//

-// Schedules

-//

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

-AI_BEGIN_CUSTOM_NPC( npc_hunter, CNPC_Hunter )

-

-	DECLARE_TASK( TASK_HUNTER_AIM )

-	DECLARE_TASK( TASK_HUNTER_FIND_DODGE_POSITION )

-	DECLARE_TASK( TASK_HUNTER_DODGE )

-	DECLARE_TASK( TASK_HUNTER_PRE_RANGE_ATTACK2 )

-	DECLARE_TASK( TASK_HUNTER_SHOOT_COMMIT )

-	DECLARE_TASK( TASK_HUNTER_ANNOUNCE_FLANK )

-	DECLARE_TASK( TASK_HUNTER_BEGIN_FLANK )

-	DECLARE_TASK( TASK_HUNTER_STAGGER )

-	DECLARE_TASK( TASK_HUNTER_CORNERED_TIMER )

-	DECLARE_TASK( TASK_HUNTER_FIND_SIDESTEP_POSITION )

-	DECLARE_TASK( TASK_HUNTER_CHARGE )

-	DECLARE_TASK( TASK_HUNTER_FINISH_RANGE_ATTACK )

-	DECLARE_TASK( TASK_HUNTER_WAIT_FOR_MOVEMENT_FACING_ENEMY )

-	DECLARE_TASK( TASK_HUNTER_CHARGE_DELAY )

-

-	DECLARE_ACTIVITY( ACT_HUNTER_DEPLOYRA2 )

-	DECLARE_ACTIVITY( ACT_HUNTER_DODGER )

-	DECLARE_ACTIVITY( ACT_HUNTER_DODGEL )

-	DECLARE_ACTIVITY( ACT_HUNTER_GESTURE_SHOOT )

-	DECLARE_ACTIVITY( ACT_HUNTER_FLINCH_STICKYBOMB )

-	DECLARE_ACTIVITY( ACT_HUNTER_STAGGER )

-	DECLARE_ACTIVITY( ACT_DI_HUNTER_MELEE )

-	DECLARE_ACTIVITY( ACT_DI_HUNTER_THROW )

-	DECLARE_ACTIVITY( ACT_HUNTER_MELEE_ATTACK1_VS_PLAYER )

-	DECLARE_ACTIVITY( ACT_HUNTER_ANGRY )

-	DECLARE_ACTIVITY( ACT_HUNTER_WALK_ANGRY )

-	DECLARE_ACTIVITY( ACT_HUNTER_FOUND_ENEMY )

-	DECLARE_ACTIVITY( ACT_HUNTER_FOUND_ENEMY_ACK )

-	DECLARE_ACTIVITY( ACT_HUNTER_CHARGE_START )

-	DECLARE_ACTIVITY( ACT_HUNTER_CHARGE_RUN )

-	DECLARE_ACTIVITY( ACT_HUNTER_CHARGE_STOP )

-	DECLARE_ACTIVITY( ACT_HUNTER_CHARGE_CRASH )

-	DECLARE_ACTIVITY( ACT_HUNTER_CHARGE_HIT )

-	DECLARE_ACTIVITY( ACT_HUNTER_RANGE_ATTACK2_UNPLANTED )

-	DECLARE_ACTIVITY( ACT_HUNTER_IDLE_PLANTED )

-	DECLARE_ACTIVITY( ACT_HUNTER_FLINCH_N )

-	DECLARE_ACTIVITY( ACT_HUNTER_FLINCH_S )

-	DECLARE_ACTIVITY( ACT_HUNTER_FLINCH_E )

-	DECLARE_ACTIVITY( ACT_HUNTER_FLINCH_W )

-

-	DECLARE_INTERACTION( g_interactionHunterFoundEnemy );

-

-	DECLARE_SQUADSLOT( SQUAD_SLOT_HUNTER_CHARGE )

-	DECLARE_SQUADSLOT( SQUAD_SLOT_HUNTER_FLANK_FIRST )

-	DECLARE_SQUADSLOT( SQUAD_SLOT_RUN_SHOOT )

-

-	DECLARE_CONDITION( COND_HUNTER_SHOULD_PATROL )

-	DECLARE_CONDITION( COND_HUNTER_FORCED_FLANK_ENEMY )

-	DECLARE_CONDITION( COND_HUNTER_CAN_CHARGE_ENEMY )

-	DECLARE_CONDITION( COND_HUNTER_STAGGERED )

-	DECLARE_CONDITION( COND_HUNTER_IS_INDOORS )

-	DECLARE_CONDITION( COND_HUNTER_HIT_BY_STICKYBOMB )

-	DECLARE_CONDITION( COND_HUNTER_SEE_STRIDERBUSTER )

-	DECLARE_CONDITION( COND_HUNTER_FORCED_DODGE )

-	DECLARE_CONDITION( COND_HUNTER_INCOMING_VEHICLE )

-	DECLARE_CONDITION( COND_HUNTER_NEW_HINTGROUP )

-	DECLARE_CONDITION( COND_HUNTER_CANT_PLANT )

-	DECLARE_CONDITION( COND_HUNTER_SQUADMATE_FOUND_ENEMY )

-	

-	DECLARE_ANIMEVENT( AE_HUNTER_FOOTSTEP_LEFT )

-	DECLARE_ANIMEVENT( AE_HUNTER_FOOTSTEP_RIGHT )

-	DECLARE_ANIMEVENT( AE_HUNTER_FOOTSTEP_BACK )

-	DECLARE_ANIMEVENT( AE_HUNTER_MELEE_ANNOUNCE )

-	DECLARE_ANIMEVENT( AE_HUNTER_MELEE_ATTACK_LEFT )

-	DECLARE_ANIMEVENT( AE_HUNTER_MELEE_ATTACK_RIGHT )

-	DECLARE_ANIMEVENT( AE_HUNTER_DIE )

-	DECLARE_ANIMEVENT( AE_HUNTER_SPRAY_BLOOD )

-	DECLARE_ANIMEVENT( AE_HUNTER_START_EXPRESSION )

-	DECLARE_ANIMEVENT( AE_HUNTER_END_EXPRESSION )

-

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

-	// Attack (Deploy/shoot/finish)

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_RANGE_ATTACK1,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING					0"

-		"		TASK_HUNTER_SHOOT_COMMIT			0"

-		"		TASK_RANGE_ATTACK1					0"

-		"	"

-		"	Interrupts"

-		"		COND_NEW_ENEMY"

-		"		COND_ENEMY_DEAD"

-		"		COND_LOST_ENEMY"

-		"		COND_ENEMY_OCCLUDED"

-		"		COND_WEAPON_SIGHT_OCCLUDED"

-		"		COND_TOO_CLOSE_TO_ATTACK"

-		"		COND_TOO_FAR_TO_ATTACK"

-		"		COND_NOT_FACING_ATTACK"

-	)

-

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

-	// Attack (Deploy/shoot/finish)

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_RANGE_ATTACK2,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING				0"

-		"		TASK_HUNTER_PRE_RANGE_ATTACK2	0"

-		"		TASK_HUNTER_SHOOT_COMMIT		0"

-		"		TASK_RANGE_ATTACK2				0"

-		"		TASK_HUNTER_FINISH_RANGE_ATTACK	0"

-		"		TASK_SET_ACTIVITY				ACTIVITY:ACT_IDLE"

-		"		TASK_WAIT        				0.4"

-		"		TASK_WAIT_RANDOM				0.2"

-		"	"

-		"	Interrupts"

-		"		COND_NEW_ENEMY"

-	)

-

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

-	// Shoot at striderbuster. Distinct from generic range attack

-	// because of BuildScheduleTestBits.

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_RANGE_ATTACK2_VS_STRIDERBUSTER,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING				0"

-		"		TASK_HUNTER_SHOOT_COMMIT		0"

-		"		TASK_RANGE_ATTACK2				0"

-		"	"

-		"	Interrupts"

-	)

-

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

-	// Shoot at striderbuster with a little latency beforehand

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_RANGE_ATTACK2_VS_STRIDERBUSTER_LATENT,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING				0"

-		"		TASK_HUNTER_SHOOT_COMMIT		0"

-		"		TASK_WAIT						0.2"

-		"		TASK_PLAY_SEQUENCE_FACE_ENEMY	ACTIVITY:ACT_RANGE_ATTACK2"

-		"		TASK_RANGE_ATTACK2				0"

-		"	"

-		"	Interrupts"

-	)

-

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

-	// Dodge Incoming vehicle

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_DODGE,

-

-		"	Tasks"

-		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_HUNTER_FAIL_DODGE"

-		"		TASK_HUNTER_FIND_DODGE_POSITION			0"

-		"		TASK_HUNTER_DODGE						0"

-		""

-		"	Interrupts"

-	)

-

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

-	// Dodge Incoming vehicle

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_FAIL_DODGE,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING		0"

-		"		TASK_SET_ACTIVITY		ACTIVITY:ACT_IDLE"

-		"		TASK_FACE_ENEMY			0"

-		""

-		"	Interrupts"

-	)

-

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

-	// > SCHED_HUNTER_CHARGE_ENEMY

-	// Rush at my enemy and head-butt them.

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_CHARGE_ENEMY,

-

-		"	Tasks"

-		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_HUNTER_FAIL_CHARGE_ENEMY"

-		"		TASK_STOP_MOVING				0"

-		"		TASK_FACE_ENEMY					0"

-		"		TASK_HUNTER_CHARGE				0"

-		""

-		"	Interrupts"

-		"		COND_TASK_FAILED"

-		"		COND_ENEMY_DEAD"

-	)

-

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_FAIL_CHARGE_ENEMY,

-

-		"	Tasks"

-		"		TASK_HUNTER_CHARGE_DELAY		10"

-	)

-

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

-	// Chase the enemy with intent to claw

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_CHASE_ENEMY_MELEE,

-

-		"	Tasks"

-		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_ESTABLISH_LINE_OF_FIRE"

-		"		TASK_STOP_MOVING				0"

-		"		TASK_GET_CHASE_PATH_TO_ENEMY	300"

-		"		TASK_RUN_PATH					0"

-		"		TASK_WAIT_FOR_MOVEMENT			0"

-		"		TASK_FACE_ENEMY					0"

-		""

-		"	Interrupts"

-		"		COND_NEW_ENEMY"

-		"		COND_ENEMY_DEAD"

-		"		COND_ENEMY_UNREACHABLE"

-		"		COND_CAN_MELEE_ATTACK1"

-		"		COND_CAN_MELEE_ATTACK2"

-		//"		COND_TOO_CLOSE_TO_ATTACK"

-		"		COND_LOST_ENEMY"

-	)

-

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

-	// Chase my enemy, shoot or claw when possible to do so.

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_CHASE_ENEMY,

-

-		"	Tasks"

-		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_ESTABLISH_LINE_OF_FIRE"

-		"		TASK_STOP_MOVING				0"

-		"		TASK_GET_CHASE_PATH_TO_ENEMY	300"

-		"		TASK_RUN_PATH					0"

-		"		TASK_WAIT_FOR_MOVEMENT			0"

-		"		TASK_FACE_ENEMY					0"

-		""

-		"	Interrupts"

-		"		COND_NEW_ENEMY"

-		"		COND_ENEMY_DEAD"

-		"		COND_ENEMY_UNREACHABLE"

-		"		COND_CAN_RANGE_ATTACK1"

-		"		COND_CAN_RANGE_ATTACK2"

-		"		COND_CAN_MELEE_ATTACK1"

-		"		COND_CAN_MELEE_ATTACK2"

-		"		COND_TOO_CLOSE_TO_ATTACK"

-		"		COND_LOST_ENEMY"

-	)

-

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

-	// Move to a flanking position, then shoot if possible.

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_FLANK_ENEMY,

-

-		"	Tasks"

-		"		TASK_SET_FAIL_SCHEDULE					SCHEDULE:SCHED_ESTABLISH_LINE_OF_FIRE"

-		"		TASK_STOP_MOVING						0"

-		"		TASK_HUNTER_BEGIN_FLANK					0"

-		"		TASK_GET_FLANK_ARC_PATH_TO_ENEMY_LOS	30"

-		"		TASK_HUNTER_ANNOUNCE_FLANK				0"

-		"		TASK_RUN_PATH							0"

-		"		TASK_WAIT_FOR_MOVEMENT					0"

-		"		TASK_FACE_ENEMY							0"

-		//"		TASK_HUNTER_END_FLANK					0"

-		""

-		"	Interrupts"

-		"		COND_NEW_ENEMY"

-		//"		COND_CAN_RANGE_ATTACK1"

-		//"		COND_CAN_RANGE_ATTACK2"

-		"		COND_CAN_MELEE_ATTACK1"

-		"		COND_CAN_MELEE_ATTACK2"

-		"		COND_ENEMY_DEAD"

-		"		COND_ENEMY_UNREACHABLE"

-		"		COND_TOO_CLOSE_TO_ATTACK"

-		"		COND_LOST_ENEMY"

-	)

-

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

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_COMBAT_FACE,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING		0"

-		"		TASK_SET_ACTIVITY		ACTIVITY:ACT_IDLE"

-		"		TASK_WAIT_FACE_ENEMY	1"

-		""

-		"	Interrupts"

-		"		COND_CAN_RANGE_ATTACK1"

-		"		COND_CAN_RANGE_ATTACK2"

-		"		COND_CAN_MELEE_ATTACK1"

-		"		COND_CAN_MELEE_ATTACK2"

-		"		COND_NEW_ENEMY"

-		"		COND_ENEMY_DEAD"

-	)

-	

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

-	// Like the base class, only don't stop in the middle of 

-	// swinging if the enemy is killed, hides, or new enemy.

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_MELEE_ATTACK1,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING		0"

-		"		TASK_FACE_ENEMY			0"

-		"		TASK_MELEE_ATTACK1		0"

-		//"		TASK_SET_SCHEDULE		SCHEDULE:SCHED_HUNTER_POST_MELEE_WAIT"

-		""

-		"	Interrupts"

-	)

-

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

-	// In a fight with nothing to do. Make busy!

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

-	DEFINE_SCHEDULE	

-	(

-		SCHED_HUNTER_CHANGE_POSITION,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING				0"

-		"		TASK_WANDER						720432" // 6 feet to 36 feet

-		"		TASK_RUN_PATH					0"

-		"		TASK_HUNTER_WAIT_FOR_MOVEMENT_FACING_ENEMY	0"

-		"		TASK_STOP_MOVING				0"

-		"		TASK_SET_SCHEDULE				SCHEDULE:SCHED_HUNTER_CHANGE_POSITION_FINISH"

-		""

-		"	Interrupts"

-		"		COND_ENEMY_DEAD"

-		"		COND_CAN_MELEE_ATTACK1"

-		"		COND_CAN_MELEE_ATTACK2"

-		"		COND_HEAR_DANGER"

-		"		COND_HEAR_MOVE_AWAY"

-		"		COND_NEW_ENEMY"

-	)

-

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

-	// In a fight with nothing to do. Make busy!

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

-	DEFINE_SCHEDULE	

-	(

-		SCHED_HUNTER_CHANGE_POSITION_FINISH,

-

-		"	Tasks"

-		"		TASK_FACE_ENEMY					0"

-		"		TASK_WAIT_FACE_ENEMY_RANDOM		5"

-		""

-		"	Interrupts"

-		"		COND_ENEMY_DEAD"

-		"		COND_CAN_RANGE_ATTACK1"

-		"		COND_CAN_RANGE_ATTACK2"

-		"		COND_CAN_MELEE_ATTACK1"

-		"		COND_CAN_MELEE_ATTACK2"

-		"		COND_HEAR_DANGER"

-		"		COND_HEAR_MOVE_AWAY"

-		"		COND_NEW_ENEMY"

-	)

-

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

-	// In a fight with nothing to do. Make busy!

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

-	DEFINE_SCHEDULE	

-	(

-		SCHED_HUNTER_SIDESTEP,

-

-		"	Tasks"

-		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_HUNTER_FAIL_IMMEDIATE" // used because sched_fail includes a one second pause. ick!

-		"		TASK_STOP_MOVING						0"

-		"		TASK_HUNTER_FIND_SIDESTEP_POSITION		0"

-		"		TASK_GET_PATH_TO_SAVEPOSITION			0"

-		"		TASK_RUN_PATH							0"

-		"		TASK_WAIT_FOR_MOVEMENT					0"

-		"		TASK_FACE_ENEMY							0"

-		""

-		"	Interrupts"

-	)

-

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

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

-	DEFINE_SCHEDULE	

-	(

-		SCHED_HUNTER_PATROL,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING				0"

-		"		TASK_WANDER						720432" // 6 feet to 36 feet

-		"		TASK_WALK_PATH					0"

-		"		TASK_WAIT_FOR_MOVEMENT			0"

-		"		TASK_STOP_MOVING				0"

-		"		TASK_FACE_REASONABLE			0"

-		"		TASK_WAIT_RANDOM				3"

-		""

-		"	Interrupts"

-		"		COND_ENEMY_DEAD"

-		"		COND_LIGHT_DAMAGE"

-		"		COND_HEAVY_DAMAGE"

-		"		COND_HEAR_DANGER"

-		"		COND_HEAR_COMBAT"

-		"		COND_HEAR_PLAYER"

-		"		COND_HEAR_BULLET_IMPACT"

-		"		COND_HEAR_MOVE_AWAY"

-		"		COND_NEW_ENEMY"

-		"		COND_SEE_ENEMY"

-		"		COND_CAN_RANGE_ATTACK1"

-		"		COND_CAN_RANGE_ATTACK2"

-		"		COND_CAN_MELEE_ATTACK1"

-		"		COND_CAN_MELEE_ATTACK2"

-	)

-

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

-	// Stagger because I got hit by something heavy

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_STAGGER,

-

-		"	Tasks"

-		"		TASK_HUNTER_STAGGER			0"

-		""

-		"	Interrupts"

-	)

-

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

-	// Run around randomly until we detect an enemy

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_PATROL_RUN,

-

-		"	Tasks"

-		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_COMBAT_FACE"

-		"		TASK_SET_ROUTE_SEARCH_TIME		5"	// Spend 5 seconds trying to build a path if stuck

-		"		TASK_GET_PATH_TO_RANDOM_NODE	200"

-		"		TASK_RUN_PATH					0"

-		"		TASK_WAIT_FOR_MOVEMENT			0"

-		""

-		"	Interrupts"

-		"		COND_CAN_RANGE_ATTACK1 "

-		"		COND_CAN_RANGE_ATTACK2 "

-		"		COND_CAN_MELEE_ATTACK1 "

-		"		COND_CAN_MELEE_ATTACK2"

-		"		COND_GIVE_WAY"

-		"		COND_NEW_ENEMY"

-		"		COND_HEAR_COMBAT"

-		"		COND_HEAR_DANGER"

-		"		COND_HEAR_PLAYER"

-		"		COND_LIGHT_DAMAGE"

-		"		COND_HEAVY_DAMAGE"

-	)

-

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

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_TAKE_COVER_FROM_ENEMY,

-

-		"	Tasks"

-		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_HUNTER_CHASE_ENEMY_MELEE"

-		"		TASK_HUNTER_CORNERED_TIMER		10.0"

-		"		TASK_WAIT						0.0"

-	//	"		TASK_SET_TOLERANCE_DISTANCE		24"

-	//	"		TASK_FIND_COVER_FROM_ENEMY		0"

-		"		TASK_FIND_FAR_NODE_COVER_FROM_ENEMY 200.0"

-		"		TASK_RUN_PATH					0"

-		"		TASK_HUNTER_CORNERED_TIMER		0.0"

-	//	"		TASK_CLEAR_FAIL_SCHEDULE		0" // not used because sched_fail includes a one second pause. ick!

-		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_HUNTER_FAIL_IMMEDIATE"

-		"		TASK_WAIT_FOR_MOVEMENT			0"

-		"		TASK_REMEMBER					MEMORY:INCOVER"

-		"		TASK_SET_SCHEDULE				SCHEDULE:SCHED_HUNTER_HIDE_UNDER_COVER"

-		/*

-		"		TASK_FACE_ENEMY					0"

-		"		TASK_SET_ACTIVITY				ACTIVITY:ACT_IDLE"	// Translated to cover

-		"		TASK_WAIT						1"

-		*/

-		""

-		"	Interrupts"

-		"		COND_NEW_ENEMY"

-		"		COND_HEAR_DANGER"

-	)

-

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

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_HIDE_UNDER_COVER,

-

-		"	Tasks"

-		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_HUNTER_FAIL_IMMEDIATE" // used because sched_fail includes a one second pause. ick!

-		"		TASK_FACE_ENEMY					0"

-		"		TASK_SET_ACTIVITY				ACTIVITY:ACT_IDLE"	// Translated to cover

-		"		TASK_WAIT						1"

-		""

-		"	Interrupts"

-		"		COND_NEW_ENEMY"

-		"		COND_HEAR_DANGER"

-		"		COND_HAVE_ENEMY_LOS"

-	)

-	

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

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_FOUND_ENEMY,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING				0"

-		"		TASK_FACE_ENEMY					0"

-		"		TASK_PLAY_SEQUENCE_FACE_ENEMY	ACTIVITY:ACT_HUNTER_FOUND_ENEMY"

-		""

-		"	Interrupts"

-		"		COND_LIGHT_DAMAGE"

-		"		COND_HEAVY_DAMAGE"

-	)

-	

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

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_FOUND_ENEMY_ACK,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING				0"

-		"		TASK_WAIT_RANDOM				0.75"

-		"		TASK_FACE_ENEMY					0"

-		"		TASK_PLAY_SEQUENCE_FACE_ENEMY	ACTIVITY:ACT_HUNTER_FOUND_ENEMY_ACK"

-		""

-		"	Interrupts"

-		"		COND_LIGHT_DAMAGE"

-		"		COND_HEAVY_DAMAGE"

-	)

-	

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

-	// An empty schedule that immediately bails out, faster than

-	// SCHED_FAIL which stops moving and waits for one second.

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_FAIL_IMMEDIATE,

-

-		"	Tasks"

-		"		TASK_WAIT			0"

-

-	)

-

-	DEFINE_SCHEDULE

-	( 

-		SCHED_HUNTER_GOTO_HINT,

-		"	Tasks"

-		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_HUNTER_CLEAR_HINTNODE" // used because sched_fail includes a one second pause. ick!

-		"		TASK_GET_PATH_TO_HINTNODE		1"

-		"		TASK_WAIT_FOR_MOVEMENT			0"

-		"		TASK_CLEAR_HINTNODE				0"

-		""

-		""

-		"	Interrupts"

-	)

-

-	DEFINE_SCHEDULE

-	( 

-		SCHED_HUNTER_CLEAR_HINTNODE,

-		"	Tasks"

-		"		TASK_CLEAR_HINTNODE				0"

-		""

-		""

-		"	Interrupts"

-	)

-

-	DEFINE_SCHEDULE

-	(

-		SCHED_HUNTER_SIEGE_STAND,

-		"	Tasks"

-		"		TASK_STOP_MOVING				0"

-		"		TASK_SET_ACTIVITY				ACTIVITY:ACT_IDLE"

-		"		TASK_FACE_PLAYER				0"

-		"		TASK_WAIT						10"

-		"		TASK_WAIT_RANDOM				2"

-		"		TASK_SET_SCHEDULE				SCHEDULE:SCHED_HUNTER_CHANGE_POSITION_SIEGE"

-		""

-		""

-		"	Interrupts"

-		"		COND_SEE_PLAYER"

-		"		COND_NEW_ENEMY"

-	)

-

-	DEFINE_SCHEDULE	

-	(

-		SCHED_HUNTER_CHANGE_POSITION_SIEGE,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING				0"

-		"		TASK_WANDER						2400480"

-		"		TASK_RUN_PATH					0"

-		"		TASK_WAIT_FOR_MOVEMENT			0"

-		"		TASK_STOP_MOVING				0"

-		"		TASK_SET_ACTIVITY				ACTIVITY:ACT_IDLE"

-		"		TASK_FACE_PLAYER				0"

-		""

-		"	Interrupts"

-		"		COND_NEW_ENEMY"

-	)

-

-	// formula is MIN_DIST * 10000 + MAX_DIST

-

-AI_END_CUSTOM_NPC()

+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Small, fast version of the strider. Goes where striders cannot, such
+// as into buildings. Best killed with physics objects and explosives.
+//
+//=============================================================================
+
+#include "cbase.h"
+#include "npc_strider.h"
+#include "npc_hunter.h"
+#include "ai_behavior_follow.h"
+#include "ai_moveprobe.h"
+#include "ai_senses.h"
+#include "ai_speech.h"
+#include "ai_task.h"
+#include "ai_default.h"
+#include "ai_schedule.h"
+#include "ai_hull.h"
+#include "ai_baseactor.h"
+#include "ai_waypoint.h"
+#include "ai_link.h"
+#include "ai_hint.h"
+#include "ai_squadslot.h"
+#include "ai_squad.h"
+#include "ai_tacticalservices.h"
+#include "beam_shared.h"
+#include "datacache/imdlcache.h"
+#include "eventqueue.h"
+#include "gib.h"
+#include "globalstate.h"
+#include "hierarchy.h"
+#include "movevars_shared.h"
+#include "npcevent.h"
+#include "saverestore_utlvector.h"
+#include "particle_parse.h"
+#include "te_particlesystem.h"
+#include "sceneentity.h"
+#include "shake.h"
+#include "soundenvelope.h"
+#include "soundent.h"
+#include "SpriteTrail.h"
+#include "IEffects.h"
+#include "engine/IEngineSound.h"
+#include "bone_setup.h"
+#include "studio.h"
+#include "ai_route.h"
+#include "ammodef.h"
+#include "npc_bullseye.h"
+#include "physobj.h"
+#include "ai_memory.h"
+#include "collisionutils.h"
+#include "shot_manipulator.h"
+#include "steamjet.h"
+#include "physics_prop_ragdoll.h"
+#include "vehicle_base.h"
+#include "coordsize.h"
+#include "hl2_shareddefs.h"
+#include "te_effect_dispatch.h"
+#include "beam_flags.h"
+#include "prop_combine_ball.h"
+#include "explode.h"
+#include "weapon_physcannon.h"
+#include "weapon_striderbuster.h"
+#include "monstermaker.h"
+#include "weapon_rpg.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+class CNPC_Hunter;
+
+
+static const char *HUNTER_FLECHETTE_MODEL = "models/weapons/hunter_flechette.mdl";
+
+// Think contexts
+static const char *HUNTER_BLEED_THINK = "HunterBleed";
+static const char *HUNTER_ZAP_THINK = "HunterZap";
+static const char *HUNTER_JOSTLE_VEHICLE_THINK = "HunterJostle";
+
+
+ConVar sk_hunter_health( "sk_hunter_health", "210" );
+
+// Melee attacks
+ConVar sk_hunter_dmg_one_slash( "sk_hunter_dmg_one_slash", "20" );
+ConVar sk_hunter_dmg_charge( "sk_hunter_dmg_charge", "20" );
+
+// Flechette volley attack
+ConVar hunter_flechette_max_range( "hunter_flechette_max_range", "1200" );
+ConVar hunter_flechette_min_range( "hunter_flechette_min_range", "100" );
+ConVar hunter_flechette_volley_size( "hunter_flechette_volley_size", "8" );
+ConVar hunter_flechette_speed( "hunter_flechette_speed", "2000" );
+ConVar sk_hunter_dmg_flechette( "sk_hunter_dmg_flechette", "4.0" );
+ConVar sk_hunter_flechette_explode_dmg( "sk_hunter_flechette_explode_dmg", "12.0" );
+ConVar sk_hunter_flechette_explode_radius( "sk_hunter_flechette_explode_radius", "128.0" );
+ConVar hunter_flechette_explode_delay( "hunter_flechette_explode_delay", "2.5" );
+ConVar hunter_flechette_delay( "hunter_flechette_delay", "0.1" );
+ConVar hunter_first_flechette_delay( "hunter_first_flechette_delay", "0.5" );
+ConVar hunter_flechette_max_concurrent_volleys( "hunter_flechette_max_concurrent_volleys", "2" );
+ConVar hunter_flechette_volley_start_min_delay( "hunter_flechette_volley_start_min_delay", ".25" );
+ConVar hunter_flechette_volley_start_max_delay( "hunter_flechette_volley_start_max_delay", ".95" );
+ConVar hunter_flechette_volley_end_min_delay( "hunter_flechette_volley_end_min_delay", "1" );
+ConVar hunter_flechette_volley_end_max_delay( "hunter_flechette_volley_end_max_delay", "2" );
+ConVar hunter_flechette_test( "hunter_flechette_test", "0" );
+ConVar hunter_clamp_shots( "hunter_clamp_shots", "1" );
+ConVar hunter_cheap_explosions( "hunter_cheap_explosions", "1" );
+
+// Damage received
+ConVar sk_hunter_bullet_damage_scale( "sk_hunter_bullet_damage_scale", "0.6" );
+ConVar sk_hunter_charge_damage_scale( "sk_hunter_charge_damage_scale", "2.0" );
+ConVar sk_hunter_buckshot_damage_scale( "sk_hunter_buckshot_damage_scale", "0.5" );
+ConVar sk_hunter_vehicle_damage_scale( "sk_hunter_vehicle_damage_scale", "2.2" );
+ConVar sk_hunter_dmg_from_striderbuster( "sk_hunter_dmg_from_striderbuster", "150" );
+ConVar sk_hunter_citizen_damage_scale( "sk_hunter_citizen_damage_scale", "0.3" );
+
+ConVar hunter_allow_dissolve( "hunter_allow_dissolve", "1" );
+ConVar hunter_random_expressions( "hunter_random_expressions", "0" );
+ConVar hunter_show_weapon_los_z( "hunter_show_weapon_los_z", "0" );
+ConVar hunter_show_weapon_los_condition( "hunter_show_weapon_los_condition", "0" );
+
+ConVar hunter_melee_delay( "hunter_melee_delay", "2.0" );
+
+// Bullrush charge.
+ConVar hunter_charge( "hunter_charge", "1" );
+ConVar hunter_charge_min_delay( "hunter_charge_min_delay", "10.0" );
+ConVar hunter_charge_pct( "hunter_charge_pct", "25" );
+ConVar hunter_charge_test( "hunter_charge_test", "0" );
+
+// Vehicle dodging.
+ConVar hunter_dodge_warning( "hunter_dodge_warning", "1.1" );
+ConVar hunter_dodge_warning_width( "hunter_dodge_warning_width", "180" );
+ConVar hunter_dodge_warning_cone( "hunter_dodge_warning_cone", ".5" );
+ConVar hunter_dodge_debug( "hunter_dodge_debug", "0" );
+
+// Jostle vehicles when hit by them
+ConVar hunter_jostle_car_min_speed( "hunter_jostle_car_min_speed", "100" ); // If hit by a car going at least this fast, jostle the car
+ConVar hunter_jostle_car_max_speed( "hunter_jostle_car_max_speed", "600" ); // Used for determining jostle scale
+
+ConVar hunter_free_knowledge( "hunter_free_knowledge", "10.0" );
+ConVar hunter_plant_adjust_z( "hunter_plant_adjust_z", "12" );
+
+ConVar hunter_disable_patrol( "hunter_disable_patrol", "0" );
+
+// Dealing with striderbusters
+ConVar hunter_hate_held_striderbusters( "hunter_hate_held_striderbusters", "1" );
+ConVar hunter_hate_thrown_striderbusters( "hunter_hate_thrown_striderbusters", "1" );
+ConVar hunter_hate_attached_striderbusters( "hunter_hate_attached_striderbusters", "1" );
+ConVar hunter_hate_held_striderbusters_delay( "hunter_hate_held_striderbusters_delay", "0.5" );
+ConVar hunter_hate_held_striderbusters_tolerance( "hunter_hate_held_striderbusters_tolerance", "2000.0" );
+ConVar hunter_hate_thrown_striderbusters_tolerance( "hunter_hate_thrown_striderbusters_tolerance", "300.0" );
+ConVar hunter_seek_thrown_striderbusters_tolerance( "hunter_seek_thrown_striderbusters_tolerance", "400.0" );
+ConVar hunter_retreat_striderbusters( "hunter_retreat_striderbusters", "1", FCVAR_NONE, "If true, the hunter will retreat when a buster is glued to him." );
+
+ConVar hunter_allow_nav_jump( "hunter_allow_nav_jump", "0" );
+ConVar g_debug_hunter_charge( "g_debug_hunter_charge", "0" );
+
+ConVar hunter_stand_still( "hunter_stand_still", "0" ); // used for debugging, keeps them rooted in place
+
+ConVar hunter_siege_frequency( "hunter_siege_frequency", "12" );
+
+#define HUNTER_FOV_DOT					0.0		// 180 degree field of view
+#define HUNTER_CHARGE_MIN				256
+#define HUNTER_CHARGE_MAX				1024
+#define HUNTER_FACE_ENEMY_DIST			512.0f
+#define HUNTER_MELEE_REACH				80
+#define HUNTER_BLOOD_LEFT_FOOT			0
+#define HUNTER_IGNORE_ENEMY_TIME		5		// How long the hunter will ignore another enemy when distracted by the player.
+
+#define HUNTER_FACING_DOT				0.8		// The angle within which we start shooting
+#define HUNTER_SHOOT_MAX_YAW_DEG		60.0f	// Once shooting, clamp to +/- these degrees of yaw deflection as our target moves
+#define HUNTER_SHOOT_MAX_YAW_COS		0.5f	// The cosine of the above angle
+
+#define HUNTER_FLECHETTE_WARN_TIME		1.0f
+
+#define HUNTER_SEE_ENEMY_TIME_INVALID	-1
+
+#define NUM_FLECHETTE_VOLLEY_ON_FOLLOW 4
+
+#define HUNTER_SIEGE_MAX_DIST_MODIFIER 2.0f
+
+//-----------------------------------------------------------------------------
+// Animation events
+//-----------------------------------------------------------------------------
+int AE_HUNTER_FOOTSTEP_LEFT;
+int AE_HUNTER_FOOTSTEP_RIGHT;
+int AE_HUNTER_FOOTSTEP_BACK;
+int AE_HUNTER_MELEE_ANNOUNCE;
+int AE_HUNTER_MELEE_ATTACK_LEFT;
+int AE_HUNTER_MELEE_ATTACK_RIGHT;
+int AE_HUNTER_DIE;
+int AE_HUNTER_SPRAY_BLOOD;
+int AE_HUNTER_START_EXPRESSION;
+int AE_HUNTER_END_EXPRESSION;
+
+
+//-----------------------------------------------------------------------------
+// Interactions.
+//-----------------------------------------------------------------------------
+int g_interactionHunterFoundEnemy = 0;
+
+
+//-----------------------------------------------------------------------------
+// Local stuff.
+//-----------------------------------------------------------------------------
+static string_t s_iszStriderClassname;
+static string_t s_iszStriderBusterClassname;
+static string_t s_iszMagnadeClassname;
+static string_t s_iszPhysPropClassname;
+static string_t s_iszHuntersToRunOver;
+
+
+//-----------------------------------------------------------------------------
+// Custom Activities
+//-----------------------------------------------------------------------------
+Activity ACT_HUNTER_DEPLOYRA2;
+Activity ACT_HUNTER_DODGER;
+Activity ACT_HUNTER_DODGEL;
+Activity ACT_HUNTER_GESTURE_SHOOT;
+Activity ACT_HUNTER_FLINCH_STICKYBOMB;
+Activity ACT_HUNTER_STAGGER;
+Activity ACT_HUNTER_MELEE_ATTACK1_VS_PLAYER;
+Activity ACT_DI_HUNTER_MELEE;
+Activity ACT_DI_HUNTER_THROW;
+Activity ACT_HUNTER_ANGRY;
+Activity ACT_HUNTER_WALK_ANGRY;
+Activity ACT_HUNTER_FOUND_ENEMY;
+Activity ACT_HUNTER_FOUND_ENEMY_ACK;
+Activity ACT_HUNTER_CHARGE_START;
+Activity ACT_HUNTER_CHARGE_RUN;
+Activity ACT_HUNTER_CHARGE_STOP;
+Activity ACT_HUNTER_CHARGE_CRASH;
+Activity ACT_HUNTER_CHARGE_HIT;
+Activity ACT_HUNTER_RANGE_ATTACK2_UNPLANTED;
+Activity ACT_HUNTER_IDLE_PLANTED;
+Activity ACT_HUNTER_FLINCH_N;
+Activity ACT_HUNTER_FLINCH_S;
+Activity ACT_HUNTER_FLINCH_E;
+Activity ACT_HUNTER_FLINCH_W;
+
+
+//-----------------------------------------------------------------------------
+//	Squad slots
+//-----------------------------------------------------------------------------
+enum SquadSlot_t
+{	
+	SQUAD_SLOT_HUNTER_CHARGE = LAST_SHARED_SQUADSLOT,
+	SQUAD_SLOT_HUNTER_FLANK_FIRST,
+	SQUAD_SLOT_HUNTER_FLANK_LAST = SQUAD_SLOT_HUNTER_FLANK_FIRST,
+	SQUAD_SLOT_RUN_SHOOT,
+};
+
+#define	HUNTER_FOLLOW_DISTANCE	2000.0f
+#define	HUNTER_FOLLOW_DISTANCE_SQR	(HUNTER_FOLLOW_DISTANCE * HUNTER_FOLLOW_DISTANCE)
+
+#define HUNTER_RUNDOWN_SQUADDATA 0
+
+
+//-----------------------------------------------------------------------------
+// We're doing this quite a lot, so this makes the check a lot faster since
+// we don't have to compare strings.
+//-----------------------------------------------------------------------------
+bool IsStriderBuster( CBaseEntity *pEntity )
+{
+	if ( !pEntity )
+		return false;
+
+	if( pEntity->m_iClassname == s_iszStriderBusterClassname || 
+		pEntity->m_iClassname == s_iszMagnadeClassname)
+		return true;
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool HateThisStriderBuster( CBaseEntity *pTarget )
+{
+	if ( StriderBuster_WasKnockedOffStrider(pTarget) )
+		return false;
+
+	if ( pTarget->VPhysicsGetObject() )
+	{
+		if ( hunter_hate_held_striderbusters.GetBool() || 
+			hunter_hate_thrown_striderbusters.GetBool() ||
+			hunter_hate_attached_striderbusters.GetBool() )
+		{
+			if ( ( pTarget->VPhysicsGetObject()->GetGameFlags() & ( FVPHYSICS_PLAYER_HELD | FVPHYSICS_WAS_THROWN ) ) )
+			{
+				return true;
+			}
+
+			if ( StriderBuster_IsAttachedStriderBuster( pTarget ) )
+			{
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// The hunter can fire a volley of explosive flechettes.
+//-----------------------------------------------------------------------------
+static const char *s_szHunterFlechetteBubbles = "HunterFlechetteBubbles";
+static const char *s_szHunterFlechetteSeekThink = "HunterFlechetteSeekThink";
+static const char *s_szHunterFlechetteDangerSoundThink = "HunterFlechetteDangerSoundThink";
+static const char *s_szHunterFlechetteSpriteTrail = "sprites/bluelaser1.vmt";
+static int s_nHunterFlechetteImpact = -2;
+static int s_nFlechetteFuseAttach = -1;
+
+#define FLECHETTE_AIR_VELOCITY	2500
+
+class CHunterFlechette : public CPhysicsProp, public IParentPropInteraction
+{
+	DECLARE_CLASS( CHunterFlechette, CPhysicsProp );
+
+public:
+
+	CHunterFlechette();
+	~CHunterFlechette();
+
+	Class_T Classify() { return CLASS_NONE; }
+	
+	bool WasThrownBack()
+	{
+		return m_bThrownBack;
+	}
+
+public:
+
+	void Spawn();
+	void Activate();
+	void Precache();
+	void Shoot( Vector &vecVelocity, bool bBright );
+	void SetSeekTarget( CBaseEntity *pTargetEntity );
+	void Explode();
+
+	bool CreateVPhysics();
+
+	unsigned int PhysicsSolidMaskForEntity() const;
+	static CHunterFlechette *FlechetteCreate( const Vector &vecOrigin, const QAngle &angAngles, CBaseEntity *pentOwner = NULL );
+
+	// IParentPropInteraction
+	void OnParentCollisionInteraction( parentCollisionInteraction_t eType, int index, gamevcollisionevent_t *pEvent );
+	void OnParentPhysGunDrop( CBasePlayer *pPhysGunUser, PhysGunDrop_t Reason );
+
+protected:
+
+	void SetupGlobalModelData();
+
+	void StickTo( CBaseEntity *pOther, trace_t &tr );
+
+	void BubbleThink();
+	void DangerSoundThink();
+	void ExplodeThink();
+	void DopplerThink();
+	void SeekThink();
+
+	bool CreateSprites( bool bBright );
+
+	void FlechetteTouch( CBaseEntity *pOther );
+
+	Vector m_vecShootPosition;
+	EHANDLE m_hSeekTarget;
+	bool m_bThrownBack;
+
+	DECLARE_DATADESC();
+	//DECLARE_SERVERCLASS();
+};
+
+LINK_ENTITY_TO_CLASS( hunter_flechette, CHunterFlechette );
+
+BEGIN_DATADESC( CHunterFlechette )
+
+	DEFINE_THINKFUNC( BubbleThink ),
+	DEFINE_THINKFUNC( DangerSoundThink ),
+	DEFINE_THINKFUNC( ExplodeThink ),
+	DEFINE_THINKFUNC( DopplerThink ),
+	DEFINE_THINKFUNC( SeekThink ),
+	
+	DEFINE_ENTITYFUNC( FlechetteTouch ),
+
+	DEFINE_FIELD( m_vecShootPosition, FIELD_POSITION_VECTOR ),
+	DEFINE_FIELD( m_hSeekTarget, FIELD_EHANDLE ),
+	DEFINE_FIELD( m_bThrownBack, FIELD_BOOLEAN ),
+
+END_DATADESC()
+
+//IMPLEMENT_SERVERCLASS_ST( CHunterFlechette, DT_HunterFlechette )
+//END_SEND_TABLE()
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+CHunterFlechette *CHunterFlechette::FlechetteCreate( const Vector &vecOrigin, const QAngle &angAngles, CBaseEntity *pentOwner )
+{
+	// Create a new entity with CHunterFlechette private data
+	CHunterFlechette *pFlechette = (CHunterFlechette *)CreateEntityByName( "hunter_flechette" );
+	UTIL_SetOrigin( pFlechette, vecOrigin );
+	pFlechette->SetAbsAngles( angAngles );
+	pFlechette->Spawn();
+	pFlechette->Activate();
+	pFlechette->SetOwnerEntity( pentOwner );
+
+	return pFlechette;
+}
+
+
+//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+void CC_Hunter_Shoot_Flechette( const CCommand& args )
+{
+	MDLCACHE_CRITICAL_SECTION();
+
+	bool allowPrecache = CBaseEntity::IsPrecacheAllowed();
+	CBaseEntity::SetAllowPrecache( true );
+
+	CBasePlayer *pPlayer = UTIL_GetCommandClient();
+
+	QAngle angEye = pPlayer->EyeAngles();
+	CHunterFlechette *entity = CHunterFlechette::FlechetteCreate( pPlayer->EyePosition(), angEye, pPlayer );
+	if ( entity )
+	{
+		entity->Precache();
+		DispatchSpawn( entity );
+
+		// Shoot the flechette.		
+		Vector forward;
+		pPlayer->EyeVectors( &forward );
+		forward *= 2000.0f;
+		entity->Shoot( forward, false );
+	}
+
+	CBaseEntity::SetAllowPrecache( allowPrecache );
+}
+
+static ConCommand ent_create("hunter_shoot_flechette", CC_Hunter_Shoot_Flechette, "Fires a hunter flechette where the player is looking.", FCVAR_GAMEDLL | FCVAR_CHEAT);
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+CHunterFlechette::CHunterFlechette()
+{
+	UseClientSideAnimation();
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+CHunterFlechette::~CHunterFlechette()
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// If set, the flechette will seek unerringly toward the target as it flies.
+//-----------------------------------------------------------------------------
+void CHunterFlechette::SetSeekTarget( CBaseEntity *pTargetEntity )
+{
+	if ( pTargetEntity )
+	{
+		m_hSeekTarget = pTargetEntity;
+		SetContextThink( &CHunterFlechette::SeekThink, gpGlobals->curtime, s_szHunterFlechetteSeekThink );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CHunterFlechette::CreateVPhysics()
+{
+	// Create the object in the physics system
+	VPhysicsInitNormal( SOLID_BBOX, FSOLID_NOT_STANDABLE, false );
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+unsigned int CHunterFlechette::PhysicsSolidMaskForEntity() const
+{
+	return ( BaseClass::PhysicsSolidMaskForEntity() | CONTENTS_HITBOX ) & ~CONTENTS_GRATE;
+}
+
+
+//-----------------------------------------------------------------------------
+// Called from CPropPhysics code when we're attached to a physics object.
+//-----------------------------------------------------------------------------
+void CHunterFlechette::OnParentCollisionInteraction( parentCollisionInteraction_t eType, int index, gamevcollisionevent_t *pEvent )
+{
+	if ( eType == COLLISIONINTER_PARENT_FIRST_IMPACT )
+	{
+		m_bThrownBack = true;
+		Explode();
+	}
+}
+
+void CHunterFlechette::OnParentPhysGunDrop( CBasePlayer *pPhysGunUser, PhysGunDrop_t Reason )
+{
+	m_bThrownBack = true;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CHunterFlechette::CreateSprites( bool bBright )
+{
+	if ( bBright )
+	{
+		DispatchParticleEffect( "hunter_flechette_trail_striderbuster", PATTACH_ABSORIGIN_FOLLOW, this );
+	}
+	else
+	{
+		DispatchParticleEffect( "hunter_flechette_trail", PATTACH_ABSORIGIN_FOLLOW, this );
+	}
+	
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CHunterFlechette::Spawn()
+{
+	Precache( );
+
+	SetModel( HUNTER_FLECHETTE_MODEL );
+	SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_CUSTOM );
+	UTIL_SetSize( this, -Vector(1,1,1), Vector(1,1,1) );
+	SetSolid( SOLID_BBOX );
+	SetGravity( 0.05f );
+	SetCollisionGroup( COLLISION_GROUP_PROJECTILE );
+	
+	// Make sure we're updated if we're underwater
+	UpdateWaterState();
+
+	SetTouch( &CHunterFlechette::FlechetteTouch );
+
+	// Make us glow until we've hit the wall
+	m_nSkin = 1;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CHunterFlechette::Activate()
+{
+	BaseClass::Activate();
+	SetupGlobalModelData();
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CHunterFlechette::SetupGlobalModelData()
+{
+	if ( s_nHunterFlechetteImpact == -2 )
+	{
+		s_nHunterFlechetteImpact = LookupSequence( "impact" );
+		s_nFlechetteFuseAttach = LookupAttachment( "attach_fuse" );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CHunterFlechette::Precache()
+{
+	PrecacheModel( HUNTER_FLECHETTE_MODEL );
+	PrecacheModel( "sprites/light_glow02_noz.vmt" );
+
+	PrecacheScriptSound( "NPC_Hunter.FlechetteNearmiss" );
+	PrecacheScriptSound( "NPC_Hunter.FlechetteHitBody" );
+	PrecacheScriptSound( "NPC_Hunter.FlechetteHitWorld" );
+	PrecacheScriptSound( "NPC_Hunter.FlechettePreExplode" );
+	PrecacheScriptSound( "NPC_Hunter.FlechetteExplode" );
+
+	PrecacheParticleSystem( "hunter_flechette_trail_striderbuster" );
+	PrecacheParticleSystem( "hunter_flechette_trail" );
+	PrecacheParticleSystem( "hunter_projectile_explosion_1" );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CHunterFlechette::StickTo( CBaseEntity *pOther, trace_t &tr )
+{
+	EmitSound( "NPC_Hunter.FlechetteHitWorld" );
+
+	SetMoveType( MOVETYPE_NONE );
+	
+	if ( !pOther->IsWorld() )
+	{
+		SetParent( pOther );
+		SetSolid( SOLID_NONE );
+		SetSolidFlags( FSOLID_NOT_SOLID );
+	}
+
+	// Do an impact effect.
+	//Vector vecDir = GetAbsVelocity();
+	//float speed = VectorNormalize( vecDir );
+
+	//Vector vForward;
+	//AngleVectors( GetAbsAngles(), &vForward );
+	//VectorNormalize ( vForward );
+
+	//CEffectData	data;
+	//data.m_vOrigin = tr.endpos;
+	//data.m_vNormal = vForward;
+	//data.m_nEntIndex = 0;
+	//DispatchEffect( "BoltImpact", data );
+	
+	Vector vecVelocity = GetAbsVelocity();
+	bool bAttachedToBuster = StriderBuster_OnFlechetteAttach( pOther, vecVelocity );
+
+	SetTouch( NULL );
+
+	// We're no longer flying. Stop checking for water volumes.
+	SetContextThink( NULL, 0, s_szHunterFlechetteBubbles );
+
+	// Stop seeking.
+	m_hSeekTarget = NULL;
+	SetContextThink( NULL, 0, s_szHunterFlechetteSeekThink );
+
+	// Get ready to explode.
+	if ( !bAttachedToBuster )
+	{
+		SetThink( &CHunterFlechette::DangerSoundThink );
+		SetNextThink( gpGlobals->curtime + (hunter_flechette_explode_delay.GetFloat() - HUNTER_FLECHETTE_WARN_TIME) );
+	}
+	else
+	{
+		DangerSoundThink();
+	}
+
+	// Play our impact animation.
+	ResetSequence( s_nHunterFlechetteImpact );
+
+	static int s_nImpactCount = 0;
+	s_nImpactCount++;
+	if ( s_nImpactCount & 0x01 )
+	{
+		UTIL_ImpactTrace( &tr, DMG_BULLET );
+		
+		// Shoot some sparks
+		if ( UTIL_PointContents( GetAbsOrigin() ) != CONTENTS_WATER)
+		{
+			g_pEffects->Sparks( GetAbsOrigin() );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CHunterFlechette::FlechetteTouch( CBaseEntity *pOther )
+{
+	if ( pOther->IsSolidFlagSet(FSOLID_VOLUME_CONTENTS | FSOLID_TRIGGER) )
+	{
+		// Some NPCs are triggers that can take damage (like antlion grubs). We should hit them.
+		if ( ( pOther->m_takedamage == DAMAGE_NO ) || ( pOther->m_takedamage == DAMAGE_EVENTS_ONLY ) )
+			return;
+	}
+
+	if ( FClassnameIs( pOther, "hunter_flechette" ) )
+		return;
+
+	trace_t	tr;
+	tr = BaseClass::GetTouchTrace();
+
+	if ( pOther->m_takedamage != DAMAGE_NO )
+	{
+		Vector	vecNormalizedVel = GetAbsVelocity();
+
+		ClearMultiDamage();
+		VectorNormalize( vecNormalizedVel );
+
+		float flDamage = sk_hunter_dmg_flechette.GetFloat();
+		CBreakable *pBreak = dynamic_cast <CBreakable *>(pOther);
+		if ( pBreak && ( pBreak->GetMaterialType() == matGlass ) )
+		{
+			flDamage = MAX( pOther->GetHealth(), flDamage );
+		}
+
+		CTakeDamageInfo	dmgInfo( this, GetOwnerEntity(), flDamage, DMG_DISSOLVE | DMG_NEVERGIB );
+		CalculateMeleeDamageForce( &dmgInfo, vecNormalizedVel, tr.endpos, 0.7f );
+		dmgInfo.SetDamagePosition( tr.endpos );
+		pOther->DispatchTraceAttack( dmgInfo, vecNormalizedVel, &tr );
+
+		ApplyMultiDamage();
+
+		// Keep going through breakable glass.
+		if ( pOther->GetCollisionGroup() == COLLISION_GROUP_BREAKABLE_GLASS )
+			 return;
+			 
+		SetAbsVelocity( Vector( 0, 0, 0 ) );
+
+		// play body "thwack" sound
+		EmitSound( "NPC_Hunter.FlechetteHitBody" );
+
+		StopParticleEffects( this );
+
+		Vector vForward;
+		AngleVectors( GetAbsAngles(), &vForward );
+		VectorNormalize ( vForward );
+
+		trace_t	tr2;
+		UTIL_TraceLine( GetAbsOrigin(),	GetAbsOrigin() + vForward * 128, MASK_BLOCKLOS, pOther, COLLISION_GROUP_NONE, &tr2 );
+
+		if ( tr2.fraction != 1.0f )
+		{
+			//NDebugOverlay::Box( tr2.endpos, Vector( -16, -16, -16 ), Vector( 16, 16, 16 ), 0, 255, 0, 0, 10 );
+			//NDebugOverlay::Box( GetAbsOrigin(), Vector( -16, -16, -16 ), Vector( 16, 16, 16 ), 0, 0, 255, 0, 10 );
+
+			if ( tr2.m_pEnt == NULL || ( tr2.m_pEnt && tr2.m_pEnt->GetMoveType() == MOVETYPE_NONE ) )
+			{
+				CEffectData	data;
+
+				data.m_vOrigin = tr2.endpos;
+				data.m_vNormal = vForward;
+				data.m_nEntIndex = tr2.fraction != 1.0f;
+			
+				//DispatchEffect( "BoltImpact", data );
+			}
+		}
+
+		if ( ( ( pOther->GetMoveType() == MOVETYPE_VPHYSICS ) || ( pOther->GetMoveType() == MOVETYPE_PUSH ) ) && ( ( pOther->GetHealth() > 0 ) || ( pOther->m_takedamage == DAMAGE_EVENTS_ONLY ) ) )
+		{
+			CPhysicsProp *pProp = dynamic_cast<CPhysicsProp *>( pOther );
+			if ( pProp )
+			{
+				pProp->SetInteraction( PROPINTER_PHYSGUN_NOTIFY_CHILDREN );
+			}
+		
+			// We hit a physics object that survived the impact. Stick to it.
+			StickTo( pOther, tr );
+		}
+		else
+		{
+			SetTouch( NULL );
+			SetThink( NULL );
+			SetContextThink( NULL, 0, s_szHunterFlechetteBubbles );
+
+			UTIL_Remove( this );
+		}
+	}
+	else
+	{
+		// See if we struck the world
+		if ( pOther->GetMoveType() == MOVETYPE_NONE && !( tr.surface.flags & SURF_SKY ) )
+		{
+			// We hit a physics object that survived the impact. Stick to it.
+			StickTo( pOther, tr );
+		}
+		else if( pOther->GetMoveType() == MOVETYPE_PUSH && FClassnameIs(pOther, "func_breakable") )
+		{
+			// We hit a func_breakable, stick to it.
+			// The MOVETYPE_PUSH is a micro-optimization to cut down on the classname checks.
+			StickTo( pOther, tr );
+		}
+		else
+		{
+			// Put a mark unless we've hit the sky
+			if ( ( tr.surface.flags & SURF_SKY ) == false )
+			{
+				UTIL_ImpactTrace( &tr, DMG_BULLET );
+			}
+
+			UTIL_Remove( this );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Fixup flechette position when seeking towards a striderbuster.
+//-----------------------------------------------------------------------------
+void CHunterFlechette::SeekThink()
+{
+	if ( m_hSeekTarget )
+	{
+		Vector vecBodyTarget = m_hSeekTarget->BodyTarget( GetAbsOrigin() );
+
+		Vector vecClosest;
+		CalcClosestPointOnLineSegment( GetAbsOrigin(), m_vecShootPosition, vecBodyTarget, vecClosest, NULL );
+
+		Vector vecDelta = vecBodyTarget - m_vecShootPosition;
+		VectorNormalize( vecDelta );
+
+		QAngle angShoot;
+		VectorAngles( vecDelta, angShoot );
+
+		float flSpeed = hunter_flechette_speed.GetFloat();
+		if ( !flSpeed )
+		{
+			flSpeed = 2500.0f;
+		}
+
+		Vector vecVelocity = vecDelta * flSpeed;
+		Teleport( &vecClosest, &angShoot, &vecVelocity );
+
+		SetNextThink( gpGlobals->curtime, s_szHunterFlechetteSeekThink );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Play a near miss sound as we travel past the player.
+//-----------------------------------------------------------------------------
+void CHunterFlechette::DopplerThink()
+{
+	CBasePlayer *pPlayer = AI_GetSinglePlayer();
+	if ( !pPlayer )
+		return;
+
+	Vector vecVelocity = GetAbsVelocity();
+	VectorNormalize( vecVelocity );
+	
+	float flMyDot = DotProduct( vecVelocity, GetAbsOrigin() );
+	float flPlayerDot = DotProduct( vecVelocity, pPlayer->GetAbsOrigin() );
+
+	if ( flPlayerDot <= flMyDot )
+	{
+		EmitSound( "NPC_Hunter.FlechetteNearMiss" );
+		
+		// We've played the near miss sound and we're not seeking. Stop thinking.
+		SetThink( NULL );
+	}
+	else
+	{
+		SetNextThink( gpGlobals->curtime );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Think every 0.1 seconds to make bubbles if we're flying through water.
+//-----------------------------------------------------------------------------
+void CHunterFlechette::BubbleThink()
+{
+	SetNextThink( gpGlobals->curtime + 0.1f, s_szHunterFlechetteBubbles );
+
+	if ( GetWaterLevel()  == 0 )
+		return;
+
+	UTIL_BubbleTrail( GetAbsOrigin() - GetAbsVelocity() * 0.1f, GetAbsOrigin(), 5 );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CHunterFlechette::Shoot( Vector &vecVelocity, bool bBrightFX )
+{
+	CreateSprites( bBrightFX );
+
+	m_vecShootPosition = GetAbsOrigin();
+
+	SetAbsVelocity( vecVelocity );
+
+	SetThink( &CHunterFlechette::DopplerThink );
+	SetNextThink( gpGlobals->curtime );
+
+	SetContextThink( &CHunterFlechette::BubbleThink, gpGlobals->curtime + 0.1, s_szHunterFlechetteBubbles );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CHunterFlechette::DangerSoundThink()
+{
+	EmitSound( "NPC_Hunter.FlechettePreExplode" );
+
+	CSoundEnt::InsertSound( SOUND_DANGER|SOUND_CONTEXT_EXCLUDE_COMBINE, GetAbsOrigin(), 150.0f, 0.5, this );
+	SetThink( &CHunterFlechette::ExplodeThink );
+	SetNextThink( gpGlobals->curtime + HUNTER_FLECHETTE_WARN_TIME );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CHunterFlechette::ExplodeThink()
+{
+	Explode();
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CHunterFlechette::Explode()
+{
+	SetSolid( SOLID_NONE );
+
+	// Don't catch self in own explosion!
+	m_takedamage = DAMAGE_NO;
+
+	EmitSound( "NPC_Hunter.FlechetteExplode" );
+	
+	// Move the explosion effect to the tip to reduce intersection with the world.
+	Vector vecFuse;
+	GetAttachment( s_nFlechetteFuseAttach, vecFuse );
+	DispatchParticleEffect( "hunter_projectile_explosion_1", vecFuse, GetAbsAngles(), NULL );
+
+	int nDamageType = DMG_DISSOLVE;
+
+	// Perf optimization - only every other explosion makes a physics force. This is
+	// hardly noticeable since flechettes usually explode in clumps.
+	static int s_nExplosionCount = 0;
+	s_nExplosionCount++;
+	if ( ( s_nExplosionCount & 0x01 ) && hunter_cheap_explosions.GetBool() )
+	{
+		nDamageType |= DMG_PREVENT_PHYSICS_FORCE;
+	}
+
+	RadiusDamage( CTakeDamageInfo( this, GetOwnerEntity(), sk_hunter_flechette_explode_dmg.GetFloat(), nDamageType ), GetAbsOrigin(), sk_hunter_flechette_explode_radius.GetFloat(), CLASS_NONE, NULL );
+		
+    AddEffects( EF_NODRAW );
+
+	SetThink( &CBaseEntity::SUB_Remove );
+	SetNextThink( gpGlobals->curtime + 0.1f );
+}
+
+
+//-----------------------------------------------------------------------------
+// Calculate & apply damage & force for a charge to a target.
+// Done outside of the hunter because we need to do this inside a trace filter.
+//-----------------------------------------------------------------------------
+void Hunter_ApplyChargeDamage( CBaseEntity *pHunter, CBaseEntity *pTarget, float flDamage )
+{
+	Vector attackDir = ( pTarget->WorldSpaceCenter() - pHunter->WorldSpaceCenter() );
+	VectorNormalize( attackDir );
+	Vector offset = RandomVector( -32, 32 ) + pTarget->WorldSpaceCenter();
+
+	// Generate enough force to make a 75kg guy move away at 700 in/sec
+	Vector vecForce = attackDir * ImpulseScale( 75, 700 );
+
+	// Deal the damage
+	CTakeDamageInfo	info( pHunter, pHunter, vecForce, offset, flDamage, DMG_CLUB );
+	pTarget->TakeDamage( info );
+}
+
+
+//-----------------------------------------------------------------------------
+// A simple trace filter class to skip small moveable physics objects
+//-----------------------------------------------------------------------------
+class CHunterTraceFilterSkipPhysics : public CTraceFilter
+{
+public:
+	// It does have a base, but we'll never network anything below here..
+	DECLARE_CLASS_NOBASE( CHunterTraceFilterSkipPhysics );
+	
+	CHunterTraceFilterSkipPhysics( const IHandleEntity *passentity, int collisionGroup, float minMass )
+		: m_pPassEnt(passentity), m_collisionGroup(collisionGroup), m_minMass(minMass)
+	{
+	}
+	virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
+	{
+		if ( !StandardFilterRules( pHandleEntity, contentsMask ) )
+			return false;
+
+		if ( !PassServerEntityFilter( pHandleEntity, m_pPassEnt ) )
+			return false;
+
+		// Don't test if the game code tells us we should ignore this collision...
+		CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity );
+		if ( pEntity )
+		{
+			if ( !pEntity->ShouldCollide( m_collisionGroup, contentsMask ) )
+				return false;
+			
+			if ( !g_pGameRules->ShouldCollide( m_collisionGroup, pEntity->GetCollisionGroup() ) )
+				return false;
+
+			// don't test small moveable physics objects (unless it's an NPC)
+			if ( !pEntity->IsNPC() && pEntity->GetMoveType() == MOVETYPE_VPHYSICS )
+			{
+				float entMass = PhysGetEntityMass( pEntity ) ;
+				if ( entMass < m_minMass )
+				{
+					if ( entMass < m_minMass * 0.666f || pEntity->CollisionProp()->BoundingRadius() < (assert_cast<const CAI_BaseNPC *>(EntityFromEntityHandle( m_pPassEnt )))->GetHullHeight() )
+					{
+						return false;
+					}
+				}
+			}
+
+			// If we hit an antlion, don't stop, but kill it
+			if ( pEntity->Classify() == CLASS_ANTLION )
+			{
+				CBaseEntity *pHunter = (CBaseEntity *)EntityFromEntityHandle( m_pPassEnt );
+				Hunter_ApplyChargeDamage( pHunter, pEntity, pEntity->GetHealth() );
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+private:
+	const IHandleEntity *m_pPassEnt;
+	int m_collisionGroup;
+	float m_minMass;
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+inline void HunterTraceHull_SkipPhysics( const Vector &vecAbsStart, const Vector &vecAbsEnd, const Vector &hullMin, 
+					 const Vector &hullMax,	unsigned int mask, const CBaseEntity *ignore, 
+					 int collisionGroup, trace_t *ptr, float minMass )
+{
+	Ray_t ray;
+	ray.Init( vecAbsStart, vecAbsEnd, hullMin, hullMax );
+	CHunterTraceFilterSkipPhysics traceFilter( ignore, collisionGroup, minMass );
+	enginetrace->TraceRay( ray, mask, &traceFilter, ptr );
+}
+
+
+//-----------------------------------------------------------------------------
+// Hunter follow behavior
+//-----------------------------------------------------------------------------
+class CAI_HunterEscortBehavior : public CAI_FollowBehavior
+{	
+public:
+	DECLARE_CLASS( CAI_HunterEscortBehavior, CAI_FollowBehavior );
+
+	CAI_HunterEscortBehavior() :
+		BaseClass( AI_FollowParams_t( AIF_HUNTER, true ) ),
+		m_flTimeEscortReturn( 0 ),
+		m_bEnabled( false )
+	{
+	}
+
+	CNPC_Hunter *GetOuter() { return (CNPC_Hunter *)( BaseClass::GetOuter() ); }
+
+	void SetEscortTarget( CNPC_Strider *pLeader, bool fFinishCurSchedule = false );
+	CNPC_Strider * GetEscortTarget() { return (CNPC_Strider *)GetFollowTarget(); }
+
+	bool FarFromFollowTarget()
+	{ 
+		return ( GetFollowTarget() && (GetAbsOrigin() - GetFollowTarget()->GetAbsOrigin()).LengthSqr() > HUNTER_FOLLOW_DISTANCE_SQR ); 
+	}
+
+	void DrawDebugGeometryOverlays();
+	bool ShouldFollow();
+	void BuildScheduleTestBits();
+
+	void BeginScheduleSelection();
+
+	void GatherConditions();
+	void GatherConditionsNotActive();
+	int SelectSchedule();
+	int	FollowCallBaseSelectSchedule();
+	void StartTask( const Task_t *pTask );
+	void RunTask( const Task_t *pTask );
+
+	void CheckBreakEscort();
+
+	void OnDamage( const CTakeDamageInfo &info );
+	static void DistributeFreeHunters();
+	static void FindFreeHunters( CUtlVector<CNPC_Hunter *> *pFreeHunters );
+
+	float			m_flTimeEscortReturn;
+	CSimpleSimTimer	m_FollowAttackTimer;
+	bool			m_bEnabled;
+
+	static float	gm_flLastDefendSound; // not saved and loaded, it's okay to yell again after a load
+
+	//---------------------------------
+
+	DECLARE_DATADESC();
+};
+
+
+BEGIN_DATADESC( CAI_HunterEscortBehavior )
+	DEFINE_FIELD( m_flTimeEscortReturn, FIELD_TIME ),
+	DEFINE_EMBEDDED( m_FollowAttackTimer ),
+	DEFINE_FIELD( m_bEnabled, FIELD_BOOLEAN ),
+END_DATADESC();
+
+float CAI_HunterEscortBehavior::gm_flLastDefendSound;
+
+//-----------------------------------------------------------------------------
+// Hunter PHYSICS DAMAGE TABLE
+//-----------------------------------------------------------------------------
+#define HUNTER_MIN_PHYSICS_DAMAGE 10
+
+static impactentry_t s_HunterLinearTable[] =
+{
+	{ 150*150, 75 },
+	{ 350*350, 105 },
+	{ 1000*1000, 300 },
+};
+
+static impactentry_t s_HunterAngularTable[] =
+{
+	{ 100*100, 75 },
+	{ 200*200, 105 },
+	{ 300*300, 300 },
+};
+
+impactdamagetable_t s_HunterImpactDamageTable =
+{
+	s_HunterLinearTable,
+	s_HunterAngularTable,
+	
+	ARRAYSIZE(s_HunterLinearTable),
+	ARRAYSIZE(s_HunterAngularTable),
+
+	24*24,		// minimum linear speed squared
+	360*360,	// minimum angular speed squared (360 deg/s to cause spin/slice damage)
+	5,			// can't take damage from anything under 5kg
+
+	10,			// anything less than 10kg is "small"
+	HUNTER_MIN_PHYSICS_DAMAGE,			// never take more than 10 pts of damage from anything under 10kg
+	36*36,		// <10kg objects must go faster than 36 in/s to do damage
+
+	VPHYSICS_LARGE_OBJECT_MASS,		// large mass in kg 
+	4,			// large mass scale (anything over 500kg does 4X as much energy to read from damage table)
+	5,			// large mass falling scale (emphasize falling/crushing damage over sideways impacts since the stress will kill you anyway)
+	0.0f,		// min vel
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+class CNPC_Hunter : public CAI_BaseActor
+{
+	DECLARE_CLASS( CNPC_Hunter, CAI_BaseActor );
+
+public:
+	CNPC_Hunter();
+	~CNPC_Hunter();
+
+	//---------------------------------
+
+	void			Precache();
+	void			Spawn();
+	void			PostNPCInit();
+	void			Activate();
+	void			UpdateOnRemove();
+	void			OnRestore();
+	bool			CreateBehaviors();
+	void			IdleSound();
+	bool			ShouldPlayIdleSound();
+	bool			CanBecomeRagdoll();
+	Activity		GetDeathActivity();
+	void			StopLoopingSounds();
+
+	const impactdamagetable_t &GetPhysicsImpactDamageTable();
+
+	Class_T			Classify();
+	Vector			BodyTarget( const Vector &posSrc, bool bNoisy /*= true*/ );
+
+	int				DrawDebugTextOverlays();
+	void			DrawDebugGeometryOverlays();
+
+	void			UpdateEfficiency( bool bInPVS );
+
+	//---------------------------------
+
+	virtual Vector	GetNodeViewOffset()					{ return BaseClass::GetDefaultEyeOffset();		}
+
+	int				GetSoundInterests();
+
+	bool			IsInLargeOutdoorMap();
+
+	//---------------------------------
+	// CAI_BaseActor
+	//---------------------------------
+	const char *SelectRandomExpressionForState( NPC_STATE state );
+	void PlayExpressionForState( NPC_STATE state );
+
+	//---------------------------------
+	// CBaseAnimating
+	//---------------------------------
+	float			GetIdealAccel() const { return GetIdealSpeed(); }
+
+	//---------------------------------
+	// Behavior
+	//---------------------------------
+	void			NPCThink();
+	void			PrescheduleThink();
+	void			GatherConditions();
+	void			CollectSiegeTargets();
+	void			ManageSiegeTargets();
+	void			KillCurrentSiegeTarget();
+	bool			QueryHearSound( CSound *pSound );
+	void			OnSeeEntity( CBaseEntity *pEntity );
+	void			CheckFlinches() {} // Hunter handles on own
+	void			BuildScheduleTestBits();
+	NPC_STATE		SelectIdealState();
+	int				SelectSchedule();
+	int				SelectCombatSchedule();
+	int				SelectSiegeSchedule();
+	int				TranslateSchedule( int scheduleType );
+	void			StartTask( const Task_t *pTask );
+	void			RunTask( const Task_t *pTask );
+	Activity		NPC_TranslateActivity( Activity baseAct );
+	void			OnChangeActivity( Activity eNewActivity );
+	
+	void			HandleAnimEvent( animevent_t *pEvent );
+	bool			HandleInteraction(int interactionType, void *data, CBaseCombatCharacter *pSourceEnt);
+
+	void			PlayerHasIlluminatedNPC( CBasePlayer *pPlayer, float flDot );
+
+	void			AddEntityRelationship( CBaseEntity *pEntity, Disposition_t nDisposition, int nPriority );
+	float			EnemyDistTolerance() { return 100.0f; }
+
+	bool			ScheduledMoveToGoalEntity( int scheduleType, CBaseEntity *pGoalEntity, Activity movementActivity );
+
+	void			OnChangeHintGroup( string_t oldGroup, string_t newGroup );
+
+	bool			IsUsingSiegeTargets()	{ return m_iszSiegeTargetName != NULL_STRING; }
+	
+	//---------------------------------
+	// Inputs
+	//---------------------------------
+	void			InputDodge( inputdata_t &inputdata );
+	void			InputFlankEnemy( inputdata_t &inputdata );
+	void			InputDisableShooting( inputdata_t &inputdata );
+	void			InputEnableShooting( inputdata_t &inputdata );
+	void			InputFollowStrider( inputdata_t &inputdata );
+	void			InputUseSiegeTargets( inputdata_t &inputdata );
+	void			InputEnableSquadShootDelay( inputdata_t &inputdata );
+	void			InputDisableSquadShootDelay( inputdata_t &inputdata );
+	void			InputEnableUnplantedShooting( inputdata_t &inputdata );
+	void			InputDisableUnplantedShooting( inputdata_t &inputdata );
+
+	//---------------------------------
+	// Combat
+	//---------------------------------
+	bool			FVisible( CBaseEntity *pEntity, int traceMask = MASK_BLOCKLOS, CBaseEntity **ppBlocker = NULL );
+	bool			IsValidEnemy( CBaseEntity *pEnemy );
+	
+	Disposition_t	IRelationType( CBaseEntity *pTarget );
+	int				IRelationPriority( CBaseEntity *pTarget );
+
+	void			SetSquad( CAI_Squad *pSquad );
+
+	bool			UpdateEnemyMemory( CBaseEntity *pEnemy, const Vector &position, CBaseEntity *pInformer = NULL );
+
+	int				RangeAttack1Conditions( float flDot, float flDist );
+	int				RangeAttack2Conditions( float flDot, float flDist );
+
+	int				MeleeAttack1Conditions ( float flDot, float flDist );
+	int				MeleeAttack1ConditionsVsEnemyInVehicle( CBaseCombatCharacter *pEnemy, float flDot );
+
+	int				MeleeAttack2Conditions( float flDot, float flDist );
+
+	bool			WeaponLOSCondition(const Vector &ownerPos, const Vector &targetPos, bool bSetConditions);
+	bool			TestShootPosition(const Vector &vecShootPos, const Vector &targetPos );
+
+	Vector			Weapon_ShootPosition();
+
+	CBaseEntity *	MeleeAttack( float flDist, int iDamage, QAngle &qaViewPunch, Vector &vecVelocityPunch, int BloodOrigin );
+
+	void			MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType );
+	void			DoMuzzleFlash( int nAttachment );
+
+	bool			CanShootThrough( const trace_t &tr, const Vector &vecTarget );
+
+	int				CountRangedAttackers();
+	void 			DelayRangedAttackers( float minDelay, float maxDelay, bool bForced = false );
+
+	//---------------------------------
+	//	Sounds & speech
+	//---------------------------------
+	void			AlertSound();
+	void			PainSound( const CTakeDamageInfo &info );
+	void			DeathSound( const CTakeDamageInfo &info );
+
+	//---------------------------------
+	// Damage handling
+	//---------------------------------
+	void			TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator );
+	bool			IsHeavyDamage( const CTakeDamageInfo &info );
+	int				OnTakeDamage( const CTakeDamageInfo &info );
+	int				OnTakeDamage_Alive( const CTakeDamageInfo &info );
+	void			Event_Killed( const CTakeDamageInfo &info );
+
+	void			StartBleeding();
+	inline bool		IsBleeding() { return m_bIsBleeding; }
+	void			Explode();
+
+	void			SetupGlobalModelData();
+	
+	//---------------------------------
+	// Navigation & Movement
+	//---------------------------------
+	bool			OverrideMoveFacing( const AILocalMoveGoal_t &move, float flInterval );
+	float			MaxYawSpeed();
+	bool			IsJumpLegal(const Vector &startPos, const Vector &apex, const Vector &endPos) const;
+	float			GetJumpGravity() const		{ return 3.0f; }
+	bool			ShouldProbeCollideAgainstEntity( CBaseEntity *pEntity );
+	void            TaskFail( AI_TaskFailureCode_t code );
+	void			TaskFail( const char *pszGeneralFailText )	{ TaskFail( MakeFailCode( pszGeneralFailText ) ); }
+
+	CAI_BaseNPC *	GetEntity() { return this; }
+
+	//---------------------------------
+	// Magnade
+	//---------------------------------	
+	void	StriderBusterAttached( CBaseEntity *pAttached );
+	void	StriderBusterDetached( CBaseEntity *pAttached );
+
+private:
+
+	void ConsiderFlinching( const CTakeDamageInfo &info );
+
+	void TaskFindDodgeActivity();
+
+	void GatherChargeConditions();
+	void GatherIndoorOutdoorConditions();
+
+	// Charge attack.
+	bool ShouldCharge( const Vector &startPos, const Vector &endPos, bool useTime, bool bCheckForCancel );
+	void ChargeLookAhead();
+	float ChargeSteer();
+	bool EnemyIsRightInFrontOfMe( CBaseEntity **pEntity );
+	void ChargeDamage( CBaseEntity *pTarget );
+	bool HandleChargeImpact( Vector vecImpact, CBaseEntity *pEntity );
+
+	void BeginVolley( int nNum, float flStartTime );
+	bool ShootFlechette( CBaseEntity *pTargetEntity, bool bSingleShot );
+	bool ShouldSeekTarget( CBaseEntity *pTargetEntity, bool bStriderBuster );
+	void GetShootDir( Vector &vecDir, const Vector &vecSrc, CBaseEntity *pTargetEntity, bool bStriderbuster, int nShotNum, bool bSingleShot );
+	bool ClampShootDir( Vector &vecDir );
+
+	void SetAim( const Vector &aimDir, float flInterval );
+	void RelaxAim( float flInterval );
+	void UpdateAim();
+	void UpdateEyes();
+	void LockBothEyes( float flDuration );
+	void UnlockBothEyes( float flDuration );
+
+	void TeslaThink();
+	void BleedThink();
+	void JostleVehicleThink();
+
+	void FollowStrider( const char *szStrider );
+	void FollowStrider( CNPC_Strider * pStrider );
+	int NumHuntersInMySquad();
+
+	bool CanPlantHere( const Vector &vecPos );
+
+	//---------------------------------
+	// Foot handling
+	//---------------------------------
+	Vector LeftFootHit( float eventtime );
+	Vector RightFootHit( float eventtime );
+	Vector BackFootHit( float eventtime );
+
+	void FootFX( const Vector &origin );
+
+	CBaseEntity *GetEnemyVehicle();
+	bool IsCorporealEnemy( CBaseEntity *pEnemy );
+
+	void PhysicsDamageEffect( const Vector &vecPos, const Vector &vecDir );
+	bool PlayerFlashlightOnMyEyes( CBasePlayer *pPlayer );
+
+	//-----------------------------------------------------
+	// Conditions, Schedules, Tasks
+	//-----------------------------------------------------
+	enum 
+	{
+		SCHED_HUNTER_RANGE_ATTACK1 = BaseClass::NEXT_SCHEDULE,
+		SCHED_HUNTER_RANGE_ATTACK2,
+		SCHED_HUNTER_MELEE_ATTACK1,
+		SCHED_HUNTER_DODGE,
+		SCHED_HUNTER_CHASE_ENEMY,
+		SCHED_HUNTER_CHASE_ENEMY_MELEE,
+		SCHED_HUNTER_COMBAT_FACE,
+		SCHED_HUNTER_FLANK_ENEMY,
+		SCHED_HUNTER_CHANGE_POSITION,
+		SCHED_HUNTER_CHANGE_POSITION_FINISH,
+		SCHED_HUNTER_SIDESTEP,
+		SCHED_HUNTER_PATROL,
+		SCHED_HUNTER_FLINCH_STICKYBOMB,
+		SCHED_HUNTER_STAGGER,
+		SCHED_HUNTER_PATROL_RUN,
+		SCHED_HUNTER_TAKE_COVER_FROM_ENEMY,
+		SCHED_HUNTER_HIDE_UNDER_COVER,
+		SCHED_HUNTER_FAIL_IMMEDIATE, // instant fail without waiting
+		SCHED_HUNTER_CHARGE_ENEMY,
+		SCHED_HUNTER_FAIL_CHARGE_ENEMY,
+		SCHED_HUNTER_FOUND_ENEMY,
+		SCHED_HUNTER_FOUND_ENEMY_ACK,
+		SCHED_HUNTER_RANGE_ATTACK2_VS_STRIDERBUSTER,
+		SCHED_HUNTER_RANGE_ATTACK2_VS_STRIDERBUSTER_LATENT,
+		SCHED_HUNTER_GOTO_HINT,
+		SCHED_HUNTER_CLEAR_HINTNODE,
+		SCHED_HUNTER_FAIL_DODGE,
+		SCHED_HUNTER_SIEGE_STAND,
+		SCHED_HUNTER_CHANGE_POSITION_SIEGE,
+
+		TASK_HUNTER_AIM = BaseClass::NEXT_TASK,
+		TASK_HUNTER_FIND_DODGE_POSITION,
+		TASK_HUNTER_DODGE,
+		TASK_HUNTER_PRE_RANGE_ATTACK2,
+		TASK_HUNTER_SHOOT_COMMIT,
+		TASK_HUNTER_BEGIN_FLANK,
+		TASK_HUNTER_ANNOUNCE_FLANK,
+		TASK_HUNTER_STAGGER,
+		TASK_HUNTER_CORNERED_TIMER,
+		TASK_HUNTER_FIND_SIDESTEP_POSITION,
+		TASK_HUNTER_CHARGE,
+		TASK_HUNTER_CHARGE_DELAY,
+		TASK_HUNTER_FINISH_RANGE_ATTACK,
+		TASK_HUNTER_WAIT_FOR_MOVEMENT_FACING_ENEMY,
+
+		COND_HUNTER_SHOULD_PATROL = BaseClass::NEXT_CONDITION,
+		COND_HUNTER_FORCED_FLANK_ENEMY,
+		COND_HUNTER_FORCED_DODGE,
+		COND_HUNTER_CAN_CHARGE_ENEMY,
+		COND_HUNTER_HIT_BY_STICKYBOMB,
+		COND_HUNTER_STAGGERED,
+		COND_HUNTER_IS_INDOORS,
+		COND_HUNTER_SEE_STRIDERBUSTER,
+		COND_HUNTER_INCOMING_VEHICLE,
+		COND_HUNTER_NEW_HINTGROUP,
+		COND_HUNTER_CANT_PLANT,
+		COND_HUNTER_SQUADMATE_FOUND_ENEMY,
+	};
+
+	enum HunterEyeStates_t
+	{
+		HUNTER_EYE_STATE_TOP_LOCKED = 0,
+		HUNTER_EYE_STATE_BOTTOM_LOCKED,
+		HUNTER_EYE_STATE_BOTH_LOCKED,
+		HUNTER_EYE_STATE_BOTH_UNLOCKED,
+	};
+
+	string_t		m_iszFollowTarget;		// Name of the strider we should follow.
+	CSimpleStopwatch m_BeginFollowDelay;
+
+	int				m_nKillingDamageType;
+	HunterEyeStates_t m_eEyeState;
+
+	float			m_aimYaw;
+	float			m_aimPitch;
+
+	float			m_flShootAllowInterruptTime;
+	float			m_flNextChargeTime;				// Prevents us from doing our threat display too often.
+	float			m_flNextDamageTime;
+	float			m_flNextSideStepTime;
+
+	CSimpleSimTimer m_HeavyDamageDelay;
+	CSimpleSimTimer m_FlinchTimer;
+	CSimpleSimTimer m_EyeSwitchTimer;		// Controls how often we switch which eye is focusing on our enemy.
+
+	bool			m_bTopMuzzle;	// Used to alternate between top muzzle FX and bottom muzzle FX.
+	bool			m_bEnableSquadShootDelay;
+	bool			m_bIsBleeding;
+
+	Activity		m_eDodgeActivity;
+	CSimpleSimTimer m_RundownDelay;
+	CSimpleSimTimer m_IgnoreVehicleTimer;
+
+	bool m_bDisableShooting;	// Range attack disabled via an input. Used for scripting melee attacks.
+	
+	bool m_bFlashlightInEyes;	// The player is shining the flashlight on our eyes.
+	float m_flPupilDilateTime;	// When to dilate our pupils if the flashlight is no longer on our eyes.
+
+	Vector m_vecEnemyLastSeen;
+	Vector m_vecLastCanPlantHerePos;
+	Vector m_vecStaggerDir;
+
+	bool m_bPlanted;
+	bool m_bLastCanPlantHere;
+	bool m_bMissLeft;
+	bool m_bEnableUnplantedShooting;
+
+	static float	gm_flMinigunDistZ;
+	static Vector	gm_vecLocalRelativePositionMinigun;
+
+	static int gm_nTopGunAttachment;
+	static int gm_nBottomGunAttachment;
+	static int gm_nAimYawPoseParam;
+	static int gm_nAimPitchPoseParam;
+	static int gm_nBodyYawPoseParam;
+	static int gm_nBodyPitchPoseParam;
+	static int gm_nStaggerYawPoseParam;
+	static int gm_nHeadCenterAttachment;
+	static int gm_nHeadBottomAttachment;
+	static float gm_flHeadRadius;
+
+	static int gm_nUnplantedNode;
+	static int gm_nPlantedNode;
+
+	CAI_HunterEscortBehavior m_EscortBehavior;
+
+	int m_nFlechettesQueued;
+	int m_nClampedShots;				// The number of consecutive shots fired at an out-of-max yaw target.
+
+	float m_flNextRangeAttack2Time;		// Time when we can fire another volley of flechettes.
+	float m_flNextFlechetteTime;		// Time to fire the next flechette in this volley.
+	
+	float m_flNextMeleeTime;
+	float m_flTeslaStopTime;
+
+	string_t m_iszCurrentExpression;
+
+	// buster fu	
+	CUtlVector< EHANDLE >	m_hAttachedBusters;		// List of busters attached to us
+	float m_fCorneredTimer; ///< hunter was cornered when fleeing player; it won't flee again until this time
+
+	CSimpleSimTimer m_CheckHintGroupTimer;
+
+	DEFINE_CUSTOM_AI;
+
+	DECLARE_DATADESC();
+
+	friend class CAI_HunterEscortBehavior;
+	friend class CHunterMaker;
+
+	bool	m_bInLargeOutdoorMap;
+	float	m_flTimeSawEnemyAgain;
+
+	// Sounds
+	//CSoundPatch	*m_pGunFiringSound;
+
+	CUtlVector<EHANDLE> m_pSiegeTargets;
+	string_t	m_iszSiegeTargetName;
+	float		m_flTimeNextSiegeTargetAttack;
+	EHANDLE		m_hCurrentSiegeTarget;
+	
+	EHANDLE		m_hHitByVehicle;
+};
+
+
+LINK_ENTITY_TO_CLASS( npc_hunter, CNPC_Hunter );
+
+
+BEGIN_DATADESC( CNPC_Hunter )
+
+	DEFINE_KEYFIELD( m_iszFollowTarget, FIELD_STRING, "FollowTarget" ),
+
+	DEFINE_FIELD( m_aimYaw,				FIELD_FLOAT ),
+	DEFINE_FIELD( m_aimPitch,				FIELD_FLOAT ),
+
+	DEFINE_FIELD( m_flShootAllowInterruptTime, FIELD_TIME ),
+	DEFINE_FIELD( m_flNextChargeTime, FIELD_TIME ),
+	//DEFINE_FIELD( m_flNextDamageTime, FIELD_TIME ),
+	DEFINE_FIELD( m_flNextSideStepTime, FIELD_TIME ),
+
+	DEFINE_EMBEDDED( m_HeavyDamageDelay ),
+	DEFINE_EMBEDDED( m_FlinchTimer ),
+
+	DEFINE_FIELD( m_eEyeState, FIELD_INTEGER ),
+
+	DEFINE_FIELD( m_bTopMuzzle, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_bEnableSquadShootDelay, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_bIsBleeding, FIELD_BOOLEAN ),
+
+	DEFINE_FIELD( m_bDisableShooting, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_bFlashlightInEyes, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_flPupilDilateTime, FIELD_TIME ),
+
+	DEFINE_FIELD( m_vecEnemyLastSeen, FIELD_POSITION_VECTOR ),
+	DEFINE_FIELD( m_vecLastCanPlantHerePos, FIELD_POSITION_VECTOR ),
+	DEFINE_FIELD( m_vecStaggerDir, FIELD_VECTOR ),
+	
+	DEFINE_FIELD( m_bPlanted, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_bLastCanPlantHere, FIELD_BOOLEAN ),
+	//DEFINE_FIELD( m_bMissLeft, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_bEnableUnplantedShooting, FIELD_BOOLEAN ),
+
+	DEFINE_FIELD( m_nKillingDamageType, FIELD_INTEGER ),
+	DEFINE_FIELD( m_eDodgeActivity, FIELD_INTEGER ),
+	DEFINE_EMBEDDED( m_RundownDelay ),
+	DEFINE_EMBEDDED( m_IgnoreVehicleTimer ),
+
+	DEFINE_FIELD( m_flNextMeleeTime, FIELD_TIME ),
+	DEFINE_FIELD( m_flTeslaStopTime, FIELD_TIME ),
+
+	// (auto saved by AI)
+	//DEFINE_FIELD( m_EscortBehavior, FIELD_EMBEDDED ),	
+
+	DEFINE_FIELD( m_iszCurrentExpression, FIELD_STRING ),
+
+	DEFINE_FIELD( m_fCorneredTimer, FIELD_TIME),
+
+	DEFINE_EMBEDDED( m_CheckHintGroupTimer ),
+
+	// (Recomputed in Precache())
+	//DEFINE_FIELD( m_bInLargeOutdoorMap, FIELD_BOOLEAN ), 
+	DEFINE_FIELD( m_flTimeSawEnemyAgain, FIELD_TIME ),
+
+	//DEFINE_SOUNDPATCH( m_pGunFiringSound ),
+
+	//DEFINE_UTLVECTOR( m_pSiegeTarget, FIELD_EHANDLE ),
+	DEFINE_FIELD( m_iszSiegeTargetName, FIELD_STRING ),
+	DEFINE_FIELD( m_flTimeNextSiegeTargetAttack, FIELD_TIME ),
+	DEFINE_FIELD( m_hCurrentSiegeTarget, FIELD_EHANDLE ),
+	DEFINE_FIELD( m_hHitByVehicle, FIELD_EHANDLE ),
+
+	DEFINE_EMBEDDED( m_BeginFollowDelay ),
+	DEFINE_EMBEDDED( m_EyeSwitchTimer ),
+
+	DEFINE_FIELD( m_nFlechettesQueued, FIELD_INTEGER ),
+	DEFINE_FIELD( m_nClampedShots, FIELD_INTEGER ),
+	DEFINE_FIELD( m_flNextRangeAttack2Time, FIELD_TIME ),
+	DEFINE_FIELD( m_flNextFlechetteTime, FIELD_TIME ),
+	DEFINE_UTLVECTOR( m_hAttachedBusters, FIELD_EHANDLE ),
+	DEFINE_UTLVECTOR( m_pSiegeTargets, FIELD_EHANDLE ),
+
+	// inputs
+	DEFINE_INPUTFUNC( FIELD_VOID, "Dodge", InputDodge ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "FlankEnemy", InputFlankEnemy ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "DisableShooting", InputDisableShooting ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "EnableShooting", InputEnableShooting ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "FollowStrider", InputFollowStrider ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "UseSiegeTargets", InputUseSiegeTargets ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "EnableSquadShootDelay", InputEnableSquadShootDelay ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "DisableSquadShootDelay", InputDisableSquadShootDelay ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "EnableUnplantedShooting", InputEnableUnplantedShooting ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "DisableUnplantedShooting", InputDisableUnplantedShooting ),
+
+	// Function Pointers
+	DEFINE_THINKFUNC( TeslaThink ),
+	DEFINE_THINKFUNC( BleedThink ),
+	DEFINE_THINKFUNC( JostleVehicleThink ),
+
+END_DATADESC()
+
+//-----------------------------------------------------------------------------
+
+int CNPC_Hunter::gm_nUnplantedNode = 0;
+int CNPC_Hunter::gm_nPlantedNode = 0;
+
+int CNPC_Hunter::gm_nAimYawPoseParam = -1;
+int CNPC_Hunter::gm_nAimPitchPoseParam = -1;
+int CNPC_Hunter::gm_nBodyYawPoseParam = -1;
+int CNPC_Hunter::gm_nBodyPitchPoseParam = -1;
+int CNPC_Hunter::gm_nStaggerYawPoseParam = -1;
+int CNPC_Hunter::gm_nHeadCenterAttachment = -1;
+int CNPC_Hunter::gm_nHeadBottomAttachment = -1;
+float CNPC_Hunter::gm_flHeadRadius = 0;
+
+int CNPC_Hunter::gm_nTopGunAttachment = -1;
+int CNPC_Hunter::gm_nBottomGunAttachment = -1;
+
+float CNPC_Hunter::gm_flMinigunDistZ;
+Vector CNPC_Hunter::gm_vecLocalRelativePositionMinigun;
+
+//-----------------------------------------------------------------------------
+
+static CUtlVector<CNPC_Hunter *> g_Hunters;
+float g_TimeLastDistributeFreeHunters = -1;
+const float FREE_HUNTER_DISTRIBUTE_INTERVAL = 2;
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+CNPC_Hunter::CNPC_Hunter()
+{
+	g_Hunters.AddToTail( this );
+	g_TimeLastDistributeFreeHunters = -1;
+	m_flTimeSawEnemyAgain = HUNTER_SEE_ENEMY_TIME_INVALID;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+CNPC_Hunter::~CNPC_Hunter()
+{
+	g_Hunters.FindAndRemove( this );
+	g_TimeLastDistributeFreeHunters = -1;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::Precache()
+{
+	PrecacheModel( "models/hunter.mdl" );
+	PropBreakablePrecacheAll( MAKE_STRING("models/hunter.mdl") );
+
+	PrecacheScriptSound( "NPC_Hunter.Idle" );
+	PrecacheScriptSound( "NPC_Hunter.Scan" );
+	PrecacheScriptSound( "NPC_Hunter.Alert" );
+	PrecacheScriptSound( "NPC_Hunter.Pain" );
+	PrecacheScriptSound( "NPC_Hunter.PreCharge" );
+	PrecacheScriptSound( "NPC_Hunter.Angry" );
+	PrecacheScriptSound( "NPC_Hunter.Death" );
+	PrecacheScriptSound( "NPC_Hunter.FireMinigun" );
+	PrecacheScriptSound( "NPC_Hunter.Footstep" );
+	PrecacheScriptSound( "NPC_Hunter.BackFootstep" );
+	PrecacheScriptSound( "NPC_Hunter.FlechetteVolleyWarn" );
+	PrecacheScriptSound( "NPC_Hunter.FlechetteShoot" );
+	PrecacheScriptSound( "NPC_Hunter.FlechetteShootLoop" );
+	PrecacheScriptSound( "NPC_Hunter.FlankAnnounce" );
+	PrecacheScriptSound( "NPC_Hunter.MeleeAnnounce" );
+	PrecacheScriptSound( "NPC_Hunter.MeleeHit" );
+	PrecacheScriptSound( "NPC_Hunter.TackleAnnounce" );
+	PrecacheScriptSound( "NPC_Hunter.TackleHit" );
+	PrecacheScriptSound( "NPC_Hunter.ChargeHitEnemy" );
+	PrecacheScriptSound( "NPC_Hunter.ChargeHitWorld" );
+	PrecacheScriptSound( "NPC_Hunter.FoundEnemy" );
+	PrecacheScriptSound( "NPC_Hunter.FoundEnemyAck" );
+	PrecacheScriptSound( "NPC_Hunter.DefendStrider" );
+	PrecacheScriptSound( "NPC_Hunter.HitByVehicle" );
+
+	PrecacheParticleSystem( "hunter_muzzle_flash" );
+	PrecacheParticleSystem( "blood_impact_synth_01" );
+	PrecacheParticleSystem( "blood_impact_synth_01_arc_parent" );
+	PrecacheParticleSystem( "blood_spurt_synth_01" );
+	PrecacheParticleSystem( "blood_drip_synth_01" );
+
+	PrecacheInstancedScene( "scenes/npc/hunter/hunter_scan.vcd" );
+	PrecacheInstancedScene( "scenes/npc/hunter/hunter_eyeclose.vcd" );
+	PrecacheInstancedScene( "scenes/npc/hunter/hunter_roar.vcd" );
+	PrecacheInstancedScene( "scenes/npc/hunter/hunter_pain.vcd" );
+	PrecacheInstancedScene( "scenes/npc/hunter/hunter_eyedarts_top.vcd" );
+	PrecacheInstancedScene( "scenes/npc/hunter/hunter_eyedarts_bottom.vcd" );
+	
+	PrecacheMaterial( "effects/water_highlight" );
+
+	UTIL_PrecacheOther( "hunter_flechette" );
+	UTIL_PrecacheOther( "sparktrail" );
+
+	m_bInLargeOutdoorMap = false;
+	if( !Q_strnicmp( STRING(gpGlobals->mapname), "ep2_outland_12", 14) )
+	{
+		m_bInLargeOutdoorMap = true;
+	}
+
+	BaseClass::Precache();
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::Spawn()
+{
+	Precache();
+
+	SetModel( "models/hunter.mdl" );
+	BaseClass::Spawn();
+
+	//m_debugOverlays |= OVERLAY_NPC_ROUTE_BIT | OVERLAY_BBOX_BIT | OVERLAY_PIVOT_BIT;
+
+	SetHullType( HULL_MEDIUM_TALL );
+	SetHullSizeNormal();
+	SetDefaultEyeOffset();
+	
+	SetNavType( NAV_GROUND );
+	m_flGroundSpeed	= 500;
+	m_NPCState = NPC_STATE_NONE;
+
+	SetBloodColor( DONT_BLEED );
+	
+	m_iHealth = m_iMaxHealth = sk_hunter_health.GetInt();
+
+	m_flFieldOfView = HUNTER_FOV_DOT;
+
+	SetSolid( SOLID_BBOX );
+	AddSolidFlags( FSOLID_NOT_STANDABLE );
+	SetMoveType( MOVETYPE_STEP );
+
+	SetupGlobalModelData();
+	
+	CapabilitiesAdd( bits_CAP_MOVE_GROUND | bits_CAP_SQUAD | bits_CAP_ANIMATEDFACE );
+	CapabilitiesAdd( bits_CAP_INNATE_RANGE_ATTACK1 | bits_CAP_INNATE_RANGE_ATTACK2 | bits_CAP_INNATE_MELEE_ATTACK1 );
+	CapabilitiesAdd( bits_CAP_SKIP_NAV_GROUND_CHECK );
+
+	if ( !hunter_allow_dissolve.GetBool() )
+	{
+		AddEFlags( EFL_NO_DISSOLVE );
+	}
+
+	if( hunter_allow_nav_jump.GetBool() )
+	{
+		CapabilitiesAdd( bits_CAP_MOVE_JUMP );
+	}
+
+	NPCInit();
+
+	m_bEnableSquadShootDelay = true;
+
+	m_flDistTooFar = hunter_flechette_max_range.GetFloat();
+
+	// Discard time must be greater than free knowledge duration. Make it double.
+	float freeKnowledge = hunter_free_knowledge.GetFloat();
+	if ( freeKnowledge < GetEnemies()->GetEnemyDiscardTime() )
+	{
+		GetEnemies()->SetEnemyDiscardTime( MAX( freeKnowledge + 0.1, AI_DEF_ENEMY_DISCARD_TIME ) );
+	}
+	GetEnemies()->SetFreeKnowledgeDuration( freeKnowledge );
+
+	// Find out what strider we should follow, if any.
+	if ( m_iszFollowTarget != NULL_STRING )
+	{
+		m_BeginFollowDelay.Set( .1 ); // Allow time for strider to spawn
+	}
+
+	//if ( !m_pGunFiringSound )
+	//{
+	//	CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+	//	CPASAttenuationFilter filter( this );
+	//
+	//	m_pGunFiringSound = controller.SoundCreate( filter, entindex(), "NPC_Hunter.FlechetteShootLoop" );
+	//	controller.Play( m_pGunFiringSound, 0.0, 100 );
+	//}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::UpdateEfficiency( bool bInPVS )
+{
+	SetEfficiency( ( GetSleepState() != AISS_AWAKE ) ? AIE_DORMANT : AIE_NORMAL );
+	SetMoveEfficiency( AIME_NORMAL );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::CreateBehaviors()
+{
+	AddBehavior( &m_EscortBehavior );
+
+	return BaseClass::CreateBehaviors();
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::SetupGlobalModelData()
+{
+	if ( gm_nBodyYawPoseParam != -1 )
+		return;
+
+	gm_nAimYawPoseParam = LookupPoseParameter( "aim_yaw" );
+	gm_nAimPitchPoseParam = LookupPoseParameter( "aim_pitch" );
+
+	gm_nBodyYawPoseParam = LookupPoseParameter( "body_yaw" );
+	gm_nBodyPitchPoseParam = LookupPoseParameter( "body_pitch" );
+
+	gm_nTopGunAttachment = LookupAttachment( "top_eye" );
+	gm_nBottomGunAttachment = LookupAttachment( "bottom_eye" );
+	gm_nStaggerYawPoseParam = LookupAttachment( "stagger_yaw" );
+	
+	gm_nHeadCenterAttachment = LookupAttachment( "head_center" );
+	gm_nHeadBottomAttachment = LookupAttachment( "head_radius_measure" );
+
+	// Measure the radius of the head.	
+	Vector vecHeadCenter;
+	Vector vecHeadBottom;
+	GetAttachment( gm_nHeadCenterAttachment, vecHeadCenter );
+	GetAttachment( gm_nHeadBottomAttachment, vecHeadBottom );
+	gm_flHeadRadius = ( vecHeadCenter - vecHeadBottom ).Length();
+
+	int nSequence = SelectWeightedSequence( ACT_HUNTER_RANGE_ATTACK2_UNPLANTED );
+	gm_nUnplantedNode = GetEntryNode( nSequence );
+
+	nSequence = SelectWeightedSequence( ACT_RANGE_ATTACK2 );
+	gm_nPlantedNode = GetEntryNode( nSequence );
+
+	CollisionProp()->SetSurroundingBoundsType( USE_HITBOXES );
+}
+
+
+//-----------------------------------------------------------------------------
+// Shuts down looping sounds when we are killed in combat or deleted.
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::StopLoopingSounds()
+{
+	BaseClass::StopLoopingSounds();
+
+	//if ( m_pGunFiringSound )
+	//{
+	//	CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+	//	controller.SoundDestroy( m_pGunFiringSound );
+	//	m_pGunFiringSound = NULL;
+	//}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::OnRestore()
+{
+	BaseClass::OnRestore();
+	SetupGlobalModelData();
+	CreateVPhysics();
+	
+	if ( IsBleeding() )
+	{
+		StartBleeding();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::IdleSound()
+{
+	if ( HasCondition( COND_LOST_ENEMY ) )
+	{
+		EmitSound( "NPC_Hunter.Scan" );
+	}
+	else
+	{
+		EmitSound( "NPC_Hunter.Idle" );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::ShouldPlayIdleSound()
+{
+	if ( random->RandomInt(0, 99) == 0 && !HasSpawnFlags( SF_NPC_GAG ) )
+		return true;
+	
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Stay facing our enemy when close enough.
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::OverrideMoveFacing( const AILocalMoveGoal_t &move, float flInterval )
+{
+	if ( GetActivity() == ACT_TRANSITION )
+	{
+		// No turning while in transitions.
+		return true;
+	}
+
+ 	bool bSideStepping = IsCurSchedule( SCHED_HUNTER_SIDESTEP, false );
+ 	
+  	// FIXME: this will break scripted sequences that walk when they have an enemy
+  	if ( GetEnemy() &&
+  		( bSideStepping ||
+  		( ( ( GetNavigator()->GetMovementActivity() == ACT_RUN ) || ( GetNavigator()->GetMovementActivity() == ACT_WALK ) ) &&
+		  !IsCurSchedule( SCHED_HUNTER_TAKE_COVER_FROM_ENEMY, false ) ) ) )
+	{
+		Vector vecEnemyLKP = GetEnemyLKP();
+		
+		// Face my enemy if we're close enough
+		if ( bSideStepping || UTIL_DistApprox( vecEnemyLKP, GetAbsOrigin() ) < HUNTER_FACE_ENEMY_DIST )
+		{
+			AddFacingTarget( GetEnemy(), vecEnemyLKP, 1.0, 0.2 );
+		}
+	}
+
+	return BaseClass::OverrideMoveFacing( move, flInterval );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::PostNPCInit()
+{
+	BaseClass::PostNPCInit();
+
+	IPhysicsObject *pPhysObject = VPhysicsGetObject();
+	Assert( pPhysObject );
+	if ( pPhysObject )
+	{
+		pPhysObject->SetMass( 600.0 );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::Activate()
+{
+	BaseClass::Activate();
+
+	s_iszStriderBusterClassname = AllocPooledString( "weapon_striderbuster" );
+	s_iszStriderClassname  = AllocPooledString( "npc_strider" );
+	s_iszMagnadeClassname = AllocPooledString( "npc_grenade_magna" );
+	s_iszPhysPropClassname = AllocPooledString( "prop_physics" );
+	s_iszHuntersToRunOver = AllocPooledString( "hunters_to_run_over" );
+	
+	// If no one has initialized the hunters to run over counter, just zero it out.
+	if ( !GlobalEntity_IsInTable( s_iszHuntersToRunOver ) )
+	{
+		GlobalEntity_Add( s_iszHuntersToRunOver, gpGlobals->mapname, GLOBAL_ON );
+		GlobalEntity_SetCounter( s_iszHuntersToRunOver, 0 );
+	}
+
+	CMissile::AddCustomDetonator( this, ( GetHullMaxs().AsVector2D() - GetHullMins().AsVector2D() ).Length() * 0.5, GetHullHeight() );
+
+	SetupGlobalModelData();
+	
+	if ( gm_flMinigunDistZ == 0 )
+	{
+		// Have to create a virgin hunter to ensure proper pose
+		CNPC_Hunter *pHunter = (CNPC_Hunter *)CreateEntityByName( "npc_hunter" );
+		Assert(pHunter);
+		pHunter->Spawn();
+
+		pHunter->SetActivity( ACT_WALK );
+		pHunter->InvalidateBoneCache();
+
+		// Currently just using the gun for the vertical component!
+		Vector defEyePos;
+		pHunter->GetAttachment( "minigunbase", defEyePos );
+		gm_flMinigunDistZ = defEyePos.z - pHunter->GetAbsOrigin().z;
+
+		Vector position;
+		pHunter->GetAttachment( gm_nTopGunAttachment, position );
+		VectorITransform( position, pHunter->EntityToWorldTransform(), gm_vecLocalRelativePositionMinigun );
+		UTIL_Remove( pHunter );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::UpdateOnRemove()
+{
+	CMissile::RemoveCustomDetonator( this );
+	BaseClass::UpdateOnRemove();
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+Class_T CNPC_Hunter::Classify()
+{
+	return CLASS_COMBINE_HUNTER;
+}
+
+//-----------------------------------------------------------------------------
+// Compensate for the hunter's long legs by moving the bodytarget up to his head.
+//-----------------------------------------------------------------------------
+Vector CNPC_Hunter::BodyTarget( const Vector &posSrc, bool bNoisy /*= true*/ )
+{ 
+	Vector vecResult;
+	QAngle vecAngle;
+	GetAttachment( gm_nHeadCenterAttachment, vecResult, vecAngle );
+
+	if ( bNoisy )
+	{
+		float rand1 = random->RandomFloat( 0, gm_flHeadRadius ) + random->RandomFloat( 0, gm_flHeadRadius );
+		return vecResult + RandomVector( -rand1, rand1 );
+	}
+
+	return vecResult;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int	CNPC_Hunter::DrawDebugTextOverlays()
+{
+	int text_offset = BaseClass::DrawDebugTextOverlays();
+
+	if (m_debugOverlays & OVERLAY_TEXT_BIT)
+	{
+		EntityText( text_offset, CFmtStr("%s", m_bPlanted ? "Planted" : "Unplanted" ), 0 );
+		text_offset++;
+
+		EntityText( text_offset, CFmtStr("Eye state: %d", m_eEyeState ), 0 );
+		text_offset++;
+
+		if( IsUsingSiegeTargets() )
+		{
+			EntityText( text_offset, CFmtStr("Next Siege Attempt:%f", m_flTimeNextSiegeTargetAttack - gpGlobals->curtime ), 0 );
+			text_offset++;
+		}
+	}
+
+	return text_offset;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::LockBothEyes( float flDuration )
+{
+	m_eEyeState = HUNTER_EYE_STATE_BOTH_LOCKED;
+	m_EyeSwitchTimer.Set( flDuration );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::UnlockBothEyes( float flDuration )
+{
+	m_eEyeState = HUNTER_EYE_STATE_BOTH_UNLOCKED;
+	m_EyeSwitchTimer.Set( flDuration );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::OnChangeActivity( Activity eNewActivity )
+{
+	m_EyeSwitchTimer.Force();
+	
+	BaseClass::OnChangeActivity( eNewActivity );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::UpdateEyes()
+{
+	// If the eyes are controlled by a script, do nothing.
+	if ( GetState() == NPC_STATE_SCRIPT )
+		return;
+
+	if ( m_EyeSwitchTimer.Expired() )
+	{
+		RemoveActorFromScriptedScenes( this, false );
+		
+		if ( GetActivity() == ACT_IDLE )
+		{
+			// Idles have eye motion baked in.
+			m_eEyeState = HUNTER_EYE_STATE_BOTH_LOCKED;
+		}
+		else if ( GetEnemy() == NULL )
+		{
+			m_eEyeState = HUNTER_EYE_STATE_BOTH_UNLOCKED;
+		}
+		else if ( m_eEyeState == HUNTER_EYE_STATE_BOTH_LOCKED )
+		{
+			if ( random->RandomInt( 0, 1 ) == 0 )
+			{
+				m_eEyeState = HUNTER_EYE_STATE_TOP_LOCKED;
+			}
+			else
+			{
+				m_eEyeState = HUNTER_EYE_STATE_BOTTOM_LOCKED;
+			}
+		}
+		else if ( m_eEyeState == HUNTER_EYE_STATE_TOP_LOCKED )
+		{
+			m_eEyeState = HUNTER_EYE_STATE_BOTTOM_LOCKED;
+		}
+		else if ( m_eEyeState == HUNTER_EYE_STATE_BOTTOM_LOCKED )
+		{
+			m_eEyeState = HUNTER_EYE_STATE_TOP_LOCKED;
+		}
+
+		if ( ( m_eEyeState == HUNTER_EYE_STATE_BOTTOM_LOCKED ) || ( m_eEyeState == HUNTER_EYE_STATE_BOTH_UNLOCKED ) )
+		{
+			SetExpression( "scenes/npc/hunter/hunter_eyedarts_top.vcd" );
+		}
+
+		if ( ( m_eEyeState == HUNTER_EYE_STATE_TOP_LOCKED ) || ( m_eEyeState == HUNTER_EYE_STATE_BOTH_UNLOCKED ) )
+		{
+			SetExpression( "scenes/npc/hunter/hunter_eyedarts_bottom.vcd" );
+		}
+
+		m_EyeSwitchTimer.Set( random->RandomFloat( 1.0f, 3.0f ) );
+	}
+
+	/*Vector vecEyePos;
+	Vector vecEyeDir;
+
+	GetAttachment( gm_nTopGunAttachment, vecEyePos, &vecEyeDir );
+	NDebugOverlay::Line( vecEyePos, vecEyePos + vecEyeDir * 36, 255, 0, 0, 0, 0.1 );
+
+	GetAttachment( gm_nBottomGunAttachment, vecEyePos, &vecEyeDir );
+	NDebugOverlay::Line( vecEyePos, vecEyePos + vecEyeDir * 36, 255, 0, 0, 0, 0.1 );*/
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::NPCThink()
+{
+	BaseClass::NPCThink();
+
+	// Update our planted/unplanted state.
+	m_bPlanted = ( GetEntryNode( GetSequence() ) == gm_nPlantedNode );
+
+	UpdateAim();
+	UpdateEyes();
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::PrescheduleThink()
+{
+	BaseClass::PrescheduleThink();
+	
+	if ( m_BeginFollowDelay.Expired() )
+	{
+		FollowStrider( STRING( m_iszFollowTarget ) );
+		m_BeginFollowDelay.Stop();
+	}
+
+	m_EscortBehavior.CheckBreakEscort();
+
+	// If we're being blinded by the flashlight, see if we should stop
+	if ( m_bFlashlightInEyes )
+	{
+		if ( m_flPupilDilateTime < gpGlobals->curtime )
+		{
+ 			CBasePlayer *pPlayer = UTIL_PlayerByIndex( 1 );
+ 			if ( ( pPlayer && !pPlayer->IsIlluminatedByFlashlight( this, NULL ) ) || !PlayerFlashlightOnMyEyes( pPlayer ) )
+			{
+				//Msg( "NOT SHINING FLASHLIGHT ON ME\n" );
+			
+				// Remove the actor from the flashlight scene
+				RemoveActorFromScriptedScenes( this, true, false, "scenes/npc/hunter/hunter_eyeclose.vcd" );
+				m_bFlashlightInEyes = false;
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::GatherChargeConditions()
+{
+	ClearCondition( COND_HUNTER_CAN_CHARGE_ENEMY );
+
+	if ( !hunter_charge.GetBool() )
+		return;
+		
+	if ( !GetEnemy() )
+		return;
+
+	if ( GetHintGroup() != NULL_STRING )
+		return;
+	
+	if ( !HasCondition( COND_SEE_ENEMY ) )
+		return;
+	
+	if ( !hunter_charge_test.GetBool() && gpGlobals->curtime < m_flNextChargeTime )
+		return;
+
+	// No charging Alyx or Barney
+	if( GetEnemy()->Classify() == CLASS_PLAYER_ALLY_VITAL )
+		return;
+
+	if ( m_EscortBehavior.GetEscortTarget() && GetEnemy()->MyCombatCharacterPointer() && !GetEnemy()->MyCombatCharacterPointer()->FInViewCone( this ) )
+		return;
+
+	if ( ShouldCharge( GetAbsOrigin(), GetEnemy()->GetAbsOrigin(), true, false ) )
+	{
+		SetCondition( COND_HUNTER_CAN_CHARGE_ENEMY );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::GatherConditions()
+{
+	GatherIndoorOutdoorConditions();
+	GatherChargeConditions();
+
+	BaseClass::GatherConditions();
+
+	// Enemy LKP that doesn't get updated by the free knowledge code.
+	// Used for shooting at where our enemy was when we can't see them.
+	ClearCondition( COND_HUNTER_INCOMING_VEHICLE );
+	if ( m_IgnoreVehicleTimer.Expired() && GetEnemy() && HasCondition( COND_SEE_ENEMY ) )
+	{
+		CBaseEntity *pVehicle = GetEnemyVehicle();
+		if ( ( pVehicle ) && ( GlobalEntity_GetCounter( s_iszHuntersToRunOver ) <= 0 ) )
+		{
+			static float timeDrawnArrow;
+
+			// Extrapolate the position of the vehicle and see if it's heading toward us.
+			float predictTime = hunter_dodge_warning.GetFloat();
+			Vector2D vecFuturePos = pVehicle->GetAbsOrigin().AsVector2D() + pVehicle->GetSmoothedVelocity().AsVector2D() * predictTime;
+			if ( pVehicle->GetSmoothedVelocity().LengthSqr() > Square( 200 ) )
+			{
+				float t = 0;
+				Vector2D vDirMovement = pVehicle->GetSmoothedVelocity().AsVector2D();
+				if ( hunter_dodge_debug.GetBool() )
+				{
+					NDebugOverlay::Line( pVehicle->GetAbsOrigin(), pVehicle->GetAbsOrigin() + pVehicle->GetSmoothedVelocity(), 255, 255, 255, true, .1 );
+				}
+				vDirMovement.NormalizeInPlace();
+				Vector2D vDirToHunter = GetAbsOrigin().AsVector2D() - pVehicle->GetAbsOrigin().AsVector2D();
+				vDirToHunter.NormalizeInPlace();
+				if ( DotProduct2D( vDirMovement, vDirToHunter ) > hunter_dodge_warning_cone.GetFloat() && 
+					 CalcDistanceSqrToLine2D( GetAbsOrigin().AsVector2D(), pVehicle->GetAbsOrigin().AsVector2D(), vecFuturePos, &t ) < Square( hunter_dodge_warning_width.GetFloat() * .5 ) && 
+					 t > 0.0 && t < 1.0 )
+				{
+					if ( fabs( predictTime - hunter_dodge_warning.GetFloat() ) < .05 || random->RandomInt( 0, 3 ) )
+					{
+						SetCondition( COND_HUNTER_INCOMING_VEHICLE );
+					}
+					else
+					{
+						if ( hunter_dodge_debug. GetBool() )
+						{
+							Msg( "Hunter %d failing dodge (ignore)\n", entindex() );
+						}
+					}
+
+					if ( hunter_dodge_debug. GetBool() )
+					{
+						NDebugOverlay::Cross3D( EyePosition(), 100, 255, 255, 255, true, .1 );
+						if ( timeDrawnArrow != gpGlobals->curtime )
+						{
+							timeDrawnArrow = gpGlobals->curtime;
+							Vector vEndpoint( vecFuturePos.x, vecFuturePos.y, UTIL_GetLocalPlayer()->WorldSpaceCenter().z - 24 );
+							NDebugOverlay::HorzArrow( UTIL_GetLocalPlayer()->WorldSpaceCenter() - Vector(0, 0, 24), vEndpoint, hunter_dodge_warning_width.GetFloat(), 255, 0, 0, 64, true, .1 );
+						}
+					}
+				}
+				else if ( hunter_dodge_debug.GetBool() )
+				{
+					if ( t <= 0 )
+					{
+						NDebugOverlay::Cross3D( EyePosition(), 100, 0, 0, 255, true, .1 );
+					}
+					else
+					{
+						NDebugOverlay::Cross3D( EyePosition(), 100, 0, 255, 255, true, .1 );
+					}
+				}
+			}
+			else if ( hunter_dodge_debug.GetBool() )
+			{
+				NDebugOverlay::Cross3D( EyePosition(), 100, 0, 255, 0, true, .1 );
+			}
+			if ( hunter_dodge_debug. GetBool() )
+			{
+				if ( timeDrawnArrow != gpGlobals->curtime )
+				{
+					timeDrawnArrow = gpGlobals->curtime;
+					Vector vEndpoint( vecFuturePos.x, vecFuturePos.y, UTIL_GetLocalPlayer()->WorldSpaceCenter().z - 24 );
+					NDebugOverlay::HorzArrow( UTIL_GetLocalPlayer()->WorldSpaceCenter() - Vector(0, 0, 24), vEndpoint, hunter_dodge_warning_width.GetFloat(), 127, 127, 127, 64, true, .1 );
+				}
+			}
+
+		}
+
+		m_vecEnemyLastSeen = GetEnemy()->GetAbsOrigin();
+	}
+
+	if( !HasCondition(COND_ENEMY_OCCLUDED) )
+	{
+		// m_flTimeSawEnemyAgain always tells us what time I first saw this
+		// enemy again after some period of not seeing them. This is used to
+		// compute how long the enemy has been visible to me THIS TIME. 
+		// Every time I lose sight of the enemy this time is set invalid until
+		// I see the enemy again and record that time.
+		if( m_flTimeSawEnemyAgain == HUNTER_SEE_ENEMY_TIME_INVALID )
+		{
+			m_flTimeSawEnemyAgain = gpGlobals->curtime;
+		}
+	}
+	else
+	{
+		m_flTimeSawEnemyAgain = HUNTER_SEE_ENEMY_TIME_INVALID;
+	}
+
+	ManageSiegeTargets();
+}
+
+//-----------------------------------------------------------------------------
+// Search all entities in the map
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::CollectSiegeTargets()
+{
+	CBaseEntity *pTarget = gEntList.FindEntityByName( NULL, m_iszSiegeTargetName );
+
+	while( pTarget != NULL )
+	{
+		if( pTarget->Classify() == CLASS_BULLSEYE )
+		{
+			m_pSiegeTargets.AddToTail( pTarget );
+		}
+
+		pTarget = gEntList.FindEntityByName( pTarget, m_iszSiegeTargetName );
+	};
+
+	if( m_pSiegeTargets.Count() < 1 )
+	{
+		m_iszSiegeTargetName = NULL_STRING;		// And stop trying!
+	}
+}
+
+//-----------------------------------------------------------------------------
+// For use when Hunters are outside and the player is inside a structure
+// Create a temporary bullseye in a location that makes it seem like
+// I am aware of the location of a player I cannot see. (Then fire at
+// at this bullseye, thus laying 'siege' to the part of the building he 
+// is in.) The locations are copied from suitable info_target entities.
+// (these should be placed in exterior windows and doorways so that 
+// the Hunter fires into the building through these apertures)
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::ManageSiegeTargets()
+{
+	if( gpGlobals->curtime < m_flTimeNextSiegeTargetAttack )
+		return;
+
+	if( m_pSiegeTargets.Count() == 0 )
+	{
+		// If my list of siege targets is empty, go and cache all of them now
+		// so that I don't have to search the world every time.
+		CollectSiegeTargets();
+
+		if( m_pSiegeTargets.Count() == 0 )
+			return;
+	}
+
+	m_flTimeNextSiegeTargetAttack = gpGlobals->curtime + (hunter_siege_frequency.GetFloat() * RandomFloat( 0.8f, 1.2f) );
+	CBasePlayer *pPlayer = AI_GetSinglePlayer();
+
+	// Start by assuming we are not going to create a siege target
+	bool bCreateSiegeTarget = false;
+	if( GetEnemy() == NULL )
+	{
+		// If I have no enemy at all, give it a try.
+		bCreateSiegeTarget = true;
+	}
+
+	if( bCreateSiegeTarget )
+	{
+		// We've decided that the situation calls for a siege target. So, we dig through all of my siege targets and
+		// take the closest one to the player that the player can see! (Obey they bullseye's FOV)
+		float flClosestDistSqr = Square( 1200.0f ); // Only use siege targets within 100 feet of player
+		CBaseEntity *pSiegeTargetLocation = NULL;
+		int iTraces = 0;
+		for( int i = 0 ; i < m_pSiegeTargets.Count() ; i++ )
+		{
+			CBaseEntity *pCandidate = m_pSiegeTargets[i];
+			if ( pCandidate == NULL )
+				continue;
+
+			float flDistSqr = pCandidate->GetAbsOrigin().DistToSqr(pPlayer->GetAbsOrigin());
+
+			if( flDistSqr < flClosestDistSqr )
+			{
+				// CollectSiegeTargets() guarantees my list is populated only with bullseye entities.
+				CNPC_Bullseye *pBullseye = dynamic_cast<CNPC_Bullseye*>(pCandidate);
+				if( !pBullseye->FInViewCone(this) )
+					continue;
+
+				if( pPlayer->FVisible(pCandidate) )
+				{
+					iTraces++;// Only counting these as a loose perf measurement
+					flClosestDistSqr = flDistSqr;
+					pSiegeTargetLocation = pCandidate;
+				}
+			}
+		}
+
+		if( pSiegeTargetLocation != NULL )
+		{
+			// Ditch any leftover siege target.
+			KillCurrentSiegeTarget();
+
+			// Create a bullseye that will live for 20 seconds. If we can't attack it within 20 seconds, it's probably
+			// out of reach anyone, so have it clean itself up after that long.
+			CBaseEntity *pSiegeTarget = CreateCustomTarget( pSiegeTargetLocation->GetAbsOrigin(), 20.0f );
+			pSiegeTarget->SetName( MAKE_STRING("siegetarget") );
+
+			m_hCurrentSiegeTarget.Set( pSiegeTarget );
+
+			AddEntityRelationship( pSiegeTarget, D_HT, 1 );
+			GetEnemies()->UpdateMemory( GetNavigator()->GetNetwork(), pSiegeTarget, pSiegeTarget->GetAbsOrigin(), 0.0f, true );
+			AI_EnemyInfo_t *pMemory = GetEnemies()->Find( pSiegeTarget );
+
+			if( pMemory )
+			{
+				// Pretend we've known about this target longer than we really have so that our AI doesn't waste time running ALERT schedules.
+				pMemory->timeFirstSeen = gpGlobals->curtime - 5.0f;
+				pMemory->timeLastSeen = gpGlobals->curtime - 1.0f;
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Destroy the bullseye that we're using as a temporary target
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::KillCurrentSiegeTarget()
+{
+	if ( m_hCurrentSiegeTarget )
+	{
+		GetEnemies()->ClearMemory( m_hCurrentSiegeTarget );
+
+		UTIL_Remove( m_hCurrentSiegeTarget );
+		m_hCurrentSiegeTarget.Set( NULL );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Return true if this NPC can hear the specified sound
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::QueryHearSound( CSound *pSound )
+{
+	if ( pSound->SoundContext() & SOUND_CONTEXT_EXCLUDE_COMBINE )
+		return false;
+
+	if ( pSound->SoundContext() & SOUND_CONTEXT_PLAYER_VEHICLE )
+		return false;
+
+	return BaseClass::QueryHearSound( pSound );
+}
+
+
+//-----------------------------------------------------------------------------
+// This is a fairly bogus heuristic right now, but it works on 06a and 12 (sjb)
+//
+// Better options:	Trace infinitely and check the material we hit for sky
+//					Put some leaf info in the BSP
+//					Use volumes in the levels? (yucky for designers)
+//-----------------------------------------------------------------------------
+// TODO: use this or nuke it!
+void CNPC_Hunter::GatherIndoorOutdoorConditions()
+{
+	// Check indoor/outdoor before calling base class, since base class calls our
+	// RangeAttackConditions() functions, and we want those functions to know 
+	// whether we're indoors or out.
+	trace_t tr;
+
+	UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + Vector( 0, 0, 40.0f * 12.0f ), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
+	if( tr.fraction < 1.0f )
+	{
+		SetCondition( COND_HUNTER_IS_INDOORS );
+	}
+	else
+	{
+		ClearCondition( COND_HUNTER_IS_INDOORS );
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::BuildScheduleTestBits()
+{
+	BaseClass::BuildScheduleTestBits();
+
+	if ( m_lifeState != LIFE_ALIVE )
+	{
+		return;
+	}
+
+	// Our range attack is uninterruptable for the first few seconds.
+	if ( IsCurSchedule( SCHED_HUNTER_RANGE_ATTACK2, false ) && ( gpGlobals->curtime < m_flShootAllowInterruptTime ) )
+	{
+		ClearCustomInterruptConditions();
+		SetCustomInterruptCondition( COND_HEAVY_DAMAGE );
+	}
+	else if ( IsCurSchedule( SCHED_HUNTER_RANGE_ATTACK2, false ) && ( GetActivity() == ACT_TRANSITION ) )
+	{
+		// Don't stop unplanting just because we can range attack again.
+		ClearCustomInterruptCondition( COND_CAN_RANGE_ATTACK1 );
+		ClearCustomInterruptCondition( COND_CAN_RANGE_ATTACK2 );
+	}
+	else if ( !IsInLargeOutdoorMap() && IsCurSchedule( SCHED_HUNTER_FLANK_ENEMY, false ) && GetEnemy() != NULL )
+	{
+		if( HasCondition(COND_CAN_RANGE_ATTACK2) && m_flTimeSawEnemyAgain != HUNTER_SEE_ENEMY_TIME_INVALID )
+		{
+			if( (gpGlobals->curtime - m_flTimeSawEnemyAgain) >= 2.0f )
+			{
+				// When we're running flank behavior, wait a moment AFTER being able to see the enemy before
+				// breaking my schedule to range attack. This helps assure that the hunter gets well inside
+				// the room before stopping to attack. Otherwise the Hunter may stop immediately in the doorway
+				// and stop the progress of any hunters behind it.
+				SetCustomInterruptCondition( COND_CAN_RANGE_ATTACK2 );
+			}
+		}
+	}
+
+	// If our enemy is anything but a striderbuster, drop everything if we see one.
+	if ( !IsStriderBuster( GetEnemy() ) )
+	{
+		SetCustomInterruptCondition( COND_HUNTER_SEE_STRIDERBUSTER );
+	}
+
+	// If we're not too busy, allow ourselves to ACK found enemy signals.
+	if ( !GetEnemy() )
+	{
+		SetCustomInterruptCondition( COND_HUNTER_SQUADMATE_FOUND_ENEMY );
+	}
+
+	// Interrupt everything if we need to dodge.
+	if ( !IsCurSchedule( SCHED_HUNTER_DODGE, false ) && 
+		 !IsCurSchedule( SCHED_HUNTER_STAGGER, false ) &&
+		 !IsCurSchedule( SCHED_ALERT_FACE_BESTSOUND, false ) )
+	{
+		SetCustomInterruptCondition( COND_HUNTER_INCOMING_VEHICLE );
+		SetCustomInterruptCondition( COND_HEAR_PHYSICS_DANGER );
+		SetCustomInterruptCondition( COND_HUNTER_FORCED_DODGE );
+	}
+
+	// Always interrupt on a flank command.	
+	SetCustomInterruptCondition( COND_HUNTER_FORCED_FLANK_ENEMY );
+
+	// Always interrupt if staggered.
+	SetCustomInterruptCondition( COND_HUNTER_STAGGERED );
+	
+	// Always interrupt if hit by a sticky bomb.
+	SetCustomInterruptCondition( COND_HUNTER_HIT_BY_STICKYBOMB );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+static bool IsMovablePhysicsObject( CBaseEntity *pEntity )
+{
+	return pEntity && pEntity->GetMoveType() == MOVETYPE_VPHYSICS && pEntity->VPhysicsGetObject() && pEntity->VPhysicsGetObject()->IsMoveable();
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+NPC_STATE CNPC_Hunter::SelectIdealState()
+{
+	switch ( m_NPCState )
+	{
+		case NPC_STATE_COMBAT:
+		{
+			if ( GetEnemy() == NULL )
+			{
+				if ( !HasCondition( COND_ENEMY_DEAD ) && !hunter_disable_patrol.GetBool() )
+				{
+					// Lost track of my enemy. Patrol.
+					SetCondition( COND_HUNTER_SHOULD_PATROL );
+				}
+
+				return NPC_STATE_ALERT;
+			}
+			else if ( HasCondition( COND_ENEMY_DEAD ) )
+			{
+				// dvs: TODO: announce enemy kills?
+				//AnnounceEnemyKill(GetEnemy());
+			}
+		}
+
+		default:
+		{
+			return BaseClass::SelectIdealState();
+		}
+	}
+
+	return GetIdealState();
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::ShouldCharge( const Vector &startPos, const Vector &endPos, bool useTime, bool bCheckForCancel )
+{
+	// Must have a target
+	if ( !GetEnemy() )
+		return false;
+
+	// Don't check the distance once we start charging
+	if ( !bCheckForCancel && !hunter_charge_test.GetBool() )
+	{
+		float distance = ( startPos.AsVector2D() - endPos.AsVector2D() ).LengthSqr();
+
+		// Must be within our tolerance range
+		if ( ( distance < Square(HUNTER_CHARGE_MIN) ) || ( distance > Square(HUNTER_CHARGE_MAX) ) )
+			return false;
+	}
+
+	// FIXME: We'd like to exclude small physics objects from this check!
+
+	// We only need to hit the endpos with the edge of our bounding box
+	Vector vecDir = endPos - startPos;
+	VectorNormalize( vecDir );
+	float flWidth = WorldAlignSize().x * 0.5;
+	Vector vecTargetPos = endPos - (vecDir * flWidth);
+
+	// See if we can directly move there
+	AIMoveTrace_t moveTrace;
+	GetMoveProbe()->MoveLimit( NAV_GROUND, startPos, vecTargetPos, MASK_NPCSOLID_BRUSHONLY, GetEnemy(), &moveTrace );
+	
+	// Draw the probe
+	if ( g_debug_hunter_charge.GetInt() == 1 )
+	{
+		Vector	enemyDir	= (vecTargetPos - startPos);
+		float	enemyDist	= VectorNormalize( enemyDir );
+
+		NDebugOverlay::BoxDirection( startPos, GetHullMins(), GetHullMaxs() + Vector(enemyDist,0,0), enemyDir, 0, 255, 0, 8, 1.0f );
+	}
+
+	// If we're not blocked, charge
+	if ( IsMoveBlocked( moveTrace ) )
+	{
+		// Don't allow it if it's too close to us
+		if ( UTIL_DistApprox( WorldSpaceCenter(), moveTrace.vEndPosition ) < HUNTER_CHARGE_MIN )
+			return false;
+
+		// Allow some special cases to not block us
+		if ( moveTrace.pObstruction != NULL )
+		{
+			// If we've hit the world, see if it's a cliff
+			if ( moveTrace.pObstruction == GetContainingEntity( INDEXENT(0) ) )
+			{	
+				// Can't be too far above/below the target
+				if ( fabs( moveTrace.vEndPosition.z - vecTargetPos.z ) > StepHeight() )
+					return false;
+
+				// Allow it if we got pretty close
+				if ( UTIL_DistApprox( moveTrace.vEndPosition, vecTargetPos ) < 64 )
+					return true;
+			}
+
+			// Hit things that will take damage
+			if ( moveTrace.pObstruction->m_takedamage != DAMAGE_NO )
+				return true;
+
+			// Hit things that will move
+			if ( moveTrace.pObstruction->GetMoveType() == MOVETYPE_VPHYSICS )
+				return true;
+		}
+
+		return false;
+	}
+
+	float zDelta = endPos.z - moveTrace.vEndPosition.z;
+	if ( fabsf(zDelta) > GetHullHeight() * 0.7)
+	{
+		return false;
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::HandleInteraction(int interactionType, void *data, CBaseCombatCharacter *pSourceEnt)
+{
+	if ( ( pSourceEnt != this ) && ( interactionType == g_interactionHunterFoundEnemy ) )
+	{
+		SetCondition( COND_HUNTER_SQUADMATE_FOUND_ENEMY );
+		return true;
+	}
+
+	return BaseClass::HandleInteraction( interactionType, data, pSourceEnt );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CNPC_Hunter::SelectCombatSchedule()
+{
+	// If we're here with no enemy, patrol and hope we find one.
+	CBaseEntity *pEnemy = GetEnemy();
+	if ( pEnemy == NULL )
+	{
+		if ( !hunter_disable_patrol.GetBool() )
+			return SCHED_HUNTER_PATROL_RUN;
+		else
+			return SCHED_ALERT_STAND;
+	}
+
+	if ( hunter_flechette_test.GetBool() )
+	{
+		if ( HasCondition( COND_CAN_RANGE_ATTACK2 ) )
+		{
+			return SCHED_HUNTER_RANGE_ATTACK2;
+		}
+		return SCHED_COMBAT_FACE;
+	}
+
+	bool bStriderBuster = IsStriderBuster( pEnemy );
+	if ( bStriderBuster )
+	{
+		if ( gpGlobals->curtime - CAI_HunterEscortBehavior::gm_flLastDefendSound > 10.0 )
+		{
+			EmitSound( "NPC_Hunter.DefendStrider" );
+			CAI_HunterEscortBehavior::gm_flLastDefendSound = gpGlobals->curtime;
+		}
+
+		if ( HasCondition( COND_CAN_RANGE_ATTACK2 ) || HasCondition( COND_NOT_FACING_ATTACK ) )
+		{
+			return SCHED_HUNTER_RANGE_ATTACK2;
+		}
+		return SCHED_ESTABLISH_LINE_OF_FIRE;
+	}
+
+	// Certain behaviors, like flanking and melee attacks, only make sense on visible,
+	// corporeal enemies (NOT bullseyes).
+	bool bIsCorporealEnemy = IsCorporealEnemy( pEnemy );
+
+	// Take a quick swipe at our enemy if able to do so.
+	if ( bIsCorporealEnemy && HasCondition( COND_CAN_MELEE_ATTACK1 ) )
+	{
+		return SCHED_HUNTER_MELEE_ATTACK1;
+	}
+
+	// React to newly acquired enemies.
+	if ( bIsCorporealEnemy && HasCondition( COND_NEW_ENEMY ) )
+	{
+		AI_EnemyInfo_t *pEnemyInfo = GetEnemies()->Find( pEnemy );
+
+		if ( GetSquad() && pEnemyInfo && ( pEnemyInfo->timeFirstSeen == pEnemyInfo->timeAtFirstHand ) )
+		{
+			GetSquad()->BroadcastInteraction( g_interactionHunterFoundEnemy, NULL, this );
+
+			// First contact for my squad.
+			return SCHED_HUNTER_FOUND_ENEMY;
+		}
+	}
+
+	if ( HasCondition( COND_HUNTER_SQUADMATE_FOUND_ENEMY ) )
+	{
+		// A squadmate found an enemy. Respond to their call.
+		return SCHED_HUNTER_FOUND_ENEMY_ACK;
+	}
+
+	// Fire a flechette volley. Ignore squad slots if we're attacking a striderbuster.
+	// See if there is an opportunity to charge.
+	if ( !bStriderBuster && bIsCorporealEnemy && HasCondition( COND_HUNTER_CAN_CHARGE_ENEMY ) )
+	{
+		if ( hunter_charge_test.GetBool() || random->RandomInt( 1, 100 ) < hunter_charge_pct.GetInt() )
+		{
+			if ( hunter_charge_test.GetBool() || OccupyStrategySlot( SQUAD_SLOT_HUNTER_CHARGE ) )
+			{
+				return SCHED_HUNTER_CHARGE_ENEMY;
+			}
+		}
+	}
+
+	if ( HasCondition( COND_CAN_RANGE_ATTACK2 ) )
+	{
+		if ( bStriderBuster || CountRangedAttackers() < hunter_flechette_max_concurrent_volleys.GetInt() )
+		{
+			DelayRangedAttackers( hunter_flechette_volley_start_min_delay.GetFloat(), hunter_flechette_volley_start_max_delay.GetFloat(), true );
+			return SCHED_HUNTER_RANGE_ATTACK2;
+		}
+	}
+
+	if ( pEnemy->GetGroundEntity() == this )
+	{
+		return SCHED_HUNTER_MELEE_ATTACK1;
+	}
+
+	if ( HasCondition( COND_TOO_CLOSE_TO_ATTACK ) )
+	{
+		return SCHED_MOVE_AWAY_FROM_ENEMY;
+	}
+
+	// Sidestep every so often if my enemy is nearby and facing me.
+/*
+	if ( gpGlobals->curtime > m_flNextSideStepTime )
+	{
+		if ( HasCondition( COND_ENEMY_FACING_ME ) && ( UTIL_DistApprox( GetEnemy()->GetAbsOrigin(), GetAbsOrigin() ) < HUNTER_FACE_ENEMY_DIST ) )
+		{
+			m_flNextSideStepTime = gpGlobals->curtime + random->RandomFloat( 1.0f, 3.0f );
+			return SCHED_HUNTER_SIDESTEP;
+		}
+	}
+*/
+	if ( HasCondition( COND_HEAVY_DAMAGE ) && ( gpGlobals->curtime > m_flNextSideStepTime ) )
+	{
+		m_flNextSideStepTime = gpGlobals->curtime + random->RandomFloat( 1.0f, 3.0f );
+		return SCHED_HUNTER_SIDESTEP;
+	}
+
+	if ( !bStriderBuster && bIsCorporealEnemy )
+	{
+		if ( HasCondition( COND_HUNTER_CAN_CHARGE_ENEMY ) )
+		{
+			if ( OccupyStrategySlot( SQUAD_SLOT_HUNTER_CHARGE ) )
+			{
+				return SCHED_HUNTER_CHARGE_ENEMY;
+			}
+/*
+			else
+			{
+				return SCHED_HUNTER_SIDESTEP;
+			}
+*/
+		}
+
+		// Try to be a flanker.
+		if ( ( NumHuntersInMySquad() > 1 ) && OccupyStrategySlotRange( SQUAD_SLOT_HUNTER_FLANK_FIRST, SQUAD_SLOT_HUNTER_FLANK_LAST ) )
+		{
+			return SCHED_HUNTER_FLANK_ENEMY;
+		}
+	}
+	
+	// Can't see my enemy.
+	if ( HasCondition( COND_ENEMY_OCCLUDED ) || HasCondition( COND_ENEMY_TOO_FAR ) || HasCondition( COND_TOO_FAR_TO_ATTACK ) || HasCondition( COND_NOT_FACING_ATTACK ) )
+	{
+		return SCHED_HUNTER_CHASE_ENEMY;
+	}
+
+	if ( HasCondition( COND_HUNTER_CANT_PLANT ) )
+	{
+		return SCHED_ESTABLISH_LINE_OF_FIRE;
+	}
+
+	//if ( HasCondition( COND_ENEMY_OCCLUDED ) && IsCurSchedule( SCHED_RANGE_ATTACK1, false ) )
+	//{
+	//	return SCHED_HUNTER_COMBAT_FACE;
+	//}
+
+ 	return SCHED_HUNTER_CHANGE_POSITION;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CNPC_Hunter::SelectSiegeSchedule()
+{
+	bool bHasEnemy = (GetEnemy() != NULL);
+
+	if( bHasEnemy )
+	{
+		// We have an enemy, so we should be making every effort to attack it.
+		if( !HasCondition(COND_SEE_ENEMY) || !HasCondition(COND_CAN_RANGE_ATTACK2) )
+			return SCHED_ESTABLISH_LINE_OF_FIRE;
+
+		if( HasCondition(COND_CAN_RANGE_ATTACK2) )
+			return SCHED_HUNTER_RANGE_ATTACK2;
+
+		return SCHED_HUNTER_SIEGE_STAND;
+	}
+	else
+	{
+		// Otherwise we are loitering in siege mode. Break line of sight with the player
+		// if they expose our position.
+		if( HasCondition( COND_SEE_PLAYER ) )
+			return SCHED_HUNTER_CHANGE_POSITION_SIEGE;
+	}
+
+	return SCHED_HUNTER_SIEGE_STAND;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CNPC_Hunter::SelectSchedule()
+{
+	if ( hunter_stand_still.GetBool() )
+	{
+		m_bPlanted = false;
+		return SCHED_IDLE_STAND;
+	}
+	
+	if ( HasCondition( COND_HUNTER_FORCED_DODGE ) )
+		return SCHED_HUNTER_DODGE;
+
+	if ( HasCondition( COND_HUNTER_NEW_HINTGROUP ) || ( GetHintGroup() != NULL_STRING && m_CheckHintGroupTimer.Expired() ) )
+	{
+		CAI_Hint *pHint;
+		CHintCriteria criteria;
+		criteria.SetGroup( GetHintGroup() );
+		criteria.SetFlag( bits_HINT_NODE_NEAREST );
+
+		if ( HasCondition( COND_HUNTER_NEW_HINTGROUP ) )
+		{
+			ClearCondition( COND_HUNTER_NEW_HINTGROUP );
+			if ( GetEnemy() )
+			{
+				pHint = CAI_HintManager::FindHint( NULL, GetEnemy()->GetAbsOrigin(), criteria );
+			}
+			else
+			{
+				pHint = CAI_HintManager::FindHint( GetAbsOrigin(), criteria );
+			}
+
+			if ( pHint )
+			{
+				pHint->Lock( this );
+			}
+		} 
+		else
+		{
+			pHint = CAI_HintManager::FindHint( GetAbsOrigin(), criteria );
+			if ( pHint )
+			{
+				if ( (pHint->GetAbsOrigin() - GetAbsOrigin()).Length2DSqr() < Square( 20*12 ) )
+				{
+					m_CheckHintGroupTimer.Set( 5 );
+					pHint = NULL;
+				}
+				else
+				{
+					m_CheckHintGroupTimer.Set( 15 );
+				}
+			}
+		}
+
+		if ( pHint )
+		{
+			SetHintNode( pHint );
+			return SCHED_HUNTER_GOTO_HINT;
+		}
+	}
+
+	if ( HasCondition( COND_HUNTER_INCOMING_VEHICLE ) )
+	{
+		if ( m_RundownDelay.Expired() )
+		{
+			int iRundownCounter = 0;
+			if ( GetSquad() )
+			{
+				GetSquad()->GetSquadData( HUNTER_RUNDOWN_SQUADDATA, &iRundownCounter );
+			}
+
+			if ( iRundownCounter % 2 == 0 )
+			{
+				for ( int i = 0; i < g_Hunters.Count(); i++ )
+				{
+					if ( g_Hunters[i] != this )
+					{
+						g_Hunters[i]->m_RundownDelay.Set( 3 );
+						g_Hunters[i]->m_IgnoreVehicleTimer.Force();
+					}
+				}
+				m_IgnoreVehicleTimer.Set( hunter_dodge_warning.GetFloat() * 4 );
+				if ( hunter_dodge_debug.GetBool() )
+				{
+					Msg( "Hunter %d rundown\n", entindex() );
+				}
+
+				if ( HasCondition( COND_SEE_ENEMY ) )
+				{
+					if ( m_bPlanted && HasCondition( COND_CAN_RANGE_ATTACK2 ) )
+					{
+						return SCHED_HUNTER_RANGE_ATTACK2;
+					}
+					else if ( random->RandomInt( 0, 1 ) )
+					{
+						return SCHED_HUNTER_CHARGE_ENEMY;
+					}
+					else
+					{
+						return SCHED_MOVE_AWAY;
+					}
+				}
+				else
+				{
+					SetTarget( UTIL_GetLocalPlayer() );
+					return SCHED_TARGET_FACE;
+				}
+			}
+			else
+			{
+				if ( hunter_dodge_debug.GetBool() )
+				{
+					Msg( "Hunter %d safe from rundown\n", entindex() );
+				}
+				for ( int i = 0; i < g_Hunters.Count(); i++ )
+				{
+					g_Hunters[i]->m_RundownDelay.Set( 4 );
+					g_Hunters[i]->m_IgnoreVehicleTimer.Force();
+				}
+				if ( GetSquad() )
+				{
+					GetSquad()->SetSquadData( HUNTER_RUNDOWN_SQUADDATA, iRundownCounter + 1 );
+				}
+			}
+		}
+
+		if ( HasCondition( COND_SEE_ENEMY ) )
+		{
+			if ( hunter_dodge_debug.GetBool() )
+			{
+				Msg( "Hunter %d try dodge\n", entindex() );
+			}
+			return SCHED_HUNTER_DODGE;
+		}
+		else
+		{
+			SetTarget( UTIL_GetLocalPlayer() );
+			return SCHED_TARGET_FACE;
+		}
+
+		CSound *pBestSound = GetBestSound( SOUND_PHYSICS_DANGER );
+		if ( pBestSound && ( pBestSound->SoundContext() & SOUND_CONTEXT_PLAYER_VEHICLE ) )
+		{
+			return SCHED_ALERT_FACE_BESTSOUND;
+		}
+	}
+
+	if ( HasCondition( COND_HUNTER_FORCED_FLANK_ENEMY ) )
+	{
+		return SCHED_HUNTER_FLANK_ENEMY;
+	}
+	
+	if ( HasCondition( COND_HUNTER_STAGGERED ) /*|| HasCondition( COND_HUNTER_HIT_BY_STICKYBOMB )*/ )
+	{
+		return SCHED_HUNTER_STAGGER;
+	}
+
+	// Now that we're past all of the forced reactions to things, if we're running the siege
+	// behavior, go pick an appropriate siege schedule UNLESS we have an enemy. If we have
+	// an enemy, we should focus on attacking that enemy.
+	if( IsUsingSiegeTargets() )
+	{
+		return SelectSiegeSchedule();
+	}
+
+	// back away if there's a magnade glued to my head.
+	if ( hunter_retreat_striderbusters.GetBool() /*&& GetEnemy() && ( GetEnemy()->IsPlayer() )*/ 
+		&& (m_hAttachedBusters.Count() > 0)
+		&& m_fCorneredTimer < gpGlobals->curtime)
+	{
+		return SCHED_HUNTER_TAKE_COVER_FROM_ENEMY;
+	}
+
+	if ( !BehaviorSelectSchedule() )
+	{
+		switch ( GetState() )
+		{
+			case NPC_STATE_IDLE:
+			{
+				return SCHED_HUNTER_PATROL;
+			}
+
+			case NPC_STATE_ALERT:
+			{
+				if ( HasCondition( COND_HUNTER_SHOULD_PATROL ) )
+					return SCHED_HUNTER_PATROL;
+					
+				break;
+			}
+
+			case NPC_STATE_COMBAT:
+			{
+				return SelectCombatSchedule();
+			}
+		}
+	}
+		
+	return BaseClass::SelectSchedule();
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CNPC_Hunter::TranslateSchedule( int scheduleType )
+{
+	switch ( scheduleType )
+	{
+		case SCHED_RANGE_ATTACK1:
+		{
+			return SCHED_HUNTER_RANGE_ATTACK1;
+		}
+
+		case SCHED_RANGE_ATTACK2:
+		case SCHED_HUNTER_RANGE_ATTACK2:
+		{
+			if ( scheduleType == SCHED_RANGE_ATTACK2 )
+			{
+				Msg( "HUNTER IGNORING SQUAD SLOTS\n" );
+			}
+
+			if ( IsStriderBuster( GetEnemy() ) )
+			{
+				// Attack as FAST as possible. The point is to shoot down the buster.
+				return SCHED_HUNTER_RANGE_ATTACK2_VS_STRIDERBUSTER;
+			}
+
+			return SCHED_HUNTER_RANGE_ATTACK2;
+		}
+
+		case SCHED_MELEE_ATTACK1:
+		{
+			return SCHED_HUNTER_MELEE_ATTACK1;
+		}
+	
+		case SCHED_ESTABLISH_LINE_OF_FIRE_FALLBACK:
+		{
+			return SCHED_HUNTER_CHANGE_POSITION;
+		}
+
+		case SCHED_ALERT_STAND:
+		{
+			if ( !hunter_disable_patrol.GetBool() )
+				return SCHED_HUNTER_PATROL_RUN;
+			break;
+		}
+
+		case SCHED_COMBAT_FACE:
+		{
+			return SCHED_HUNTER_COMBAT_FACE;
+		}
+
+		case SCHED_HUNTER_PATROL:
+		{
+			if ( hunter_disable_patrol.GetBool() )
+			{
+				return SCHED_IDLE_STAND;
+			}
+			break;
+		}
+	}
+
+	return BaseClass::TranslateSchedule( scheduleType );
+}
+
+
+//-----------------------------------------------------------------------------
+// catch blockage while escaping magnade
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::TaskFail( AI_TaskFailureCode_t code )
+{
+	if ( IsCurSchedule( SCHED_HUNTER_TAKE_COVER_FROM_ENEMY, false ) && ( code == FAIL_NO_ROUTE_BLOCKED  ) )
+	{
+		// cornered!
+		if ( m_fCorneredTimer < gpGlobals->curtime )
+		{
+			m_fCorneredTimer = gpGlobals->curtime + 6.0f;
+		}
+	}
+
+	BaseClass::TaskFail( code );
+}
+
+
+//-----------------------------------------------------------------------------
+// The player is speeding toward us in a vehicle! Find a good activity for dodging.
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::TaskFindDodgeActivity()
+{
+	if ( GetEnemy() == NULL )
+	{
+		TaskFail( "No enemy to dodge" );
+		return;
+	}
+
+	Vector vecUp;
+	Vector vecRight;
+	GetVectors( NULL, &vecRight, &vecUp );
+
+	// TODO: find most perpendicular 8-way dodge when we get the anims
+	Vector vecEnemyDir = GetEnemy()->GetAbsOrigin() - GetAbsOrigin();
+	//Vector vecDir = CrossProduct( vecEnemyDir, vecUp );
+	VectorNormalize( vecEnemyDir );
+	if ( fabs( DotProduct( vecEnemyDir, vecRight ) ) > 0.7 )
+	{
+		TaskFail( "Can't dodge, enemy approaching perpendicularly" );
+		return;
+	}
+
+	// Check left or right randomly first.
+	bool bDodgeLeft = false;
+	CBaseEntity *pVehicle = GetEnemyVehicle();
+	if ( pVehicle  )
+	{
+		Ray_t enemyRay;
+		Ray_t perpendicularRay;
+		enemyRay.Init( pVehicle->GetAbsOrigin(), pVehicle->GetAbsOrigin() + pVehicle->GetSmoothedVelocity() );
+		Vector vPerpendicularPt = vecEnemyDir;
+		vPerpendicularPt.y = -vPerpendicularPt.y;
+		perpendicularRay.Init( GetAbsOrigin(), GetAbsOrigin() + vPerpendicularPt );
+
+		enemyRay.m_Start.z = enemyRay.m_Delta.z = enemyRay.m_StartOffset.z;
+		perpendicularRay.m_Start.z = perpendicularRay.m_Delta.z = perpendicularRay.m_StartOffset.z;
+
+		float t, s;
+
+		IntersectRayWithRay( perpendicularRay, enemyRay, t, s );
+
+		if ( t > 0 )
+		{
+			bDodgeLeft = true;
+		}
+	}
+	else if ( random->RandomInt( 0, 1 ) == 0 )
+	{
+		bDodgeLeft = true;
+	}
+
+	bool bFoundDir = false;
+	int nTries = 0;
+
+	while ( !bFoundDir && ( nTries < 2 ) )
+	{
+		// Pick a dodge activity to try.
+		if ( bDodgeLeft )
+		{
+			m_eDodgeActivity = ACT_HUNTER_DODGEL;
+		}
+		else
+		{
+			m_eDodgeActivity = ACT_HUNTER_DODGER;
+		}
+
+		// See where the dodge will put us.
+		Vector vecLocalDelta;
+		int nSeq = SelectWeightedSequence( m_eDodgeActivity );
+		GetSequenceLinearMotion( nSeq, &vecLocalDelta );
+
+		// Transform the sequence delta into local space.
+		matrix3x4_t fRotateMatrix;
+		AngleMatrix( GetLocalAngles(), fRotateMatrix );
+		Vector vecDelta;
+		VectorRotate( vecLocalDelta, fRotateMatrix, vecDelta );
+
+		// Trace a bit high so this works better on uneven terrain.
+		Vector testHullMins = GetHullMins();
+		testHullMins.z += ( StepHeight() * 2 );
+
+		// See if all is clear in that direction.
+		trace_t tr;
+		HunterTraceHull_SkipPhysics( GetAbsOrigin(), GetAbsOrigin() + vecDelta, testHullMins, GetHullMaxs(), MASK_NPCSOLID, this, GetCollisionGroup(), &tr, VPhysicsGetObject()->GetMass() * 0.5f );
+
+		// TODO: dodge anyway if we'll make it a certain percentage of the way through the dodge?
+		if ( tr.fraction == 1.0f )
+		{
+			//NDebugOverlay::SweptBox( GetAbsOrigin(), GetAbsOrigin() + vecDelta, testHullMins, GetHullMaxs(), QAngle( 0, 0, 0 ), 0, 255, 0, 128, 5 );
+			bFoundDir = true;
+			TaskComplete();
+		}
+		else
+		{
+			//NDebugOverlay::SweptBox( GetAbsOrigin(), GetAbsOrigin() + vecDelta, testHullMins, GetHullMaxs(), QAngle( 0, 0, 0 ), 255, 0, 0, 128, 5 );
+			nTries++;
+			bDodgeLeft = !bDodgeLeft;
+		}
+	}
+
+	if ( nTries < 2 )
+	{
+		TaskComplete();
+	}
+	else
+	{
+		TaskFail( "Couldn't find dodge position\n" );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::StartTask( const Task_t *pTask )
+{
+	switch ( pTask->iTask )
+	{
+		case TASK_HUNTER_FINISH_RANGE_ATTACK:
+		{
+			if( GetEnemy() != NULL && GetEnemy()->Classify() == CLASS_PLAYER_ALLY_VITAL )
+			{
+				// Just finished shooting at Alyx! So forget her for a little while and get back on the player
+				// !!!LATER - make sure there's someone else in enemy memory to go bother.
+				GetEnemies()->SetTimeValidEnemy( GetEnemy(), gpGlobals->curtime + 10.0f );
+			}
+
+			if( m_hCurrentSiegeTarget )
+			{
+				// We probably just fired at our siege target, so dump it.
+				KillCurrentSiegeTarget();
+			}
+
+			TaskComplete();
+		}
+
+		case TASK_HUNTER_WAIT_FOR_MOVEMENT_FACING_ENEMY:
+		{
+			ChainStartTask( TASK_WAIT_FOR_MOVEMENT, pTask->flTaskData );
+			break;
+		}
+
+		case TASK_HUNTER_BEGIN_FLANK:
+		{
+			if ( IsInSquad() && GetSquad()->NumMembers() > 1 )
+			{
+				// Flank relative to the other shooter in our squad.
+				// If there's no other shooter, just flank relative to any squad member.
+				AISquadIter_t iter;
+				CAI_BaseNPC *pNPC = GetSquad()->GetFirstMember( &iter );
+				while ( pNPC == this )
+				{
+					pNPC = GetSquad()->GetNextMember( &iter );
+				}
+
+				m_vSavePosition = pNPC->GetAbsOrigin();
+			}
+			else
+			{
+				// Flank relative to our current position.
+				m_vSavePosition = GetAbsOrigin();
+			}
+			
+			TaskComplete();
+			break;
+		}
+
+		case TASK_HUNTER_ANNOUNCE_FLANK:
+		{
+			EmitSound( "NPC_Hunter.FlankAnnounce" );
+			TaskComplete();
+			break;
+		}
+
+		case TASK_HUNTER_DODGE:
+		{
+			if ( hunter_dodge_debug. GetBool() )
+			{
+				Msg( "Hunter %d dodging\n", entindex() );
+			}
+			SetIdealActivity( m_eDodgeActivity );
+			break;
+		}
+		
+		// Guarantee a certain delay between volleys. If we aren't already planted,
+		// the plant transition animation will take care of that.
+		case TASK_HUNTER_PRE_RANGE_ATTACK2:
+		{
+			if ( !m_bPlanted  || ( GetEnemy() && IsStriderBuster( GetEnemy() ) ) )
+			{
+				TaskComplete();
+			}
+			else
+			{
+				SetIdealActivity( ACT_HUNTER_ANGRY );
+			}
+			break;
+		}
+
+		case TASK_HUNTER_SHOOT_COMMIT:
+		{
+			// We're committing to shooting. Don't allow interrupts until after we've shot a bit (see TASK_RANGE_ATTACK1).
+			m_flShootAllowInterruptTime = gpGlobals->curtime + 100.0f;
+			TaskComplete();
+			break;
+		}
+		
+		case TASK_RANGE_ATTACK2:
+		{
+			if ( GetEnemy() )
+			{
+				bool bIsBuster = IsStriderBuster( GetEnemy() );
+				if ( bIsBuster )
+				{
+					AddFacingTarget( GetEnemy(), GetEnemy()->GetAbsOrigin() + GetEnemy()->GetSmoothedVelocity() * .5, 1.0, 0.8 );
+				}
+
+				// Start the firing sound.
+				//CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+				//controller.SoundChangeVolume( m_pGunFiringSound, 1.0, hunter_first_flechette_delay.GetFloat() );
+
+				SetIdealActivity( ACT_RANGE_ATTACK2 );
+
+				// Decide how many shots to fire.
+				int nShots = hunter_flechette_volley_size.GetInt();
+				if ( g_pGameRules->IsSkillLevel( SKILL_EASY ) )
+				{
+					nShots--;
+				}
+
+				// Decide when to fire the first shot.
+				float initialDelay = hunter_first_flechette_delay.GetFloat();
+				if ( bIsBuster )
+				{
+					initialDelay = 0; //*= 0.5;
+				}
+
+				BeginVolley( nShots, gpGlobals->curtime + initialDelay );
+
+				// In case we need to miss on purpose, pick a direction now.
+				m_bMissLeft = false;
+				if ( random->RandomInt( 0, 1 ) == 0 )
+				{
+					m_bMissLeft = true;
+				}
+
+				LockBothEyes( initialDelay + ( nShots * hunter_flechette_delay.GetFloat() ) );
+			}
+			else
+			{
+				TaskFail( FAIL_NO_ENEMY );
+			}
+			
+			break;
+		}
+
+		case TASK_HUNTER_STAGGER:
+		{
+			// Stagger in the direction the impact force would push us.
+			VMatrix worldToLocalRotation = EntityToWorldTransform();
+			Vector vecLocalStaggerDir = worldToLocalRotation.InverseTR().ApplyRotation( m_vecStaggerDir );
+			
+			float flStaggerYaw = VecToYaw( vecLocalStaggerDir );
+			SetPoseParameter( gm_nStaggerYawPoseParam, flStaggerYaw );
+
+			// Go straight there!
+			SetActivity( ACT_RESET );
+			SetActivity( ( Activity )ACT_HUNTER_STAGGER );
+			break;
+		}
+	
+		case TASK_MELEE_ATTACK1:
+		{
+			SetLastAttackTime( gpGlobals->curtime );
+			
+			if ( GetEnemy() && GetEnemy()->IsPlayer() )
+			{
+				ResetIdealActivity( ( Activity )ACT_HUNTER_MELEE_ATTACK1_VS_PLAYER );
+			}
+			else
+			{
+				ResetIdealActivity( ACT_MELEE_ATTACK1 );
+			}
+			
+			break;
+		}
+
+		case TASK_HUNTER_CORNERED_TIMER:
+		{
+			m_fCorneredTimer = gpGlobals->curtime + pTask->flTaskData;
+
+			break;
+		}
+
+		case TASK_HUNTER_FIND_SIDESTEP_POSITION:
+		{
+			if ( GetEnemy() == NULL )
+			{
+				TaskFail( "No enemy to sidestep" );
+			}
+			else
+			{
+				Vector vecUp;
+				GetVectors( NULL, NULL, &vecUp );
+				
+				Vector vecEnemyDir = GetEnemy()->GetAbsOrigin() - GetAbsOrigin();
+				Vector vecDir = CrossProduct( vecEnemyDir, vecUp );
+				VectorNormalize( vecDir );
+
+				// Sidestep left or right randomly.				
+				if ( random->RandomInt( 0, 1 ) == 0 )
+				{
+					vecDir *= -1;
+				}
+
+				// Start high and then trace down so that it works on uneven terrain.
+				Vector vecPos = GetAbsOrigin() + Vector( 0, 0, 64 ) + random->RandomFloat( 120, 200 ) * vecDir;
+				
+				// Try to find the ground at the sidestep position.
+				trace_t tr;
+				UTIL_TraceLine( vecPos, vecPos + Vector( 0, 0, -128 ), MASK_NPCSOLID, NULL, COLLISION_GROUP_NONE, &tr );
+				if ( tr.fraction < 1.0f )
+				{
+					//NDebugOverlay::Line( vecPos, tr.endpos, 0, 255, 0, true, 10 ); 
+		
+					m_vSavePosition = tr.endpos;
+									
+					TaskComplete();
+				}
+				else
+				{
+					TaskFail( "Couldn't find sidestep position\n" );
+				}
+			}
+			
+			break;
+		}
+
+		case TASK_HUNTER_FIND_DODGE_POSITION:
+		{
+			TaskFindDodgeActivity();
+			break;
+		}
+
+		case TASK_HUNTER_CHARGE:
+		{
+			SetIdealActivity( ( Activity )ACT_HUNTER_CHARGE_START );
+			break;
+		}
+
+		case TASK_HUNTER_CHARGE_DELAY:
+		{
+			m_flNextChargeTime = gpGlobals->curtime + pTask->flTaskData;
+			TaskComplete();
+			break;
+		}
+	
+		case TASK_DIE:
+		{
+			GetNavigator()->StopMoving();	
+			ResetActivity();
+			SetIdealActivity( GetDeathActivity() );
+			m_lifeState = LIFE_DYING;
+
+			break;
+		}
+
+		//case TASK_HUNTER_END_FLANK:
+		//{
+		//	
+		//}
+	
+		default:
+		{
+			BaseClass::StartTask( pTask );
+			break;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::RunTask( const Task_t *pTask )
+{
+	switch ( pTask->iTask )
+	{
+		case TASK_HUNTER_PRE_RANGE_ATTACK2:
+		{
+			if ( IsActivityFinished() )
+			{
+				TaskComplete();
+			}
+			break;
+		}
+
+		case TASK_RANGE_ATTACK2:
+		{
+			if( !hunter_hate_thrown_striderbusters.GetBool() && GetEnemy() != NULL && IsStriderBuster( GetEnemy() ) )
+			{
+				if( !IsValidEnemy(GetEnemy()) )
+				{
+					TaskFail("No longer hate this StriderBuster");
+				}
+			}
+
+			bool bIsBuster = IsStriderBuster( GetEnemy() );
+			if ( bIsBuster )
+			{
+				Vector vFuturePosition = GetEnemy()->GetAbsOrigin() + GetEnemy()->GetSmoothedVelocity() * .3;
+				AddFacingTarget( GetEnemy(), vFuturePosition, 1.0, 0.8 );
+
+				Vector2D vToFuturePositon = ( vFuturePosition.AsVector2D() - GetAbsOrigin().AsVector2D() );
+				vToFuturePositon.NormalizeInPlace();
+				Vector2D facingDir = BodyDirection2D().AsVector2D();
+
+				float flDot = DotProduct2D( vToFuturePositon, facingDir );
+
+				if ( flDot < .4 )
+				{
+					GetMotor()->SetIdealYawToTarget( vFuturePosition );
+					GetMotor()->UpdateYaw();
+					break;
+				}
+			}
+
+			if ( gpGlobals->curtime >= m_flNextFlechetteTime )
+			{
+				// Must have an enemy and a shot queued up.
+				bool bDone = false;
+				if ( GetEnemy() != NULL && m_nFlechettesQueued > 0 )
+				{
+					if ( ShootFlechette( GetEnemy(), false ) )
+					{
+						m_nClampedShots++;
+					}
+					else
+					{
+						m_nClampedShots = 0;
+					}
+
+					m_nFlechettesQueued--;
+
+					// If we fired three or more clamped shots in a row, call it quits so we don't look dumb.
+					if ( ( m_nClampedShots >= 3 ) || ( m_nFlechettesQueued == 0 ) )
+					{
+						bDone = true;
+					}
+					else
+					{
+						// More shooting to do. Schedule our next flechette.
+						m_flNextFlechetteTime = gpGlobals->curtime + hunter_flechette_delay.GetFloat();
+					}
+				}
+				else
+				{
+					bDone = true;
+				}
+				
+				if ( bDone )     
+				{
+					// Stop the firing sound.
+					//CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+					//controller.SoundChangeVolume( m_pGunFiringSound, 0.0f, 0.1f );
+
+					DelayRangedAttackers( hunter_flechette_volley_end_min_delay.GetFloat(), hunter_flechette_volley_end_max_delay.GetFloat(), true );
+					TaskComplete();
+				}
+			}
+
+			break;
+		}
+	
+		case TASK_GET_PATH_TO_ENEMY_LOS:
+		{
+			ChainRunTask( TASK_GET_PATH_TO_ENEMY_LKP_LOS, pTask->flTaskData );
+			break;
+		}
+
+		case TASK_HUNTER_DODGE:
+		{
+			AutoMovement();
+
+			if ( IsActivityFinished() )
+			{
+				TaskComplete();
+			}
+			break;
+		}
+
+		case TASK_HUNTER_CORNERED_TIMER:
+		{
+			TaskComplete();
+			break;
+		}
+		
+		case TASK_HUNTER_STAGGER:
+		{
+			if ( IsActivityFinished() )
+			{
+				TaskComplete();
+			}
+			break;
+		}
+				
+		case TASK_HUNTER_CHARGE:
+		{
+			Activity eActivity = GetActivity();
+
+			// See if we're trying to stop after hitting/missing our target
+			if ( eActivity == ACT_HUNTER_CHARGE_STOP || eActivity == ACT_HUNTER_CHARGE_CRASH ) 
+			{
+				if ( IsActivityFinished() )
+				{
+					m_flNextChargeTime = gpGlobals->curtime + hunter_charge_min_delay.GetFloat() + random->RandomFloat( 0, 2.5 ) + random->RandomFloat( 0, 2.5 );
+					float delayMultiplier = ( g_pGameRules->IsSkillLevel( SKILL_EASY ) ) ? 1.5 : 1.0;
+					float groupDelay = gpGlobals->curtime +  ( 2.0  + random->RandomFloat( 0, 2 ) ) * delayMultiplier;
+					for ( int i = 0; i < g_Hunters.Count(); i++ )
+					{
+						if ( g_Hunters[i] != this && g_Hunters[i]->m_flNextChargeTime < groupDelay )
+						{
+							g_Hunters[i]->m_flNextChargeTime = groupDelay;
+						}
+					}
+					TaskComplete();
+					return;
+				}
+
+				// Still in the process of slowing down. Run movement until it's done.
+				AutoMovement();
+				return;
+			}
+
+			// Check for manual transition
+			if ( ( eActivity == ACT_HUNTER_CHARGE_START ) && ( IsActivityFinished() ) )
+			{
+				SetIdealActivity( ACT_HUNTER_CHARGE_RUN );
+			}
+
+			// See if we're still running
+			if ( eActivity == ACT_HUNTER_CHARGE_RUN || eActivity == ACT_HUNTER_CHARGE_START ) 
+			{
+				if ( HasCondition( COND_NEW_ENEMY ) || HasCondition( COND_LOST_ENEMY ) || HasCondition( COND_ENEMY_DEAD ) )
+				{
+					SetIdealActivity( ACT_HUNTER_CHARGE_STOP );
+					return;
+				}
+				else 
+				{
+					if ( GetEnemy() != NULL )
+					{
+						Vector	goalDir = ( GetEnemy()->GetAbsOrigin() - GetAbsOrigin() );
+						VectorNormalize( goalDir );
+
+						if ( DotProduct( BodyDirection2D(), goalDir ) < 0.25f )
+						{
+							SetIdealActivity( ACT_HUNTER_CHARGE_STOP );
+						}
+					}
+				}
+			}
+
+			// Steer towards our target
+			float idealYaw;
+			if ( GetEnemy() == NULL )
+			{
+				idealYaw = GetMotor()->GetIdealYaw();
+			}
+			else
+			{
+				idealYaw = CalcIdealYaw( GetEnemy()->GetAbsOrigin() );
+			}
+
+			// Add in our steering offset
+			idealYaw += ChargeSteer();
+			
+			// Turn to face
+			GetMotor()->SetIdealYawAndUpdate( idealYaw );
+
+			// See if we're going to run into anything soon
+			ChargeLookAhead();
+
+			// Let our animations simply move us forward. Keep the result
+			// of the movement so we know whether we've hit our target.
+			AIMoveTrace_t moveTrace;
+			if ( AutoMovement( GetEnemy(), &moveTrace ) == false )
+			{
+				// Only stop if we hit the world
+				if ( HandleChargeImpact( moveTrace.vEndPosition, moveTrace.pObstruction ) )
+				{
+					// If we're starting up, this is an error
+					if ( eActivity == ACT_HUNTER_CHARGE_START )
+					{
+						TaskFail( "Unable to make initial movement of charge\n" );
+						return;
+					}
+
+					// Crash unless we're trying to stop already
+					if ( eActivity != ACT_HUNTER_CHARGE_STOP )
+					{
+						if ( moveTrace.fStatus == AIMR_BLOCKED_WORLD && moveTrace.vHitNormal == vec3_origin )
+						{
+							SetIdealActivity( ACT_HUNTER_CHARGE_STOP );
+						}
+						else
+						{
+							// Shake the screen
+							if ( moveTrace.fStatus != AIMR_BLOCKED_NPC )
+							{
+								EmitSound( "NPC_Hunter.ChargeHitWorld" );
+								UTIL_ScreenShake( GetAbsOrigin(), 16.0f, 4.0f, 1.0f, 400.0f, SHAKE_START );
+							}
+							SetIdealActivity( ACT_HUNTER_CHARGE_CRASH );
+						}
+					}
+				}
+				else if ( moveTrace.pObstruction )
+				{
+					// If we hit another hunter, stop
+					if ( moveTrace.pObstruction->Classify() == CLASS_COMBINE_HUNTER )
+					{
+						// Crash unless we're trying to stop already
+						if ( eActivity != ACT_HUNTER_CHARGE_STOP )
+						{
+							SetIdealActivity( ACT_HUNTER_CHARGE_STOP );
+						}
+					}
+					// If we hit an antlion, don't stop, but kill it
+					// We never have hunters and antlions together, but you never know.
+					else if (moveTrace.pObstruction->Classify() == CLASS_ANTLION )
+					{
+						if ( FClassnameIs( moveTrace.pObstruction, "npc_antlionguard" ) )
+						{
+							// Crash unless we're trying to stop already
+							if ( eActivity != ACT_HUNTER_CHARGE_STOP )
+							{
+								SetIdealActivity( ACT_HUNTER_CHARGE_STOP );
+							}
+						}
+						else
+						{
+							Hunter_ApplyChargeDamage( this, moveTrace.pObstruction, moveTrace.pObstruction->GetHealth() );
+						}
+					}
+				}
+			}
+
+			break;
+		}
+				
+		case TASK_HUNTER_WAIT_FOR_MOVEMENT_FACING_ENEMY:
+		{
+			if ( GetEnemy() )
+			{
+				Vector vecEnemyLKP = GetEnemyLKP();
+				AddFacingTarget( GetEnemy(), vecEnemyLKP, 1.0, 0.8 );
+			}
+			ChainRunTask( TASK_WAIT_FOR_MOVEMENT, pTask->flTaskData );
+			break;
+		}
+
+		default:
+		{
+			BaseClass::RunTask( pTask );
+			break;		
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Return true if our charge target is right in front of the hunter.
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::EnemyIsRightInFrontOfMe( CBaseEntity **pEntity )
+{
+	if ( !GetEnemy() )
+		return false;
+
+	if ( (GetEnemy()->WorldSpaceCenter() - WorldSpaceCenter()).LengthSqr() < (156*156) )
+	{
+		Vector vecLOS = ( GetEnemy()->GetAbsOrigin() - GetAbsOrigin() );
+		vecLOS.z = 0;
+		VectorNormalize( vecLOS );
+		Vector vBodyDir = BodyDirection2D();
+		if ( DotProduct( vecLOS, vBodyDir ) > 0.8 )
+		{
+			// He's in front of me, and close. Make sure he's not behind a wall.
+			trace_t tr;
+			UTIL_TraceHull( WorldSpaceCenter(), GetEnemy()->WorldSpaceCenter(), GetHullMins() * 0.5, GetHullMaxs() * 0.5, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
+			if ( tr.m_pEnt == GetEnemy() )
+			{
+				*pEntity = tr.m_pEnt;
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// While charging, look ahead and see if we're going to run into anything.
+// If we are, start the gesture so it looks like we're anticipating the hit.
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::ChargeLookAhead( void )
+{
+#if 0
+	trace_t	tr;
+	Vector vecForward;
+	GetVectors( &vecForward, NULL, NULL );
+	Vector vecTestPos = GetAbsOrigin() + ( vecForward * m_flGroundSpeed * 0.75 );
+	Vector testHullMins = GetHullMins();
+	testHullMins.z += (StepHeight() * 2);
+	HunterTraceHull_SkipPhysics( GetAbsOrigin(), vecTestPos, testHullMins, GetHullMaxs(), MASK_SHOT_HULL, this, COLLISION_GROUP_NONE, &tr, VPhysicsGetObject()->GetMass() * 0.5 );
+
+	//NDebugOverlay::Box( tr.startpos, testHullMins, GetHullMaxs(), 0, 255, 0, true, 0.1f );
+	//NDebugOverlay::Box( vecTestPos, testHullMins, GetHullMaxs(), 255, 0, 0, true, 0.1f );
+
+	if ( tr.fraction != 1.0 )
+	{
+		// dvs: TODO:
+		// Start playing the hit animation
+		//AddGesture( ACT_HUNTER_CHARGE_ANTICIPATION );
+	}
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+float CNPC_Hunter::ChargeSteer()
+{
+	trace_t	tr;
+	Vector	testPos, steer, forward, right;
+	QAngle	angles;
+	const float	testLength = m_flGroundSpeed * 0.15f;
+
+	//Get our facing
+	GetVectors( &forward, &right, NULL );
+
+	steer = forward;
+
+	const float faceYaw	= UTIL_VecToYaw( forward );
+
+	//Offset right
+	VectorAngles( forward, angles );
+	angles[YAW] += 45.0f;
+	AngleVectors( angles, &forward );
+
+	// Probe out
+	testPos = GetAbsOrigin() + ( forward * testLength );
+
+	// Offset by step height
+	Vector testHullMins = GetHullMins();
+	testHullMins.z += (StepHeight() * 2);
+
+	// Probe
+	HunterTraceHull_SkipPhysics( GetAbsOrigin(), testPos, testHullMins, GetHullMaxs(), MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr, VPhysicsGetObject()->GetMass() * 0.5f );
+
+	// Debug info
+	if ( g_debug_hunter_charge.GetInt() == 1 )
+	{
+		if ( tr.fraction == 1.0f )
+		{
+  			NDebugOverlay::BoxDirection( GetAbsOrigin(), testHullMins, GetHullMaxs() + Vector(testLength,0,0), forward, 0, 255, 0, 8, 0.1f );
+   		}
+   		else
+   		{
+  			NDebugOverlay::BoxDirection( GetAbsOrigin(), testHullMins, GetHullMaxs() + Vector(testLength,0,0), forward, 255, 0, 0, 8, 0.1f );
+		}
+	}
+
+	// Add in this component
+	steer += ( right * 0.5f ) * ( 1.0f - tr.fraction );
+
+	// Offset left
+	angles[YAW] -= 90.0f;
+	AngleVectors( angles, &forward );
+
+	// Probe out
+	testPos = GetAbsOrigin() + ( forward * testLength );
+	HunterTraceHull_SkipPhysics( GetAbsOrigin(), testPos, testHullMins, GetHullMaxs(), MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr, VPhysicsGetObject()->GetMass() * 0.5f );
+
+	// Debug
+	if ( g_debug_hunter_charge.GetInt() == 1 )
+	{
+		if ( tr.fraction == 1.0f )
+		{
+			NDebugOverlay::BoxDirection( GetAbsOrigin(), testHullMins, GetHullMaxs() + Vector(testLength,0,0), forward, 0, 255, 0, 8, 0.1f );
+		}
+		else
+		{
+			NDebugOverlay::BoxDirection( GetAbsOrigin(), testHullMins, GetHullMaxs() + Vector(testLength,0,0), forward, 255, 0, 0, 8, 0.1f );
+		}
+	}
+
+	// Add in this component
+	steer -= ( right * 0.5f ) * ( 1.0f - tr.fraction );
+
+	// Debug
+	if ( g_debug_hunter_charge.GetInt() == 1 )
+	{
+		NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + ( steer * 512.0f ), 255, 255, 0, true, 0.1f );
+		NDebugOverlay::Cross3D( GetAbsOrigin() + ( steer * 512.0f ), Vector(2,2,2), -Vector(2,2,2), 255, 255, 0, true, 0.1f );
+
+		NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + ( BodyDirection3D() * 256.0f ), 255, 0, 255, true, 0.1f );
+		NDebugOverlay::Cross3D( GetAbsOrigin() + ( BodyDirection3D() * 256.0f ), Vector(2,2,2), -Vector(2,2,2), 255, 0, 255, true, 0.1f );
+	}
+
+	return UTIL_AngleDiff( UTIL_VecToYaw( steer ), faceYaw );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::ChargeDamage( CBaseEntity *pTarget )
+{
+	if ( pTarget == NULL )
+		return;
+
+	CBasePlayer *pPlayer = ToBasePlayer( pTarget );
+
+	if ( pPlayer != NULL )
+	{
+		//Kick the player angles
+		pPlayer->ViewPunch( QAngle( 20, 20, -30 ) );	
+
+		Vector	dir = pPlayer->WorldSpaceCenter() - WorldSpaceCenter();
+		VectorNormalize( dir );
+		dir.z = 0.0f;
+		
+		Vector vecNewVelocity = dir * 250.0f;
+		vecNewVelocity[2] += 128.0f;
+		pPlayer->SetAbsVelocity( vecNewVelocity );
+
+		color32 red = {128,0,0,128};
+		UTIL_ScreenFade( pPlayer, red, 1.0f, 0.1f, FFADE_IN );
+	}
+	
+	// Player takes less damage
+	float flDamage = ( pPlayer == NULL ) ? 250 : sk_hunter_dmg_charge.GetFloat();
+	
+	// If it's being held by the player, break that bond
+	Pickup_ForcePlayerToDropThisObject( pTarget );
+
+	// Calculate the physics force
+	Hunter_ApplyChargeDamage( this, pTarget, flDamage );
+}
+
+
+//-----------------------------------------------------------------------------
+// Handles the hunter charging into something. Returns true if it hit the world.
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::HandleChargeImpact( Vector vecImpact, CBaseEntity *pEntity )
+{
+	// Cause a shock wave from this point which will disrupt nearby physics objects
+	//ImpactShock( vecImpact, 128, 350 );
+
+	// Did we hit anything interesting?
+	if ( !pEntity || pEntity->IsWorld() )
+	{
+		// Robin: Due to some of the finicky details in the motor, the hunter will hit
+		//		  the world when it is blocked by our enemy when trying to step up 
+		//		  during a moveprobe. To get around this, we see if the enemy's within
+		//		  a volume in front of the hunter when we hit the world, and if he is,
+		//		  we hit him anyway.
+		EnemyIsRightInFrontOfMe( &pEntity );
+
+		// Did we manage to find him? If not, increment our charge miss count and abort.
+		if ( pEntity->IsWorld() )
+		{
+			return true;
+		}
+	}
+
+	// Hit anything we don't like
+	if ( IRelationType( pEntity ) == D_HT && ( GetNextAttack() < gpGlobals->curtime ) )
+	{
+		EmitSound( "NPC_Hunter.ChargeHitEnemy" );
+
+		// dvs: TODO:
+		//if ( !IsPlayingGesture( ACT_HUNTER_CHARGE_HIT ) )
+		//{
+		//	RestartGesture( ACT_HUNTER_CHARGE_HIT );
+		//}
+		
+		ChargeDamage( pEntity );
+
+		if ( !pEntity->IsNPC() )
+		{
+			pEntity->ApplyAbsVelocityImpulse( ( BodyDirection2D() * 400 ) + Vector( 0, 0, 200 ) );
+		}
+
+		if ( !pEntity->IsAlive() && GetEnemy() == pEntity )
+		{
+			SetEnemy( NULL );
+		}
+
+		SetNextAttack( gpGlobals->curtime + 2.0f );
+
+		if ( !pEntity->IsAlive() || !pEntity->IsNPC() )
+		{
+			SetIdealActivity( ACT_HUNTER_CHARGE_STOP );
+			return false;
+		}
+		else
+			return true;
+
+	}
+
+	// Hit something we don't hate. If it's not moveable, crash into it.
+	if ( pEntity->GetMoveType() == MOVETYPE_NONE || pEntity->GetMoveType() == MOVETYPE_PUSH )
+	{		
+		CBreakable *pBreakable = dynamic_cast<CBreakable *>(pEntity);
+		if ( pBreakable  && pBreakable->IsBreakable() && pBreakable->m_takedamage == DAMAGE_YES && pBreakable->GetHealth() > 0 )
+		{
+			ChargeDamage( pEntity );
+		}
+		return true;
+	}
+
+	// If it's a vphysics object that's too heavy, crash into it too.
+	if ( pEntity->GetMoveType() == MOVETYPE_VPHYSICS )
+	{
+		IPhysicsObject *pPhysics = pEntity->VPhysicsGetObject();
+		if ( pPhysics )
+		{
+			// If the object is being held by the player, knock it out of his hands
+			if ( pPhysics->GetGameFlags() & FVPHYSICS_PLAYER_HELD )
+			{
+				Pickup_ForcePlayerToDropThisObject( pEntity );
+				return false;
+			}
+
+			if ( !pPhysics->IsMoveable() )
+				return true;
+
+			float entMass = PhysGetEntityMass( pEntity ) ;
+			float minMass = VPhysicsGetObject()->GetMass() * 0.5f;
+			if ( entMass < minMass )
+			{
+				if ( entMass < minMass * 0.666f || pEntity->CollisionProp()->BoundingRadius() < GetHullHeight() )
+				{
+					if ( pEntity->GetHealth() > 0 )
+					{
+						CBreakableProp *pBreakable = dynamic_cast<CBreakableProp *>(pEntity);
+						if ( pBreakable && pBreakable->m_takedamage == DAMAGE_YES && pBreakable->GetHealth() > 0 && pBreakable->GetHealth() <= 50 )
+						{
+							ChargeDamage( pEntity );
+						}
+					}
+					pEntity->SetNavIgnore( 2.0 );
+					return false;
+				}
+			}
+			return true;
+
+		}
+	}
+
+	return false;
+}
+
+
+//-------------------------------------------------------------------------------------------------
+//-------------------------------------------------------------------------------------------------
+void CNPC_Hunter::Explode()
+{
+	Vector			velocity = vec3_origin;
+	AngularImpulse	angVelocity = RandomAngularImpulse( -150, 150 );
+
+	PropBreakableCreateAll( GetModelIndex(), NULL, EyePosition(), GetAbsAngles(), velocity, angVelocity, 1.0, 150, COLLISION_GROUP_NPC, this );
+
+	ExplosionCreate( EyePosition(), GetAbsAngles(), this, 500, 256, (SF_ENVEXPLOSION_NOPARTICLES|SF_ENVEXPLOSION_NOSPARKS|SF_ENVEXPLOSION_NODLIGHTS|SF_ENVEXPLOSION_NODAMAGE|SF_ENVEXPLOSION_NOSMOKE), false );
+
+	// Create liquid fountain gushtacular effect here!
+	CEffectData	data;
+
+	data.m_vOrigin = EyePosition();
+	data.m_vNormal = Vector( 0, 0, 1 );
+	data.m_flScale = 4.0f;
+
+	DispatchEffect( "StriderBlood", data );
+	
+	// Go away
+	m_lifeState = LIFE_DEAD;
+
+	SetThink( &CNPC_Hunter::SUB_Remove );
+	SetNextThink( gpGlobals->curtime + 0.1f );
+
+	AddEffects( EF_NODRAW );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+Activity CNPC_Hunter::NPC_TranslateActivity( Activity baseAct )
+{
+	if ( ( baseAct == ACT_WALK ) || ( baseAct == ACT_RUN ) )
+	{
+  		if ( GetEnemy() )
+  		{
+			Vector vecEnemyLKP = GetEnemyLKP();
+			
+			// Only start facing when we're close enough
+			if ( UTIL_DistApprox( vecEnemyLKP, GetAbsOrigin() ) < HUNTER_FACE_ENEMY_DIST )
+			{
+				return (Activity)ACT_HUNTER_WALK_ANGRY;
+			}
+		}
+	}
+	else if ( ( baseAct == ACT_IDLE ) && m_bPlanted )
+	{
+		return ( Activity )ACT_HUNTER_IDLE_PLANTED;
+	}
+	else if ( baseAct == ACT_RANGE_ATTACK2 )
+	{
+		if ( !m_bPlanted && ( m_bEnableUnplantedShooting || IsStriderBuster( GetEnemy() ) ) )
+		{
+			return (Activity)ACT_HUNTER_RANGE_ATTACK2_UNPLANTED;
+		}
+	}
+	
+	return BaseClass::NPC_TranslateActivity( baseAct );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::HandleAnimEvent( animevent_t *pEvent )
+{
+	Vector footPosition;
+	QAngle angles;
+	
+	if ( pEvent->event == AE_HUNTER_FOOTSTEP_LEFT )
+	{
+		LeftFootHit( pEvent->eventtime );
+		return;
+	}
+
+	if ( pEvent->event == AE_HUNTER_FOOTSTEP_RIGHT )
+	{
+		RightFootHit( pEvent->eventtime );
+		return;
+	}
+
+	if ( pEvent->event == AE_HUNTER_FOOTSTEP_BACK )
+	{
+		BackFootHit( pEvent->eventtime );
+		return;
+	}
+	
+	if ( pEvent->event == AE_HUNTER_START_EXPRESSION )
+	{
+		if ( pEvent->options && Q_strlen( pEvent->options ) )
+		{
+			//m_iszCurrentExpression = AllocPooledString( pEvent->options );
+			//SetExpression( pEvent->options );
+		}
+		return;
+	}
+
+	if ( pEvent->event == AE_HUNTER_END_EXPRESSION )
+	{
+		if ( pEvent->options && Q_strlen( pEvent->options ) )
+		{
+			//m_iszCurrentExpression = NULL_STRING;
+			//RemoveActorFromScriptedScenes( this, true, false, pEvent->options );
+		}
+		return;
+	}
+
+	if ( pEvent->event == AE_HUNTER_MELEE_ANNOUNCE )
+	{
+		EmitSound( "NPC_Hunter.MeleeAnnounce" );
+		return;
+	}
+		
+	if ( pEvent->event == AE_HUNTER_MELEE_ATTACK_LEFT )
+	{
+		Vector right, forward, dir;
+		AngleVectors( GetLocalAngles(), &forward, &right, NULL );
+
+		right = right * -100;
+		forward = forward * 600;
+		dir = right + forward;
+		QAngle angle( 25, 30, -20 );
+
+		MeleeAttack( HUNTER_MELEE_REACH, sk_hunter_dmg_one_slash.GetFloat(), angle, dir, HUNTER_BLOOD_LEFT_FOOT );
+		return;
+	}
+
+	if ( pEvent->event == AE_HUNTER_MELEE_ATTACK_RIGHT )
+	{
+		Vector right, forward,dir;
+		AngleVectors( GetLocalAngles(), &forward, &right, NULL );
+
+		right = right * 100;
+		forward = forward * 600;
+		dir = right + forward;
+		
+		QAngle angle( 25, -30, 20 );
+
+		MeleeAttack( HUNTER_MELEE_REACH, sk_hunter_dmg_one_slash.GetFloat(), angle, dir, HUNTER_BLOOD_LEFT_FOOT );
+		return;
+	}
+
+	if ( pEvent->event == AE_HUNTER_SPRAY_BLOOD )
+	{
+		Vector vecOrigin;
+		Vector vecDir;
+	
+		// spray blood from the attachment point
+		bool bGotAttachment = false;
+		if ( pEvent->options )
+		{
+			QAngle angDir;
+			if ( GetAttachment( pEvent->options, vecOrigin, angDir ) )
+			{
+				bGotAttachment = true;
+				AngleVectors( angDir, &vecDir, NULL, NULL );
+			}
+		}
+
+		// fall back to our center, tracing forward
+		if ( !bGotAttachment )
+		{	
+			vecOrigin = WorldSpaceCenter();
+			GetVectors( &vecDir, NULL, NULL );
+		}
+		
+		UTIL_BloodSpray( vecOrigin, vecDir, BLOOD_COLOR_RED, 4, FX_BLOODSPRAY_ALL );
+
+		for ( int i = 0 ; i < 3 ; i++ )
+		{
+			Vector vecTraceDir = vecDir;
+			vecTraceDir.x += random->RandomFloat( -0.1, 0.1 );
+			vecTraceDir.y += random->RandomFloat( -0.1, 0.1 );
+			vecTraceDir.z += random->RandomFloat( -0.1, 0.1 );
+
+			trace_t tr;
+			AI_TraceLine( vecOrigin, vecOrigin + ( vecTraceDir * 192.0f ), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
+			if ( tr.fraction != 1.0 )
+			{
+				UTIL_BloodDecalTrace( &tr, BLOOD_COLOR_RED );
+			}
+		}
+
+		return;
+	}
+
+	BaseClass::HandleAnimEvent( pEvent );
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::AddEntityRelationship( CBaseEntity *pEntity, Disposition_t nDisposition, int nPriority )
+{
+	if ( nDisposition ==  D_HT && pEntity->ClassMatches("npc_bullseye") )
+		UpdateEnemyMemory( pEntity, pEntity->GetAbsOrigin() );
+	BaseClass::AddEntityRelationship( pEntity, nDisposition, nPriority );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::ScheduledMoveToGoalEntity( int scheduleType, CBaseEntity *pGoalEntity, Activity movementActivity )
+{
+	if ( IsCurSchedule( SCHED_HUNTER_RANGE_ATTACK1, false ) )
+	{
+		SetGoalEnt( pGoalEntity );
+		return true;
+	}
+	return BaseClass::ScheduledMoveToGoalEntity( scheduleType, pGoalEntity, movementActivity );
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::OnChangeHintGroup( string_t oldGroup, string_t newGroup )
+{
+	SetCondition( COND_HUNTER_NEW_HINTGROUP );
+	m_CheckHintGroupTimer.Set( 10 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Tells whether any given hunter is in a squad that contains other hunters.
+// This is useful for preventing timid behavior for Hunters that are not 
+// supported by other hunters.
+//
+// NOTE:	This counts the self! So a hunter that is alone in his squad
+//			receives a result of 1.
+//-----------------------------------------------------------------------------
+int CNPC_Hunter::NumHuntersInMySquad()
+{
+	AISquadIter_t iter;
+	CAI_BaseNPC *pSquadmate = m_pSquad ? m_pSquad->GetFirstMember( &iter ) : NULL;
+
+	if( !pSquadmate )
+	{
+		// Not in a squad at all, but the caller is not concerned with that. Just
+		// tell them that we're in a squad of one (ourself)
+		return 1;
+	}
+	
+	int count = 0;
+
+	while ( pSquadmate )
+	{
+		if( pSquadmate->m_iClassname == m_iClassname )
+			count++;
+
+		pSquadmate = m_pSquad->GetNextMember( &iter );
+	}
+
+	return count;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::FollowStrider( const char *szStrider )
+{
+	if ( !szStrider )
+		return;
+
+	CBaseEntity *pEnt = gEntList.FindEntityByName( NULL, szStrider, this );
+	CNPC_Strider *pStrider = dynamic_cast <CNPC_Strider *>( pEnt );
+	FollowStrider(pStrider);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::FollowStrider( CNPC_Strider * pStrider )
+{
+	if ( !IsAlive() )
+	{
+		return;
+	}
+
+	if ( pStrider )
+	{
+		if ( m_EscortBehavior.GetFollowTarget() != pStrider )
+		{
+			m_iszFollowTarget = pStrider->GetEntityName();
+			if ( m_iszFollowTarget == NULL_STRING )
+			{
+				m_iszFollowTarget = AllocPooledString( "unnamed_strider" );
+			}
+			m_EscortBehavior.SetEscortTarget( pStrider );
+		}
+	}
+	else
+	{
+		DevWarning("Hunter set to follow entity %s that is not a strider\n", STRING( m_iszFollowTarget ) );
+		m_iszFollowTarget = AllocPooledString( "unknown_strider" );
+	}
+}
+
+void CAI_HunterEscortBehavior::SetEscortTarget( CNPC_Strider *pStrider, bool fFinishCurSchedule )
+{
+	m_bEnabled = true;
+
+	if ( GetOuter()->GetSquad() )
+	{
+		GetOuter()->GetSquad()->RemoveFromSquad( GetOuter() );
+	}
+
+	for ( int i = 0; i < g_Hunters.Count(); i++ )
+	{
+		if ( g_Hunters[i]->m_EscortBehavior.GetFollowTarget() == pStrider )
+		{
+			Assert( g_Hunters[i]->GetSquad() );
+			g_Hunters[i]->GetSquad()->AddToSquad( GetOuter() );
+			break;
+		}
+	}
+
+	if ( !GetOuter()->GetSquad() )
+	{
+		GetOuter()->AddToSquad( AllocPooledString( CFmtStr( "%s_hunter_squad", STRING( pStrider->GetEntityName() ) ) ) );
+	}
+
+	BaseClass::SetFollowTarget( pStrider );
+	m_flTimeEscortReturn = gpGlobals->curtime;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::InputEnableUnplantedShooting( inputdata_t &inputdata )
+{
+	m_bEnableUnplantedShooting = true;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::InputDisableUnplantedShooting( inputdata_t &inputdata )
+{
+	m_bEnableUnplantedShooting = false;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::InputFollowStrider( inputdata_t &inputdata )
+{
+	m_iszFollowTarget = inputdata.value.StringID();
+	if ( m_iszFollowTarget == s_iszStriderClassname )
+	{
+		m_EscortBehavior.m_bEnabled = true;
+		m_iszFollowTarget = NULL_STRING;
+	}
+	m_BeginFollowDelay.Start( .1 ); // Allow time for strider to spawn
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::InputUseSiegeTargets( inputdata_t &inputdata )
+{
+	m_iszSiegeTargetName = inputdata.value.StringID();
+	m_flTimeNextSiegeTargetAttack = gpGlobals->curtime + random->RandomFloat( 1, hunter_siege_frequency.GetFloat() );
+
+	if( m_iszSiegeTargetName == NULL_STRING )
+	{
+		// Turning the feature off. Restore m_flDistTooFar to default.
+		m_flDistTooFar = hunter_flechette_max_range.GetFloat();
+		m_pSiegeTargets.RemoveAll();
+	}
+	else
+	{
+		// We're going into siege mode. Adjust range accordingly.
+		m_flDistTooFar = hunter_flechette_max_range.GetFloat() * HUNTER_SIEGE_MAX_DIST_MODIFIER;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::InputDodge( inputdata_t &inputdata )
+{
+	SetCondition( COND_HUNTER_FORCED_DODGE );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::InputFlankEnemy( inputdata_t &inputdata )
+{
+	SetCondition( COND_HUNTER_FORCED_FLANK_ENEMY );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::InputDisableShooting( inputdata_t &inputdata )
+{
+	m_bDisableShooting = true;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::InputEnableShooting( inputdata_t &inputdata )
+{
+	m_bDisableShooting = false;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::InputEnableSquadShootDelay( inputdata_t &inputdata )
+{
+	m_bEnableSquadShootDelay = true;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::InputDisableSquadShootDelay( inputdata_t &inputdata )
+{
+	m_bEnableSquadShootDelay = false;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::FVisible( CBaseEntity *pEntity, int traceMask, CBaseEntity **ppBlocker )
+{
+	return BaseClass::FVisible( pEntity, traceMask, ppBlocker );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::IsValidEnemy( CBaseEntity *pTarget )
+{
+	if ( IsStriderBuster( pTarget) )
+	{
+		if ( !m_EscortBehavior.m_bEnabled || !m_EscortBehavior.GetEscortTarget() )
+		{
+			// We only hate striderbusters when we are actively protecting a strider.
+			return false;
+		}
+
+		if ( pTarget->VPhysicsGetObject() )
+		{
+			if ( ( pTarget->VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_PLAYER_HELD ) &&
+				hunter_hate_held_striderbusters.GetBool() )
+			{
+				if ( gpGlobals->curtime - StriderBuster_GetPickupTime( pTarget ) > hunter_hate_held_striderbusters_delay.GetFloat())
+				{
+					if ( StriderBuster_NumFlechettesAttached( pTarget ) <= 2 )
+					{
+						if ( m_EscortBehavior.GetEscortTarget() && 
+							( m_EscortBehavior.GetEscortTarget()->GetAbsOrigin().AsVector2D() - pTarget->GetAbsOrigin().AsVector2D() ).LengthSqr() < Square( hunter_hate_held_striderbusters_tolerance.GetFloat() ) )
+						{
+							return true;
+						}
+					}
+				}
+				return false;
+			}
+
+			bool bThrown = ( pTarget->VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_WAS_THROWN ) != 0;
+			bool bAttached = StriderBuster_IsAttachedStriderBuster( pTarget );
+
+			if ( ( bThrown && !bAttached ) && hunter_hate_thrown_striderbusters.GetBool() )
+			{
+				float t;
+				float dist = CalcDistanceSqrToLineSegment2D( m_EscortBehavior.GetEscortTarget()->GetAbsOrigin().AsVector2D(), 
+					pTarget->GetAbsOrigin().AsVector2D(), 
+					pTarget->GetAbsOrigin().AsVector2D() + pTarget->GetSmoothedVelocity().AsVector2D(), &t );
+
+				if ( t > 0 && dist < Square( hunter_hate_thrown_striderbusters_tolerance.GetFloat() ))
+				{
+					return true;
+				}
+				return false;
+			}
+
+			if ( bAttached && StriderBuster_IsAttachedStriderBuster( pTarget, m_EscortBehavior.GetEscortTarget() ) && hunter_hate_attached_striderbusters.GetBool() )
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+
+	return BaseClass::IsValidEnemy( pTarget );
+}
+
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+Disposition_t CNPC_Hunter::IRelationType( CBaseEntity *pTarget )
+{
+	if ( !pTarget )
+		return D_NU;
+
+	if ( IsStriderBuster( pTarget ) )
+	{
+		if ( HateThisStriderBuster( pTarget ) )
+			return D_HT;
+
+		return D_NU;
+	}
+
+	if ( hunter_retreat_striderbusters.GetBool() )
+	{
+		if ( pTarget->IsPlayer() && (m_hAttachedBusters.Count() > 0) )
+		{
+			return D_FR;
+		}
+	}
+		
+	return BaseClass::IRelationType( pTarget );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CNPC_Hunter::IRelationPriority( CBaseEntity *pTarget )
+{
+	if ( IsStriderBuster( pTarget ) )
+	{
+		// If we're here, we already know that we hate striderbusters.
+		return 1000.0f;
+	}
+
+	return BaseClass::IRelationPriority( pTarget );
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::SetSquad( CAI_Squad *pSquad )
+{
+	BaseClass::SetSquad( pSquad );
+	if ( pSquad && pSquad->NumMembers() == 1 )
+	{
+		pSquad->SetSquadData( HUNTER_RUNDOWN_SQUADDATA, 0 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::OnSeeEntity( CBaseEntity *pEntity )
+{
+	BaseClass::OnSeeEntity(pEntity);
+
+	if ( IsStriderBuster( pEntity ) && IsValidEnemy( pEntity ) )
+	{
+		SetCondition( COND_HUNTER_SEE_STRIDERBUSTER );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::UpdateEnemyMemory( CBaseEntity *pEnemy, const Vector &position, CBaseEntity *pInformer )
+{
+	//EmitSound( "NPC_Hunter.Alert" );
+	return BaseClass::UpdateEnemyMemory( pEnemy, position, pInformer );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::CanPlantHere( const Vector &vecPos )
+{
+	// TODO: cache results?
+	//if ( vecPos == m_vecLastCanPlantHerePos )
+	//{
+	//	return m_bLastCanPlantHere;
+	//}
+
+	Vector vecMins = GetHullMins();
+	Vector vecMaxs = GetHullMaxs();
+	
+	vecMins.x -= 16;
+	vecMins.y -= 16;
+
+	vecMaxs.x += 16;
+	vecMaxs.y += 16;
+	vecMaxs.z -= hunter_plant_adjust_z.GetInt();
+	
+	bool bResult = false;
+
+	trace_t tr;
+	UTIL_TraceHull( vecPos, vecPos, vecMins, vecMaxs, MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );
+	if ( tr.startsolid )
+	{
+		// Try again, tracing down from above.
+		Vector vecStart = vecPos;
+		vecStart.z += hunter_plant_adjust_z.GetInt();
+		
+		UTIL_TraceHull( vecStart, vecPos, vecMins, vecMaxs, MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );
+	}
+	
+	if ( tr.startsolid )
+	{
+		//NDebugOverlay::Box( vecPos, vecMins, vecMaxs, 255, 0, 0, 0, 0 );
+	}
+	else
+	{	
+		//NDebugOverlay::Box( vecPos, vecMins, vecMaxs, 0, 255, 0, 0, 0 );
+		bResult = true;
+	}
+
+	// Cache the results in case we ask again for the same spot.	
+	//m_vecLastCanPlantHerePos = vecPos;
+	//m_bLastCanPlantHere = bResult;
+
+	return bResult;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CNPC_Hunter::MeleeAttack1ConditionsVsEnemyInVehicle( CBaseCombatCharacter *pEnemy, float flDot )
+{
+	if( !IsCorporealEnemy( GetEnemy() ) )
+		return COND_NONE;
+
+	// Try and trace a box to the player, and if I hit the vehicle, attack it
+	Vector vecDelta = (pEnemy->WorldSpaceCenter() - WorldSpaceCenter());
+	VectorNormalize( vecDelta );
+	trace_t	tr;
+	AI_TraceHull( WorldSpaceCenter(), WorldSpaceCenter() + (vecDelta * 64), -Vector(8,8,8), Vector(8,8,8), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
+	if ( tr.fraction != 1.0 && tr.m_pEnt == pEnemy->GetVehicleEntity() )
+	{
+		// We're near the vehicle. Are we facing it?
+		if (flDot < 0.7)
+			return COND_NOT_FACING_ATTACK;
+
+		return COND_CAN_MELEE_ATTACK1;
+	}
+
+	return COND_TOO_FAR_TO_ATTACK;
+}
+
+
+//-----------------------------------------------------------------------------
+// For innate melee attack
+//-----------------------------------------------------------------------------
+int CNPC_Hunter::MeleeAttack1Conditions ( float flDot, float flDist )
+{
+	if ( !IsCorporealEnemy( GetEnemy() ) )
+		return COND_NONE;
+		
+	if ( ( gpGlobals->curtime < m_flNextMeleeTime ) && // allow berzerk bashing if cornered
+		!( m_hAttachedBusters.Count() > 0 && gpGlobals->curtime < m_fCorneredTimer ) )
+	{
+		return COND_NONE;
+	}
+
+	if ( GetEnemy()->Classify() == CLASS_PLAYER_ALLY_VITAL )
+	{
+		return COND_NONE;
+	}
+		
+	if ( flDist > HUNTER_MELEE_REACH )
+	{
+		// Translate a hit vehicle into its passenger if found
+		if ( GetEnemy() != NULL )
+		{
+			CBaseCombatCharacter *pCCEnemy = GetEnemy()->MyCombatCharacterPointer();
+			if ( pCCEnemy != NULL && pCCEnemy->IsInAVehicle() )
+			{
+				return MeleeAttack1ConditionsVsEnemyInVehicle( pCCEnemy, flDot );
+			}
+
+#if defined(HL2_DLL) && !defined(HL2MP)
+			// If the player is holding an object, knock it down.
+			if ( GetEnemy()->IsPlayer() )
+			{
+				CBasePlayer *pPlayer = ToBasePlayer( GetEnemy() );
+
+				Assert( pPlayer != NULL );
+
+				// Is the player carrying something?
+				CBaseEntity *pObject = GetPlayerHeldEntity(pPlayer);
+
+				if ( !pObject )
+				{
+					pObject = PhysCannonGetHeldEntity( pPlayer->GetActiveWeapon() );
+				}
+
+				if ( pObject )
+				{
+					float flDist = pObject->WorldSpaceCenter().DistTo( WorldSpaceCenter() );
+
+					if ( flDist <= HUNTER_MELEE_REACH )
+					{
+						return COND_CAN_MELEE_ATTACK1;
+					}
+				}
+			}
+#endif
+		}
+	
+		return COND_TOO_FAR_TO_ATTACK;
+	}
+
+	if (flDot < 0.7)
+	{
+		return COND_NOT_FACING_ATTACK;
+	}
+
+	// Build a cube-shaped hull, the same hull that MeleeAttack is going to use.
+	Vector vecMins = GetHullMins();
+	Vector vecMaxs = GetHullMaxs();
+	vecMins.z = vecMins.x;
+	vecMaxs.z = vecMaxs.x;
+
+	Vector forward;
+	GetVectors( &forward, NULL, NULL );
+
+	trace_t	tr;
+	AI_TraceHull( WorldSpaceCenter(), WorldSpaceCenter() + forward * HUNTER_MELEE_REACH, vecMins, vecMaxs, MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );
+
+	if ( tr.fraction == 1.0 || !tr.m_pEnt )
+	{
+		// This attack would miss completely. Trick the hunter into moving around some more.
+		return COND_TOO_FAR_TO_ATTACK;
+	}
+
+	if ( tr.m_pEnt == GetEnemy() || tr.m_pEnt->IsNPC() || (tr.m_pEnt->m_takedamage == DAMAGE_YES && (dynamic_cast<CBreakableProp*>(tr.m_pEnt))) )
+	{
+		// Let the hunter swipe at his enemy if he's going to hit them.
+		// Also let him swipe at NPC's that happen to be between the hunter and the enemy. 
+		// This makes mobs of hunters seem more rowdy since it doesn't leave guys in the back row standing around.
+		// Also let him swipe at things that takedamage, under the assumptions that they can be broken.
+		return COND_CAN_MELEE_ATTACK1;
+	}
+
+	// dvs TODO: incorporate this
+	/*if ( tr.m_pEnt->IsBSPModel() )
+	{
+		// The trace hit something solid, but it's not the enemy. If this item is closer to the hunter than
+		// the enemy is, treat this as an obstruction.
+		Vector vecToEnemy = GetEnemy()->WorldSpaceCenter() - WorldSpaceCenter();
+		Vector vecTrace = tr.endpos - tr.startpos;
+
+		if ( vecTrace.Length2DSqr() < vecToEnemy.Length2DSqr() )
+		{
+			return COND_HUNTER_LOCAL_MELEE_OBSTRUCTION;
+		}
+	}*/
+
+	if ( !tr.m_pEnt->IsWorld() && GetEnemy() && GetEnemy()->GetGroundEntity() == tr.m_pEnt )
+	{
+		// Try to swat whatever the player is standing on instead of acting like a dill.
+		return COND_CAN_MELEE_ATTACK1;
+	}
+
+	// Move around some more
+	return COND_TOO_FAR_TO_ATTACK;
+}
+
+
+//-----------------------------------------------------------------------------
+// For innate melee attack
+//-----------------------------------------------------------------------------
+int CNPC_Hunter::MeleeAttack2Conditions ( float flDot, float flDist )
+{
+	return COND_NONE;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::IsCorporealEnemy( CBaseEntity *pEnemy ) 
+{
+	if( !pEnemy )
+		return false;
+
+	// Generally speaking, don't melee attack anything the player can't see.
+	if( pEnemy->IsEffectActive( EF_NODRAW ) )
+		return false;
+
+	// Don't flank, melee attack striderbusters.
+	if ( IsStriderBuster( pEnemy ) )
+		return false;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CNPC_Hunter::RangeAttack1Conditions( float flDot, float flDist )
+{
+	return COND_NONE;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CNPC_Hunter::RangeAttack2Conditions( float flDot, float flDist )
+{
+	bool bIsBuster = IsStriderBuster( GetEnemy() );
+	bool bIsPerfectBullseye = ( GetEnemy() && dynamic_cast<CNPC_Bullseye *>(GetEnemy()) && ((CNPC_Bullseye *)GetEnemy())->UsePerfectAccuracy() );
+
+	if ( !bIsPerfectBullseye && !bIsBuster && !hunter_flechette_test.GetBool() && ( gpGlobals->curtime < m_flNextRangeAttack2Time ) )
+	{
+		return COND_NONE;
+	}
+
+	if ( m_bDisableShooting )
+	{
+		return COND_NONE;
+	}
+
+	if ( !HasCondition( COND_SEE_ENEMY ) )
+	{
+		return COND_NONE;
+	}
+
+	float flMaxFlechetteRange = hunter_flechette_max_range.GetFloat();
+
+	if ( IsUsingSiegeTargets() )
+	{
+		flMaxFlechetteRange *= HUNTER_SIEGE_MAX_DIST_MODIFIER;
+	}
+
+ 	if ( !bIsBuster && ( flDist > flMaxFlechetteRange ) )
+	{
+		return COND_TOO_FAR_TO_ATTACK;
+	}
+	else if ( !bIsBuster && ( !GetEnemy() || !GetEnemy()->ClassMatches( "npc_bullseye" ) ) && flDist < hunter_flechette_min_range.GetFloat() )
+	{
+		return COND_TOO_CLOSE_TO_ATTACK;
+	}
+	else if ( flDot < HUNTER_FACING_DOT )
+	{
+		return COND_NOT_FACING_ATTACK;
+	}
+	
+	if ( !bIsBuster && !m_bEnableUnplantedShooting && !hunter_flechette_test.GetBool() && !CanPlantHere( GetAbsOrigin() ) )
+	{
+		return COND_HUNTER_CANT_PLANT;
+	}
+
+	return COND_CAN_RANGE_ATTACK2;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::WeaponLOSCondition(const Vector &ownerPos, const Vector &targetPos, bool bSetConditions)
+{
+	CBaseEntity *pTargetEnt;
+
+	pTargetEnt = GetEnemy();
+
+	trace_t tr;
+	Vector vFrom = ownerPos + GetViewOffset();
+	AI_TraceLine( vFrom, targetPos, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
+
+	if ( ( pTargetEnt && tr.m_pEnt == pTargetEnt) || tr.fraction == 1.0 || CanShootThrough( tr, targetPos ) )
+	{
+		static Vector vMins( -2.0, -2.0, -2.0 );
+		static Vector vMaxs( -vMins);
+		// Hit the enemy, or hit nothing (traced all the way to a nonsolid enemy like a bullseye)
+		AI_TraceHull( vFrom - Vector( 0, 0, 18 ), targetPos, vMins, vMaxs, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);
+
+		if ( ( pTargetEnt && tr.m_pEnt == pTargetEnt) || tr.fraction == 1.0 || CanShootThrough( tr, targetPos ) )
+		{
+			if ( hunter_show_weapon_los_condition.GetBool() )
+			{
+				NDebugOverlay::Line( vFrom, targetPos, 255, 0, 255, false, 0.1 );
+				NDebugOverlay::Line( vFrom - Vector( 0, 0, 18 ), targetPos, 0, 0, 255, false, 0.1 );
+			}
+			return true;
+		}
+	}
+	else if ( bSetConditions )
+	{
+		SetCondition( COND_WEAPON_SIGHT_OCCLUDED );
+		SetEnemyOccluder( tr.m_pEnt );
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Look in front and see if the claw hit anything.
+//
+// Input  :	flDist				distance to trace		
+//			iDamage				damage to do if attack hits
+//			vecViewPunch		camera punch (if attack hits player)
+//			vecVelocityPunch	velocity punch (if attack hits player)
+//
+// Output : The entity hit by claws. NULL if nothing.
+//-----------------------------------------------------------------------------
+CBaseEntity *CNPC_Hunter::MeleeAttack( float flDist, int iDamage, QAngle &qaViewPunch, Vector &vecVelocityPunch, int BloodOrigin  )
+{
+	// Added test because claw attack anim sometimes used when for cases other than melee
+	if ( GetEnemy() )
+	{
+		trace_t	tr;
+		AI_TraceHull( WorldSpaceCenter(), GetEnemy()->WorldSpaceCenter(), -Vector(8,8,8), Vector(8,8,8), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
+
+		if ( tr.fraction < 1.0f )
+			return NULL;
+	}
+
+	//
+	// Trace out a cubic section of our hull and see what we hit.
+	//
+	Vector vecMins = GetHullMins();
+	Vector vecMaxs = GetHullMaxs();
+	vecMins.z = vecMins.x;
+	vecMaxs.z = vecMaxs.x;
+
+	CBaseEntity *pHurt = CheckTraceHullAttack( flDist, vecMins, vecMaxs, iDamage, DMG_SLASH );
+
+	if ( pHurt )
+	{
+		EmitSound( "NPC_Hunter.MeleeHit" );
+		EmitSound( "NPC_Hunter.TackleHit" );
+
+		CBasePlayer *pPlayer = ToBasePlayer( pHurt );
+
+		if ( pPlayer != NULL && !(pPlayer->GetFlags() & FL_GODMODE ) )
+		{
+			pPlayer->ViewPunch( qaViewPunch );
+			pPlayer->VelocityPunch( vecVelocityPunch );
+			
+			// Shake the screen
+			UTIL_ScreenShake( pPlayer->GetAbsOrigin(), 100.0, 1.5, 1.0, 2, SHAKE_START );
+
+			// Red damage indicator
+			color32 red = { 128, 0, 0, 128 };
+			UTIL_ScreenFade( pPlayer, red, 1.0f, 0.1f, FFADE_IN );
+
+			/*if ( UTIL_ShouldShowBlood( pPlayer->BloodColor() ) )
+			{
+				// Spray some of the player's blood on the hunter.			
+				trace_t tr;
+				
+				Vector vecHunterEyePos; // = EyePosition();
+				QAngle angDiscard;
+				GetBonePosition( LookupBone( "MiniStrider.top_eye_bone" ), vecHunterEyePos, angDiscard );
+
+				Vector vecPlayerEyePos = pPlayer->EyePosition();
+				
+				Vector vecDir = vecHunterEyePos - vecPlayerEyePos;
+				float flLen = VectorNormalize( vecDir );
+				
+				Vector vecStart = vecPlayerEyePos - ( vecDir * 64 );
+				Vector vecEnd = vecPlayerEyePos + ( vecDir * ( flLen + 64 ) );
+				
+				NDebugOverlay::HorzArrow( vecStart, vecEnd, 16, 255, 255, 0, 255, false, 10 );
+				
+				UTIL_TraceLine( vecStart, vecEnd, MASK_SHOT, pPlayer, COLLISION_GROUP_NONE, &tr );
+	
+				if ( tr.m_pEnt )
+				{
+					Msg( "Hit %s!!!\n", tr.m_pEnt->GetDebugName() );
+					UTIL_DecalTrace( &tr, "Blood" );
+				}
+			}*/
+		}
+		else if ( !pPlayer )
+		{
+			if ( IsMovablePhysicsObject( pHurt ) )
+			{
+				// If it's a vphysics object that's too heavy, crash into it too.
+				IPhysicsObject *pPhysics = pHurt->VPhysicsGetObject();
+				if ( pPhysics )
+				{
+					// If the object is being held by the player, break it or make them drop it.
+					if ( pPhysics->GetGameFlags() & FVPHYSICS_PLAYER_HELD )
+					{
+						// If it's breakable, break it.
+						if ( pHurt->m_takedamage == DAMAGE_YES )
+						{
+							CBreakableProp *pBreak = dynamic_cast<CBreakableProp*>(pHurt);
+							if ( pBreak )
+							{
+								CTakeDamageInfo info( this, this, 20, DMG_SLASH );
+								pBreak->Break( this, info );
+							}
+						}
+					}
+				}
+			}		
+		
+			if ( UTIL_ShouldShowBlood(pHurt->BloodColor()) )
+			{
+				// Hit an NPC. Bleed them!
+				Vector vecBloodPos;
+
+				switch ( BloodOrigin )
+				{
+					case HUNTER_BLOOD_LEFT_FOOT:
+					{
+						if ( GetAttachment( "blood_left", vecBloodPos ) )
+						{
+							SpawnBlood( vecBloodPos, g_vecAttackDir, pHurt->BloodColor(), MIN( iDamage, 30 ) );
+						}
+						
+						break;
+					}
+				}
+			}
+		}
+	}
+	else 
+	{
+		// TODO:
+		//AttackMissSound();
+	}
+
+	m_flNextMeleeTime = gpGlobals->curtime + hunter_melee_delay.GetFloat();
+
+	return pHurt;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::TestShootPosition(const Vector &vecShootPos, const Vector &targetPos )	
+{ 
+	if ( !CanPlantHere(vecShootPos ) )
+	{
+		return false;
+	}
+
+	return BaseClass::TestShootPosition( vecShootPos, targetPos );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+Vector CNPC_Hunter::Weapon_ShootPosition( )
+{
+	matrix3x4_t gunMatrix;
+	GetAttachment( gm_nTopGunAttachment, gunMatrix );
+
+	Vector vecShootPos;
+	MatrixGetColumn( gunMatrix, 3, vecShootPos );
+
+	return vecShootPos;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType )
+{
+	float flTracerDist;
+	Vector vecDir;
+	Vector vecEndPos;
+
+	vecDir = tr.endpos - vecTracerSrc;
+
+	flTracerDist = VectorNormalize( vecDir );
+
+	int nAttachment = LookupAttachment( "MiniGun" );
+
+	UTIL_Tracer( vecTracerSrc, tr.endpos, nAttachment, TRACER_FLAG_USEATTACHMENT, 5000, true, "HunterTracer" );
+}
+
+
+//-----------------------------------------------------------------------------
+// Trace didn't hit the intended target, but should the hunter
+// shoot anyway? We use this to get the hunter to destroy 
+// breakables that are between him and his target.
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::CanShootThrough( const trace_t &tr, const Vector &vecTarget )
+{
+	if ( !tr.m_pEnt )
+	{
+		return false;
+	}
+
+	if ( !tr.m_pEnt->GetHealth() )
+	{
+		return false;
+	}
+	
+	// Don't try to shoot through allies.
+	CAI_BaseNPC *pNPC = tr.m_pEnt->MyNPCPointer();
+	if ( pNPC && ( IRelationType( pNPC ) == D_LI ) )
+	{
+		return false;
+	}
+
+	// Would a trace ignoring this entity continue to the target?
+	trace_t continuedTrace;
+	AI_TraceLine( tr.endpos, vecTarget, MASK_SHOT, tr.m_pEnt, COLLISION_GROUP_NONE, &continuedTrace );
+
+	if ( continuedTrace.fraction != 1.0 )
+	{
+		if ( continuedTrace.m_pEnt != GetEnemy() )
+		{
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CNPC_Hunter::GetSoundInterests()
+{
+	return SOUND_WORLD | SOUND_COMBAT | SOUND_PLAYER | SOUND_DANGER | SOUND_PHYSICS_DANGER | SOUND_PLAYER_VEHICLE | SOUND_BULLET_IMPACT | SOUND_MOVE_AWAY;
+}
+
+//-----------------------------------------------------------------------------
+// Tells us whether the Hunter is acting in a large, outdoor map, 
+// currently only ep2_outland_12. This allows us to create logic
+// branches here in the AI code so that we can make choices that
+// tailor behavior to larger and smaller maps.
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::IsInLargeOutdoorMap()
+{
+	return m_bInLargeOutdoorMap;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::AlertSound()
+{
+	EmitSound( "NPC_Hunter.Alert" );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::PainSound( const CTakeDamageInfo &info )
+{
+	if ( gpGlobals->curtime > m_flNextDamageTime )
+	{
+		EmitSound( "NPC_Hunter.Pain" );
+		m_flNextDamageTime = gpGlobals->curtime + random->RandomFloat( 0.5, 1.2 ); 
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::DeathSound( const CTakeDamageInfo &info )
+{
+	EmitSound( "NPC_Hunter.Death" );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::TraceAttack( const CTakeDamageInfo &inputInfo, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
+{
+	CTakeDamageInfo info = inputInfo;
+
+	// Even though the damage might not hurt us, we want to react to it
+	// if it's from the player.
+	if ( info.GetAttacker()->IsPlayer() )
+	{
+		if ( !HasMemory( bits_MEMORY_PROVOKED ) )
+		{
+			GetEnemies()->ClearMemory( info.GetAttacker() );
+			Remember( bits_MEMORY_PROVOKED );
+			SetCondition( COND_LIGHT_DAMAGE );
+		}
+	}
+
+	// HUnters have special resisitance to some types of damage.
+	if ( ( info.GetDamageType() & DMG_BULLET ) ||
+		 ( info.GetDamageType() & DMG_BUCKSHOT ) ||
+		 ( info.GetDamageType() & DMG_CLUB ) ||
+		 ( info.GetDamageType() & DMG_NEVERGIB ) )
+	{
+		float flScale = 1.0;
+		
+		if ( info.GetDamageType() & DMG_BUCKSHOT )
+		{
+			flScale = sk_hunter_buckshot_damage_scale.GetFloat();
+		}
+		else if ( ( info.GetDamageType() & DMG_BULLET ) || ( info.GetDamageType() & DMG_NEVERGIB ) )
+		{
+			// Hunters resist most bullet damage, but they are actually vulnerable to .357 rounds, 
+			// since players regard that weapon as one of the game's truly powerful weapons.
+			if( info.GetAmmoType() == GetAmmoDef()->Index("357") )
+			{
+				flScale = 1.16f;
+			}
+			else
+			{
+				flScale = sk_hunter_bullet_damage_scale.GetFloat();
+			}
+		}
+
+		if ( GetActivity() == ACT_HUNTER_CHARGE_RUN )
+		{
+			flScale *= sk_hunter_charge_damage_scale.GetFloat();
+		}
+		
+		if ( flScale != 0 )
+		{
+			float flDamage = info.GetDamage() * flScale;
+			info.SetDamage( flDamage );
+		}
+		
+		QAngle vecAngles;
+		VectorAngles( ptr->plane.normal, vecAngles );
+		DispatchParticleEffect( "blood_impact_synth_01", ptr->endpos, vecAngles );
+		DispatchParticleEffect( "blood_impact_synth_01_arc_parent", PATTACH_POINT_FOLLOW, this, gm_nHeadCenterAttachment );
+	}
+
+	BaseClass::TraceAttack( info, vecDir, ptr, pAccumulator );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+const impactdamagetable_t &CNPC_Hunter::GetPhysicsImpactDamageTable()
+{
+	return s_HunterImpactDamageTable;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::PhysicsDamageEffect( const Vector &vecPos, const Vector &vecDir )
+{
+	CEffectData data;
+	data.m_vOrigin = vecPos;
+	data.m_vNormal = vecDir;
+	DispatchEffect( "HunterDamage", data );
+
+	if ( random->RandomInt( 0, 1 ) == 0 )
+	{
+		CBaseEntity *pTrail = CreateEntityByName( "sparktrail" );
+		pTrail->SetOwnerEntity( this );
+		pTrail->Spawn();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// We were hit by a strider buster. Do the tesla effect on our hitboxes.
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::TeslaThink()
+{
+	CEffectData data;
+	data.m_nEntIndex = entindex();
+	data.m_flMagnitude = 3;
+	data.m_flScale = 0.5f;
+	DispatchEffect( "TeslaHitboxes", data );
+	EmitSound( "RagdollBoogie.Zap" );
+
+	if ( gpGlobals->curtime < m_flTeslaStopTime )
+	{
+		SetContextThink( &CNPC_Hunter::TeslaThink, gpGlobals->curtime + random->RandomFloat( 0.1f, 0.3f ), HUNTER_ZAP_THINK ); 
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Our health is low. Show damage effects.
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::BleedThink()
+{
+	// Spurt blood from random points on the hunter's head.
+	Vector vecOrigin;
+	QAngle angDir;
+	GetAttachment( gm_nHeadCenterAttachment, vecOrigin, angDir );
+	
+	Vector vecDir = RandomVector( -1, 1 );
+	VectorNormalize( vecDir );
+	VectorAngles( vecDir, Vector( 0, 0, 1 ), angDir );
+
+	vecDir *= gm_flHeadRadius;
+	DispatchParticleEffect( "blood_spurt_synth_01", vecOrigin + vecDir, angDir );
+
+	SetNextThink( gpGlobals->curtime + random->RandomFloat( 0.6, 1.5 ), HUNTER_BLEED_THINK );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::IsHeavyDamage( const CTakeDamageInfo &info )
+{
+	if ( info.GetDamage() < 45 )
+	{
+		return false;
+	}
+
+	if ( info.GetDamage() < 180 )
+	{
+		if ( !m_HeavyDamageDelay.Expired() || !BaseClass::IsHeavyDamage( info ) )
+		{
+			return false;
+		}
+	}
+
+	m_HeavyDamageDelay.Set( 15, 25 );
+	return true;
+
+}
+
+
+//-----------------------------------------------------------------------------
+// We've taken some damage. Maybe we should flinch because of it.
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::ConsiderFlinching( const CTakeDamageInfo &info )
+{
+	if ( !m_FlinchTimer.Expired() )
+	{
+		// Someone is whaling on us. Push out the timer so we don't keep flinching.
+		m_FlinchTimer.Set( random->RandomFloat( 0.3 ) );
+		return;
+	}
+
+	if ( GetState() == NPC_STATE_SCRIPT )
+	{
+		return;
+	}
+
+	Activity eGesture = ACT_HUNTER_FLINCH_N;
+
+	Vector forward;
+	GetVectors( &forward, NULL, NULL );
+	
+	Vector vecForceDir = info.GetDamageForce();
+	VectorNormalize( vecForceDir );
+	
+	float flDot = DotProduct( forward, vecForceDir );
+	
+	if ( flDot > 0.707 )
+	{
+		// flinch forward
+		eGesture = ACT_HUNTER_FLINCH_N;
+	}
+	else if ( flDot < -0.707 )
+	{
+		// flinch back
+		eGesture = ACT_HUNTER_FLINCH_S;
+	}
+	else
+	{
+		// flinch left or right
+		Vector cross = CrossProduct( forward, vecForceDir );
+		
+		if ( cross.z > 0 )
+		{
+			eGesture = ACT_HUNTER_FLINCH_W;
+		}
+		else
+		{
+			eGesture = ACT_HUNTER_FLINCH_E;
+		}
+	}
+
+	if ( !IsPlayingGesture( eGesture ) )
+	{
+		RestartGesture( eGesture );
+		m_FlinchTimer.Set( random->RandomFloat( 0.3, 1.0 ) );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// This is done from a think function because when the hunter is killed,
+// the physics code puts the vehicle's pre-collision velocity back so the jostle
+// is basically discared.
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::JostleVehicleThink()
+{
+	CBaseEntity *pInflictor = m_hHitByVehicle;
+	if ( !pInflictor )
+		return;
+
+	Vector vecVelDir = pInflictor->GetSmoothedVelocity();
+	float flSpeed = VectorNormalize( vecVelDir );
+	Vector vecForce = CrossProduct( vecVelDir, Vector( 0, 0, 1 ) );
+	if ( DotProduct( vecForce, GetAbsOrigin() ) < DotProduct( vecForce, pInflictor->GetAbsOrigin() ) )
+	{
+		// We're to the left of the vehicle that's hitting us.
+		vecForce *= -1;
+	}
+
+	VectorNormalize( vecForce );
+	vecForce.z = 1.0;
+
+	float flForceScale = RemapValClamped( flSpeed, hunter_jostle_car_min_speed.GetFloat(), hunter_jostle_car_max_speed.GetFloat(), 50.0f, 150.0f );
+
+	vecForce *= ( flForceScale * pInflictor->VPhysicsGetObject()->GetMass() );
+
+	pInflictor->VPhysicsGetObject()->ApplyForceOffset( vecForce, WorldSpaceCenter() );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CNPC_Hunter::OnTakeDamage( const CTakeDamageInfo &info )
+{
+	CTakeDamageInfo myInfo = info;
+
+	if ( ( info.GetDamageType() & DMG_CRUSH ) && !( info.GetDamageType() & DMG_VEHICLE ) )
+	{
+		// Don't take damage from physics objects that weren't thrown by the player.
+		CBaseEntity *pInflictor = info.GetInflictor();
+
+		IPhysicsObject *pObj = pInflictor->VPhysicsGetObject();
+		//Assert( pObj );
+
+		if ( !pObj || !pInflictor->HasPhysicsAttacker( 4.0 ) )
+		{
+			myInfo.SetDamage( 0 );
+		}
+		else
+		{
+			// Physics objects that have flechettes stuck in them spoof
+			// a flechette hitting us so we dissolve when killed and award
+			// the achievement of killing a hunter with its flechettes.
+			CUtlVector<CBaseEntity *> children;
+			GetAllChildren( pInflictor, children );
+			for (int i = 0; i < children.Count(); i++ )
+			{
+				CBaseEntity *pent = children.Element( i );
+				if ( dynamic_cast<CHunterFlechette *>( pent ) )
+				{
+					myInfo.SetInflictor( pent );
+					myInfo.SetDamageType( myInfo.GetDamageType() | DMG_DISSOLVE );
+				}
+			}
+		}
+	}
+	
+	return BaseClass::OnTakeDamage( myInfo );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CNPC_Hunter::OnTakeDamage_Alive( const CTakeDamageInfo &info )
+{
+	CTakeDamageInfo myInfo = info;
+
+	// don't take damage from my own weapons!!!
+	// Exception: I "own" a magnade if it's glued to me.
+	CBaseEntity *pInflictor = info.GetInflictor();
+	CBaseEntity *pAttacker = info.GetAttacker();
+	if ( pInflictor )
+	{
+		if ( IsStriderBuster( pInflictor ) )
+		{
+			// Get a tesla effect on our hitboxes for a little while.
+			SetContextThink( &CNPC_Hunter::TeslaThink, gpGlobals->curtime, HUNTER_ZAP_THINK ); 
+			m_flTeslaStopTime = gpGlobals->curtime + 2.0f;
+			
+			myInfo.SetDamage( sk_hunter_dmg_from_striderbuster.GetFloat() ) ;
+
+			SetCondition( COND_HUNTER_STAGGERED );
+		}
+		else if ( pInflictor->ClassMatches( GetClassname() ) && !( info.GetDamageType() == DMG_GENERIC ) )
+		{
+			return 0;
+		}
+		else if ( pInflictor->ClassMatches( "hunter_flechette" ) ) 
+		{
+			if ( !( ( CHunterFlechette *)pInflictor )->WasThrownBack() )
+			{
+				// Flechettes only hurt us if they were thrown back at us by the player. This prevents
+				// hunters from hurting themselves when they walk into their own flechette clusters.
+				return 0;
+			}
+		}
+	}
+
+	if ( m_EscortBehavior.GetFollowTarget() && m_EscortBehavior.GetFollowTarget() == pAttacker )
+	{
+		return 0;
+	}
+
+	bool bHitByUnoccupiedCar = false;
+	if ( ( ( info.GetDamageType() & DMG_CRUSH ) && ( pAttacker && pAttacker->IsPlayer() ) ) ||
+		 ( info.GetDamageType() & DMG_VEHICLE ) )
+	{
+		// myInfo, not info! it may have been modified above.
+		float flDamage = myInfo.GetDamage();
+		if ( flDamage < HUNTER_MIN_PHYSICS_DAMAGE )
+		{
+			//DevMsg( "hunter: <<<< ZERO PHYSICS DAMAGE: %f\n", flDamage );
+			myInfo.SetDamage( 0 );
+		}
+		else
+		{
+			CBaseEntity *pInflictor = info.GetInflictor();
+			if ( ( info.GetDamageType() & DMG_VEHICLE ) || 
+				 ( pInflictor && pInflictor->GetServerVehicle() && 
+				   ( ( bHitByUnoccupiedCar = ( dynamic_cast<CPropVehicleDriveable *>(pInflictor) && static_cast<CPropVehicleDriveable *>(pInflictor)->GetDriver() == NULL ) )  == false ) ) )
+			{
+				// Adjust the damage from vehicles.
+				flDamage *= sk_hunter_vehicle_damage_scale.GetFloat();
+				myInfo.SetDamage( flDamage );
+
+				// Apply a force to jostle the vehicle that hit us.
+				// Pick a force direction based on which side we're on relative to the vehicle's motion.
+				Vector vecVelDir = pInflictor->GetSmoothedVelocity();
+				if ( vecVelDir.Length() >= hunter_jostle_car_min_speed.GetFloat() )
+				{
+					EmitSound( "NPC_Hunter.HitByVehicle" );
+					m_hHitByVehicle = pInflictor;
+					SetContextThink( &CNPC_Hunter::JostleVehicleThink, gpGlobals->curtime, HUNTER_JOSTLE_VEHICLE_THINK );
+				}
+			}
+
+			if ( !bHitByUnoccupiedCar )
+			{
+				SetCondition( COND_HUNTER_STAGGERED );
+			}
+		}
+		
+		//DevMsg( "hunter: >>>> PHYSICS DAMAGE: %f (was %f)\n", flDamage, info.GetDamage() );
+	}
+
+	// Show damage effects if we actually took damage.
+	if ( ( myInfo.GetDamageType() & ( DMG_CRUSH | DMG_BLAST ) ) && ( myInfo.GetDamage() > 0 ) )
+	{
+		if ( !bHitByUnoccupiedCar )
+			SetCondition( COND_HUNTER_STAGGERED );
+	}
+	
+	if ( HasCondition( COND_HUNTER_STAGGERED ) )
+	{
+		// Throw a bunch of gibs out
+		Vector vecForceDir = -myInfo.GetDamageForce();
+		VectorNormalize( vecForceDir );
+		PhysicsDamageEffect( myInfo.GetDamagePosition(), vecForceDir );
+
+		// Stagger away from the direction the damage came from.
+		m_vecStaggerDir = myInfo.GetDamageForce();
+		VectorNormalize( m_vecStaggerDir );
+	}
+
+	// Take less damage from citizens and Alyx, otherwise hunters go down too easily.
+	float flScale = 1.0;
+
+	if ( pAttacker &&
+		( ( pAttacker->Classify() == CLASS_CITIZEN_REBEL ) ||
+		  ( pAttacker->Classify() == CLASS_PLAYER_ALLY ) || 
+		  ( pAttacker->Classify() == CLASS_PLAYER_ALLY_VITAL ) ) )
+	{
+		flScale *= sk_hunter_citizen_damage_scale.GetFloat();
+	}
+	
+	if ( flScale != 0 )
+	{
+		// We're taking a nonzero amount of damage.
+
+		// If we're not staggering, consider flinching!
+		if ( !HasCondition( COND_HUNTER_STAGGERED ) )
+		{
+			ConsiderFlinching( info );
+		}
+		
+		if( pAttacker && pAttacker->IsPlayer() )
+		{
+			// This block of code will distract the Hunter back to the player if the 
+			// player does harm to the Hunter but is not the Hunter's current enemy.
+			// This is achieved by updating the Hunter's enemy memory of the player and 
+			// making the Hunter's current enemy invalid for a short time.
+			if( !GetEnemy() || !GetEnemy()->IsPlayer() )
+			{
+				UpdateEnemyMemory( pAttacker, pAttacker->GetAbsOrigin(), this );
+
+				if( GetEnemy() )
+				{
+					// Gotta forget about this person for a little bit.
+					GetEnemies()->SetTimeValidEnemy( GetEnemy(), gpGlobals->curtime + HUNTER_IGNORE_ENEMY_TIME );
+				}
+			}
+		}
+
+		float flDamage = myInfo.GetDamage() * flScale;
+		myInfo.SetDamage( flDamage );
+	}
+
+	int nRet = BaseClass::OnTakeDamage_Alive( myInfo );
+
+	m_EscortBehavior.OnDamage( myInfo );
+
+	// Spark at 30% health.
+	if ( !IsBleeding() && ( GetHealth() <= sk_hunter_health.GetInt() * 0.3 ) )
+	{
+		StartBleeding();
+	}
+	
+	if ( IsUsingSiegeTargets() && info.GetAttacker() != NULL && info.GetAttacker()->IsPlayer() )
+	{
+		// Defend myself. Try to siege attack immediately.
+		m_flTimeNextSiegeTargetAttack = gpGlobals->curtime;
+	}
+	
+	return nRet;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::Event_Killed( const CTakeDamageInfo &info )
+{
+	// Remember the killing blow to make decisions about ragdolling.
+	m_nKillingDamageType = info.GetDamageType();
+
+	if ( m_EscortBehavior.GetFollowTarget() )
+	{
+		if ( AIGetNumFollowers( m_EscortBehavior.GetFollowTarget(), m_iClassname ) == 1 )
+		{
+			m_EscortBehavior.GetEscortTarget()->AlertSound();
+			if ( info.GetAttacker() && info.GetAttacker()->IsPlayer() )
+			{
+				m_EscortBehavior.GetEscortTarget()->UpdateEnemyMemory( UTIL_GetLocalPlayer(), UTIL_GetLocalPlayer()->GetAbsOrigin(), this );
+			}
+		}
+	}
+	
+	if ( info.GetDamageType() & DMG_VEHICLE )
+	{
+		bool bWasRunDown = false;
+		int iRundownCounter = 0;
+		if ( GetSquad() )
+		{
+			if ( !m_IgnoreVehicleTimer.Expired() )
+			{
+				GetSquad()->GetSquadData( HUNTER_RUNDOWN_SQUADDATA, &iRundownCounter );
+				GetSquad()->SetSquadData( HUNTER_RUNDOWN_SQUADDATA, iRundownCounter + 1 );
+				bWasRunDown = true;
+			}
+		}
+
+		if ( hunter_dodge_debug.GetBool() )
+			Msg( "Hunter %d was%s run down\n", entindex(), ( bWasRunDown ) ? "" : " not" );
+
+		// Death by vehicle! Decrement the hunters to run over counter.
+		// When the counter reaches zero hunters will start dodging.
+		if ( GlobalEntity_GetCounter( s_iszHuntersToRunOver ) > 0 )
+		{
+			GlobalEntity_AddToCounter( s_iszHuntersToRunOver, -1 );
+		}
+	}
+
+	// Stop all our thinks
+	SetContextThink( NULL, 0, HUNTER_BLEED_THINK );
+
+	StopParticleEffects( this );
+
+	BaseClass::Event_Killed( info );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::StartBleeding()
+{
+	// Do this even if we're already bleeding (see OnRestore).
+	m_bIsBleeding = true;
+
+	// Start gushing blood from our... anus or something.
+	DispatchParticleEffect( "blood_drip_synth_01", PATTACH_POINT_FOLLOW, this, gm_nHeadBottomAttachment );
+
+	// Emit spurts of our blood
+	SetContextThink( &CNPC_Hunter::BleedThink, gpGlobals->curtime + 0.1, HUNTER_BLEED_THINK );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+float CNPC_Hunter::MaxYawSpeed()
+{
+	if ( IsStriderBuster( GetEnemy() ) )
+	{
+		return 60;
+	}
+
+	if ( GetActivity() == ACT_HUNTER_ANGRY )
+		return 0;
+
+	if ( GetActivity() == ACT_HUNTER_CHARGE_RUN )
+		return 5;
+
+	if ( GetActivity() == ACT_HUNTER_IDLE_PLANTED )
+		return 0;
+
+	if ( GetActivity() == ACT_HUNTER_RANGE_ATTACK2_UNPLANTED )
+		return 180;
+
+	switch ( GetActivity() )
+	{
+		case ACT_RANGE_ATTACK2:
+		{
+			return 0;
+		}
+		
+		case ACT_90_LEFT:
+		case ACT_90_RIGHT:
+		{
+			return 45;
+		}
+		
+		case ACT_TURN_LEFT:
+		case ACT_TURN_RIGHT:
+		{
+			return 45;
+		}
+		
+		case ACT_WALK:
+		{
+			return 25;
+		}
+		
+		default:
+		{
+			return 35;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::IsJumpLegal(const Vector &startPos, const Vector &apex, const Vector &endPos) const
+{
+	float MAX_JUMP_RISE		= 220.0f;
+	float MAX_JUMP_DISTANCE	= 512.0f;
+	float MAX_JUMP_DROP		= 384.0f;
+
+	trace_t tr;	
+	UTIL_TraceHull( startPos, startPos, GetHullMins(), GetHullMaxs(), MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );
+	if ( tr.startsolid )
+	{
+		// Trying to start a jump in solid! Consider checking for this in CAI_MoveProbe::JumpMoveLimit.
+		Assert( 0 );
+		return false;
+	}
+
+	if ( BaseClass::IsJumpLegal( startPos, apex, endPos, MAX_JUMP_RISE, MAX_JUMP_DROP, MAX_JUMP_DISTANCE ) )
+	{
+		return true;
+	}
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Let the probe know I can run through small debris
+// Stolen shamelessly from the Antlion Guard
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::ShouldProbeCollideAgainstEntity( CBaseEntity *pEntity )
+{
+	if ( s_iszPhysPropClassname != pEntity->m_iClassname )
+		return BaseClass::ShouldProbeCollideAgainstEntity( pEntity );
+
+	if ( pEntity->GetMoveType() == MOVETYPE_VPHYSICS )
+	{
+		IPhysicsObject *pPhysObj = pEntity->VPhysicsGetObject();
+
+		if( pPhysObj && pPhysObj->GetMass() <= 500.0f )
+		{
+			return false;
+		}
+	}
+
+	return BaseClass::ShouldProbeCollideAgainstEntity( pEntity );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::DoMuzzleFlash( int nAttachment )
+{
+	BaseClass::DoMuzzleFlash();
+	
+	DispatchParticleEffect( "hunter_muzzle_flash", PATTACH_POINT_FOLLOW, this, nAttachment );
+
+	// Dispatch the elight	
+	CEffectData data;
+	data.m_nAttachmentIndex = nAttachment;
+	data.m_nEntIndex = entindex();
+	DispatchEffect( "HunterMuzzleFlash", data );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CNPC_Hunter::CountRangedAttackers()
+{
+	CBaseEntity *pEnemy = GetEnemy();
+	if ( !pEnemy )
+	{
+		return 0;
+	}
+
+	int nAttackers = 0;
+	for ( int i = 0; i < g_Hunters.Count(); i++ )
+	{
+		CNPC_Hunter *pOtherHunter = g_Hunters[i];
+		if ( pOtherHunter->GetEnemy() == pEnemy )
+		{
+			if ( pOtherHunter->IsCurSchedule( SCHED_HUNTER_RANGE_ATTACK2 ) )
+			{
+				nAttackers++;
+			}
+		}
+	}
+	return nAttackers;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::DelayRangedAttackers( float minDelay, float maxDelay, bool bForced )
+{
+	float delayMultiplier = ( g_pGameRules->IsSkillLevel( SKILL_EASY ) ) ? 1.25 : 1.0;
+	if ( !m_bEnableSquadShootDelay && !bForced )
+	{
+		m_flNextRangeAttack2Time = gpGlobals->curtime + random->RandomFloat( minDelay, maxDelay ) * delayMultiplier;
+		return;
+	}
+
+	CBaseEntity *pEnemy = GetEnemy();
+	for ( int i = 0; i < g_Hunters.Count(); i++ )
+	{
+		CNPC_Hunter *pOtherHunter = g_Hunters[i];
+		if ( pOtherHunter->GetEnemy() == pEnemy )
+		{
+			float nextTime = gpGlobals->curtime + random->RandomFloat( minDelay, maxDelay ) * delayMultiplier;
+			if ( nextTime > pOtherHunter->m_flNextRangeAttack2Time )
+				pOtherHunter->m_flNextRangeAttack2Time = nextTime;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Given a target to shoot at, decide where to aim.
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::GetShootDir( Vector &vecDir, const Vector &vecSrc, CBaseEntity *pTargetEntity, bool bStriderBuster, int nShotNum, bool bSingleShot )
+{
+	//RestartGesture( ACT_HUNTER_GESTURE_SHOOT );
+
+	EmitSound( "NPC_Hunter.FlechetteShoot" );
+
+	Vector vecBodyTarget;
+
+	if( pTargetEntity->Classify() == CLASS_PLAYER_ALLY_VITAL )
+	{
+		// Shooting at Alyx, most likely (in EP2). The attack is designed to displace
+		// her, not necessarily actually harm her. So shoot at the area around her feet.
+		vecBodyTarget = pTargetEntity->GetAbsOrigin();
+	}
+	else
+	{
+		vecBodyTarget = pTargetEntity->BodyTarget( vecSrc );
+	}
+
+	Vector vecTarget = vecBodyTarget;
+
+	Vector vecDelta = pTargetEntity->GetAbsOrigin() - GetAbsOrigin();
+	float flDist = vecDelta.Length();
+
+	if ( !bStriderBuster )
+	{
+		// If we're not firing at a strider buster, miss in an entertaining way for the 
+		// first three shots of each volley.
+		if ( ( nShotNum < 3 ) && ( flDist > 200 ) )
+		{
+			Vector vecTargetForward;
+			Vector vecTargetRight;
+			pTargetEntity->GetVectors( &vecTargetForward, &vecTargetRight, NULL );
+
+			Vector vecForward;
+			GetVectors( &vecForward, NULL, NULL );
+
+			float flDot = DotProduct( vecTargetForward, vecForward );
+
+			if ( flDot < -0.8f )
+			{
+				// Our target is facing us, shoot the ground between us.
+				float flPerc = 0.7 + ( 0.1 * nShotNum );
+				vecTarget = GetAbsOrigin() + ( flPerc * ( pTargetEntity->GetAbsOrigin() - GetAbsOrigin() ) );
+			}
+			else if ( flDot > 0.8f )
+			{
+				// Our target is facing away from us, shoot to the left or right.
+				Vector vecMissDir = vecTargetRight;
+				if ( m_bMissLeft )
+				{
+					vecMissDir *= -1.0f;
+				}
+
+				vecTarget = pTargetEntity->EyePosition() +  ( 36.0f * ( 3 - nShotNum ) ) * vecMissDir;
+			}
+			else
+			{
+				// Our target is facing vaguely perpendicular to us, shoot across their view.
+				vecTarget = pTargetEntity->EyePosition() +  ( 36.0f * ( 3 - nShotNum ) ) * vecTargetForward;
+			}
+		}	
+		// If we can't see them, shoot where we last saw them.
+		else if ( !HasCondition( COND_SEE_ENEMY ) )
+		{
+			Vector vecDelta = vecTarget - pTargetEntity->GetAbsOrigin();
+			vecTarget = m_vecEnemyLastSeen + vecDelta;
+		}
+	}
+	else
+	{
+		// If we're firing at a striderbuster, lead it.
+		float flSpeed = hunter_flechette_speed.GetFloat();
+		if ( !flSpeed )
+		{
+			flSpeed = 2500.0f;
+		}
+
+		flSpeed *= 1.5;
+
+		float flDeltaTime = flDist / flSpeed;
+		vecTarget = vecTarget + flDeltaTime * pTargetEntity->GetSmoothedVelocity();
+	}
+
+	vecDir = vecTarget - vecSrc;
+	VectorNormalize( vecDir );
+}
+
+
+//-----------------------------------------------------------------------------
+// Ensures that we don't exceed our pitch/yaw limits when shooting flechettes.
+// Returns true if we had to clamp, false if not.
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::ClampShootDir( Vector &vecDir )
+{
+	Vector vecDir2D = vecDir;
+	vecDir2D.z = 0;
+	
+	Vector vecForward;
+	GetVectors( &vecForward, NULL, NULL );
+
+	Vector vecForward2D = vecForward;
+	vecForward2D.z = 0;
+	
+	float flDot = DotProduct( vecForward2D, vecDir2D );
+	if ( flDot >= HUNTER_SHOOT_MAX_YAW_COS )
+	{
+		// No need to clamp.
+		return false;		
+	}
+	
+	Vector vecAxis;
+	CrossProduct( vecDir, vecForward, vecAxis );
+	VectorNormalize( vecAxis );
+
+	Quaternion q;
+	AxisAngleQuaternion( vecAxis, -HUNTER_SHOOT_MAX_YAW_DEG, q );
+
+	matrix3x4_t rot;
+	QuaternionMatrix( q, rot );
+	VectorRotate( vecForward, rot, vecDir );
+	VectorNormalize( vecDir );
+	
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::ShouldSeekTarget( CBaseEntity *pTargetEntity, bool bStriderBuster )
+{
+	bool bSeek = false;
+
+	if ( bStriderBuster )
+	{
+		bool bSeek = false;
+
+		if ( pTargetEntity->VPhysicsGetObject() && ( pTargetEntity->VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_PLAYER_HELD ) )
+		{
+			bSeek = true;
+		}
+		else if ( StriderBuster_NumFlechettesAttached( pTargetEntity ) == 0 )
+		{
+			if ( StriderBuster_IsAttachedStriderBuster(pTargetEntity) )
+			{
+				bSeek = true;
+			}
+			else if ( hunter_seek_thrown_striderbusters_tolerance.GetFloat() > 0.0 )
+			{
+				CNPC_Strider *pEscortTarget = m_EscortBehavior.GetEscortTarget();
+				if ( pEscortTarget && ( pEscortTarget->GetAbsOrigin() - pTargetEntity->GetAbsOrigin() ).LengthSqr() < Square( hunter_seek_thrown_striderbusters_tolerance.GetFloat() ) )
+				{
+					bSeek = true;
+				}
+			}
+		}
+	}
+
+	return bSeek;
+}	
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::BeginVolley( int nNum, float flStartTime )
+{
+	m_nFlechettesQueued = nNum;
+	m_nClampedShots = 0;
+	m_flNextFlechetteTime = flStartTime;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::ShootFlechette( CBaseEntity *pTargetEntity, bool bSingleShot )
+{
+	if ( !pTargetEntity )
+	{
+		Assert( false );
+		return false;
+	}
+
+	int nShotNum = hunter_flechette_volley_size.GetInt() - m_nFlechettesQueued;
+
+	bool bStriderBuster = IsStriderBuster( pTargetEntity );
+
+	// Choose the next muzzle to shoot from.
+	Vector vecSrc;
+	QAngle angMuzzle;
+
+	if ( m_bTopMuzzle )
+	{
+		GetAttachment( gm_nTopGunAttachment, vecSrc, angMuzzle );
+		DoMuzzleFlash( gm_nTopGunAttachment );
+	}
+	else
+	{
+		GetAttachment( gm_nBottomGunAttachment, vecSrc, angMuzzle );
+		DoMuzzleFlash( gm_nBottomGunAttachment );
+	}
+
+	m_bTopMuzzle = !m_bTopMuzzle;
+
+	Vector vecDir;
+	GetShootDir( vecDir, vecSrc, pTargetEntity, bStriderBuster, nShotNum, bSingleShot );
+
+	bool bClamped = false;
+	if ( hunter_clamp_shots.GetBool() )
+	{
+		bClamped = ClampShootDir( vecDir );
+	}
+
+	CShotManipulator manipulator( vecDir );
+	Vector vecShoot;
+
+	if( IsUsingSiegeTargets() && nShotNum >= 2 && (nShotNum % 2) == 0 )
+	{
+		// Near perfect accuracy for these three shots, so they are likely to fly right into the windows.
+		// NOTE! In siege behavior in the map that this behavior was designed for (ep2_outland_10), the
+		// Hunters will only ever shoot at siege targets in siege mode. If you allow Hunters in siege mode
+		// to attack players or other NPCs, this accuracy bonus will apply unless we apply a bit more logic to it.
+		vecShoot = manipulator.ApplySpread( VECTOR_CONE_1DEGREES * 0.5, 1.0f );
+	}
+	else
+	{
+		vecShoot = manipulator.ApplySpread( VECTOR_CONE_4DEGREES, 1.0f );
+	}
+
+	QAngle angShoot;
+	VectorAngles( vecShoot, angShoot );
+
+	CHunterFlechette *pFlechette = CHunterFlechette::FlechetteCreate( vecSrc, angShoot, this );
+
+	pFlechette->AddEffects( EF_NOSHADOW );
+
+	vecShoot *= hunter_flechette_speed.GetFloat();
+
+	pFlechette->Shoot( vecShoot, bStriderBuster );
+
+	if ( ShouldSeekTarget( pTargetEntity, bStriderBuster ) )
+	{
+		pFlechette->SetSeekTarget( pTargetEntity );
+	}
+
+	if( nShotNum == 1 && pTargetEntity->Classify() == CLASS_PLAYER_ALLY_VITAL )
+	{
+		// Make this person afraid and react to ME, not to the flechettes. 
+		// Otherwise they could be scared into running towards the hunter.
+		CSoundEnt::InsertSound( SOUND_DANGER|SOUND_CONTEXT_REACT_TO_SOURCE|SOUND_CONTEXT_EXCLUDE_COMBINE, pTargetEntity->EyePosition(), 180.0f, 2.0f, this );
+	}
+
+	return bClamped;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+Vector CNPC_Hunter::LeftFootHit( float eventtime )
+{
+	Vector footPosition;
+
+	GetAttachment( "left foot", footPosition );
+	CPASAttenuationFilter filter( this );
+	EmitSound( filter, entindex(), "NPC_Hunter.Footstep", &footPosition, eventtime );
+
+	FootFX( footPosition );
+
+	return footPosition;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+Vector CNPC_Hunter::RightFootHit( float eventtime )
+{
+	Vector footPosition;
+
+	GetAttachment( "right foot", footPosition );
+	CPASAttenuationFilter filter( this );
+	EmitSound( filter, entindex(), "NPC_Hunter.Footstep", &footPosition, eventtime );
+	FootFX( footPosition );
+
+	return footPosition;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+Vector CNPC_Hunter::BackFootHit( float eventtime )
+{
+	Vector footPosition;
+
+	GetAttachment( "back foot", footPosition );
+	CPASAttenuationFilter filter( this );
+	EmitSound( filter, entindex(), "NPC_Hunter.BackFootstep", &footPosition, eventtime );
+	FootFX( footPosition );
+
+	return footPosition;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::FootFX( const Vector &origin )
+{
+	return;
+
+	// dvs TODO: foot dust? probably too expensive for these guys
+	/*trace_t tr;
+	AI_TraceLine( origin, origin - Vector(0,0,100), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
+	float yaw = random->RandomInt(0,120);
+	for ( int i = 0; i < 3; i++ )
+	{
+		Vector dir = UTIL_YawToVector( yaw + i*120 ) * 10;
+		VectorNormalize( dir );
+		dir.z = 0.25;
+		VectorNormalize( dir );
+		g_pEffects->Dust( tr.endpos, dir, 12, 50 );
+	}*/
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+CBaseEntity *CNPC_Hunter::GetEnemyVehicle()
+{
+	if ( GetEnemy() == NULL )
+		return NULL;
+
+	CBaseCombatCharacter *pCCEnemy = GetEnemy()->MyCombatCharacterPointer();
+	if ( pCCEnemy != NULL )
+		return pCCEnemy->GetVehicleEntity();
+
+	return NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::DrawDebugGeometryOverlays()
+{
+	if (m_debugOverlays & OVERLAY_BBOX_BIT) 
+	{	
+		float flViewRange	= acos(0.8);
+		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;
+
+		int nSeq = GetSequence();
+		if ( ( GetEntryNode( nSeq ) == gm_nPlantedNode ) && ( GetExitNode( nSeq ) == gm_nPlantedNode ) )
+		{
+			// planted - green
+			NDebugOverlay::Box( GetAbsOrigin(), GetHullMins(), GetHullMaxs(), 0, 255, 0, 128, 0 );
+		}
+		else if ( ( GetEntryNode( nSeq ) == gm_nUnplantedNode ) && ( GetExitNode( nSeq ) == gm_nUnplantedNode ) )
+		{
+			// unplanted - blue
+			NDebugOverlay::Box( GetAbsOrigin(), GetHullMins(), GetHullMaxs(), 0, 0, 255, 128, 0 );
+		}
+		else if ( ( GetEntryNode( nSeq ) == gm_nUnplantedNode ) && ( GetExitNode( nSeq ) == gm_nPlantedNode ) )
+		{
+			// planting transition - cyan
+			NDebugOverlay::Box( GetAbsOrigin(), GetHullMins(), GetHullMaxs(), 0, 255, 255, 128, 0 );
+		}
+		else if ( ( GetEntryNode( nSeq ) == gm_nPlantedNode ) && ( GetExitNode( nSeq ) == gm_nUnplantedNode ) ) 
+		{
+			// unplanting transition - purple
+			NDebugOverlay::Box( GetAbsOrigin(), GetHullMins(), GetHullMaxs(), 255, 0, 255, 128, 0 );
+		}
+		else
+		{
+			// unknown / other node - red
+			Msg( "UNKNOWN: %s\n", GetSequenceName( GetSequence() ) );
+			NDebugOverlay::Box( GetAbsOrigin(), GetHullMins(), GetHullMaxs(), 255, 0, 0, 128, 0 );
+		}
+
+		NDebugOverlay::BoxDirection(EyePosition(), Vector(0,0,-1), Vector(200,0,1), vLeftDir, 255, 0, 0, 50, 0 );
+		NDebugOverlay::BoxDirection(EyePosition(), Vector(0,0,-1), Vector(200,0,1), vRightDir, 255, 0, 0, 50, 0 );
+		NDebugOverlay::BoxDirection(EyePosition(), Vector(0,0,-1), Vector(200,0,1), vEyeDir, 0, 255, 0, 50, 0 );
+		NDebugOverlay::Box(EyePosition(), -Vector(2,2,2), Vector(2,2,2), 0, 255, 0, 128, 0 );
+	}	
+	
+	m_EscortBehavior.DrawDebugGeometryOverlays();
+	
+	BaseClass::DrawDebugGeometryOverlays();
+}
+
+
+//-----------------------------------------------------------------------------
+// Player has illuminated this NPC with the flashlight
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::PlayerHasIlluminatedNPC( CBasePlayer *pPlayer, float flDot )
+{
+	if ( m_bFlashlightInEyes )
+		return;
+
+	// Ignore the flashlight if it's not shining at my eyes
+	if ( PlayerFlashlightOnMyEyes( pPlayer ) )
+	{
+		//Msg( ">>>> SHINING FLASHLIGHT ON ME\n" );
+		m_bFlashlightInEyes = true;
+		SetExpression( "scenes/npc/hunter/hunter_eyeclose.vcd" );
+		m_flPupilDilateTime = gpGlobals->curtime + 0.2f;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::PlayerFlashlightOnMyEyes( CBasePlayer *pPlayer )
+{
+	Vector vecEyes, vecEyeForward, vecPlayerForward;
+ 	GetAttachment( gm_nTopGunAttachment, vecEyes, &vecEyeForward );
+ 	pPlayer->EyeVectors( &vecPlayerForward );
+
+	Vector vecToEyes = (vecEyes - pPlayer->EyePosition());
+	//float flDist = VectorNormalize( vecToEyes ); 
+
+	float flDot = DotProduct( vecPlayerForward, vecToEyes );
+	if ( flDot < 0.98 )
+		return false;
+
+	// Check facing to ensure we're in front of her
+ 	Vector los = ( pPlayer->EyePosition() - EyePosition() );
+	los.z = 0;
+	VectorNormalize( los );
+	Vector facingDir = EyeDirection2D();
+ 	flDot = DotProduct( los, facingDir );
+	return ( flDot > 0.3 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Return a random expression for the specified state to play over 
+// the state's expression loop.
+//-----------------------------------------------------------------------------
+const char *CNPC_Hunter::SelectRandomExpressionForState( NPC_STATE state )
+{
+	if ( m_bFlashlightInEyes )
+		return NULL;
+		
+	if ( !hunter_random_expressions.GetBool() )
+		return NULL;
+
+	char *szExpressions[4] =
+	{
+		"scenes/npc/hunter/hunter_scan.vcd",
+		"scenes/npc/hunter/hunter_eyeclose.vcd",
+		"scenes/npc/hunter/hunter_roar.vcd",
+		"scenes/npc/hunter/hunter_pain.vcd"
+	};
+	
+	int nIndex = random->RandomInt( 0, 3 );
+	//Msg( "RANDOM Expression: %s\n", szExpressions[nIndex] );
+	return szExpressions[nIndex];
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::PlayExpressionForState( NPC_STATE state )
+{
+	if ( m_bFlashlightInEyes )
+	{
+		return;
+	}
+
+	BaseClass::PlayExpressionForState( state );
+}
+
+
+//-----------------------------------------------------------------------------
+// TODO: remove if we're not doing striderbuster stuff
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::StriderBusterAttached( CBaseEntity *pAttached )
+{
+	// Add another to the list
+	m_hAttachedBusters.AddToTail( pAttached );
+
+	SetCondition( COND_HUNTER_HIT_BY_STICKYBOMB );
+	if (m_hAttachedBusters.Count() == 1)
+	{
+		EmitSound( "NPC_Hunter.Alert" );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::StriderBusterDetached( CBaseEntity *pAttached )
+{
+	int elem = m_hAttachedBusters.Find(pAttached);
+	if (elem >= 0)
+	{
+		m_hAttachedBusters.FastRemove(elem);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Set direction that the hunter aims his body and eyes (guns).
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::SetAim( const Vector &aimDir, float flInterval )
+{
+	QAngle angDir;
+	VectorAngles( aimDir, angDir );
+	float curPitch = GetPoseParameter( gm_nBodyPitchPoseParam );
+	float curYaw = GetPoseParameter( gm_nBodyYawPoseParam );
+
+	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 );
+		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 );
+
+	//Msg( "pitch=%f, yaw=%f\n", newPitch, newYaw );
+
+	SetPoseParameter( gm_nAimPitchPoseParam, 0 );
+	SetPoseParameter( gm_nAimYawPoseParam, 0 );
+
+	SetPoseParameter( gm_nBodyPitchPoseParam, clamp( newPitch, -45, 45 ) );
+	SetPoseParameter( gm_nBodyYawPoseParam, clamp( newYaw, -45, 45 ) );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::RelaxAim( float flInterval )
+{
+	float curPitch = GetPoseParameter( gm_nBodyPitchPoseParam );
+	float curYaw = GetPoseParameter( gm_nBodyYawPoseParam );
+
+	// dampen existing aim
+	float newPitch = AngleNormalize( UTIL_ApproachAngle( 0, curPitch, 3 ) );
+	float newYaw = AngleNormalize( UTIL_ApproachAngle( 0, curYaw, 2 ) );
+
+	SetPoseParameter( gm_nAimPitchPoseParam, 0 );
+	SetPoseParameter( gm_nAimYawPoseParam, 0 );
+
+	SetPoseParameter( gm_nBodyPitchPoseParam, clamp( newPitch, -45, 45 ) );
+	SetPoseParameter( gm_nBodyYawPoseParam, clamp( newYaw, -45, 45 ) );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Hunter::UpdateAim()
+{
+	if ( !GetModelPtr() || !GetModelPtr()->SequencesAvailable() )
+		return;
+		
+	float flInterval = GetAnimTimeInterval();
+
+	// Some activities look bad if we're giving our enemy the stinkeye.
+	int eActivity = GetActivity();
+
+	if ( GetEnemy() &&
+		 GetState() != NPC_STATE_SCRIPT && 
+		 ( eActivity != ACT_HUNTER_CHARGE_CRASH ) &&
+		 ( eActivity != ACT_HUNTER_CHARGE_HIT ) )
+	{
+		Vector vecShootOrigin;
+
+		vecShootOrigin = Weapon_ShootPosition();
+		Vector vecShootDir = GetShootEnemyDir( vecShootOrigin, false );
+
+		SetAim( vecShootDir, flInterval );
+	}
+	else
+	{
+		RelaxAim( flInterval );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Don't become a ragdoll until we've finished our death anim
+//-----------------------------------------------------------------------------
+bool CNPC_Hunter::CanBecomeRagdoll()
+{
+	return ( m_nKillingDamageType & DMG_CRUSH ) ||
+		IsCurSchedule( SCHED_DIE, false ) ||								// Finished playing death anim, time to ragdoll
+		IsCurSchedule( SCHED_HUNTER_CHARGE_ENEMY, false ) ||				// While moving, it looks better to ragdoll instantly
+		IsCurSchedule( SCHED_SCRIPTED_RUN, false ) ||
+		( GetActivity() == ACT_WALK ) || ( GetActivity() == ACT_RUN ) ||
+		GetCurSchedule() == NULL;											// Failsafe
+}
+
+
+//-----------------------------------------------------------------------------
+// Determines the best type of death anim to play based on how we died.
+//-----------------------------------------------------------------------------
+Activity CNPC_Hunter::GetDeathActivity()
+{
+	return ACT_DIESIMPLE;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CAI_HunterEscortBehavior::OnDamage( const CTakeDamageInfo &info )
+{
+	if ( info.GetDamage() > 0 && info.GetAttacker()->IsPlayer() &&
+		GetFollowTarget() && ( AIGetNumFollowers( GetFollowTarget() ) > 1 ) &&
+		( GetOuter()->GetSquad()->GetSquadSoundWaitTime() <= gpGlobals->curtime ) ) // && !FarFromFollowTarget()
+	{
+		// Start the clock ticking. We'll return the the strider when the timer elapses.
+		m_flTimeEscortReturn = gpGlobals->curtime + random->RandomFloat( 15.0f, 25.0f );
+		GetOuter()->GetSquad()->SetSquadSoundWaitTime( m_flTimeEscortReturn + 1.0 ); // prevent others from breaking escort
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CAI_HunterEscortBehavior::BuildScheduleTestBits()
+{
+	BaseClass::BuildScheduleTestBits();
+
+	if ( ( m_flTimeEscortReturn != 0 ) && ( gpGlobals->curtime > m_flTimeEscortReturn ) )
+	{
+		// We're delinquent! Return to strider!
+		GetOuter()->ClearCustomInterruptCondition( COND_NEW_ENEMY );
+		GetOuter()->ClearCustomInterruptCondition( COND_SEE_ENEMY );
+		GetOuter()->ClearCustomInterruptCondition( COND_SEE_HATE );
+		GetOuter()->ClearCustomInterruptCondition( COND_CAN_RANGE_ATTACK1 );
+		GetOuter()->ClearCustomInterruptCondition( COND_CAN_RANGE_ATTACK2 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CAI_HunterEscortBehavior::CheckBreakEscort()
+{
+	if ( m_flTimeEscortReturn != 0 && ( FarFromFollowTarget() || gpGlobals->curtime >= m_flTimeEscortReturn ) )
+	{
+		if ( FarFromFollowTarget() )
+		{
+			m_flTimeEscortReturn = gpGlobals->curtime;
+		}
+		else
+		{
+			m_flTimeEscortReturn = 0;
+		}
+		if ( GetOuter()->GetSquad() )
+		{
+			GetOuter()->GetSquad()->SetSquadSoundWaitTime( gpGlobals->curtime + random->RandomFloat( 5.0f, 12.0f ) );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CAI_HunterEscortBehavior::GatherConditionsNotActive( void )
+{
+	if ( m_bEnabled )
+	{
+		DistributeFreeHunters();
+	}
+
+	BaseClass::GatherConditionsNotActive();
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CAI_HunterEscortBehavior::GatherConditions( void )
+{
+	m_bEnabled = true;
+
+	DistributeFreeHunters();
+
+	BaseClass::GatherConditions();
+
+	if ( GetEnemy() && GetEnemy()->IsPlayer() && HasCondition( COND_SEE_ENEMY ) )
+	{
+		if ( GetOuter()->GetSquad()->GetSquadSoundWaitTime() <= gpGlobals->curtime && ((CBasePlayer *)GetEnemy())->IsInAVehicle() )
+		{
+			m_flTimeEscortReturn = gpGlobals->curtime + random->RandomFloat( 15.0f, 25.0f );
+			GetOuter()->GetSquad()->SetSquadSoundWaitTime( m_flTimeEscortReturn + 1.0 ); // prevent others from breaking escort
+		}
+	}
+}
+
+	
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CAI_HunterEscortBehavior::ShouldFollow()
+{
+	if ( IsStriderBuster( GetEnemy() ) )
+		return false;
+
+	if ( HasCondition( COND_HEAR_PHYSICS_DANGER ) )
+		return false;
+
+	if ( m_flTimeEscortReturn <= gpGlobals->curtime )
+	{
+		return CAI_FollowBehavior::ShouldFollow();
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CAI_HunterEscortBehavior::BeginScheduleSelection()
+{
+	BaseClass::BeginScheduleSelection();
+	Assert( m_SavedDistTooFar == GetOuter()->m_flDistTooFar );
+	GetOuter()->m_flDistTooFar *= 2;
+}	
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CAI_HunterEscortBehavior::SelectSchedule()
+{
+	if( m_FollowDelay.IsRunning() && !m_FollowDelay.Expired() )
+	{
+		return FollowCallBaseSelectSchedule();
+	}
+	return BaseClass::SelectSchedule();
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CAI_HunterEscortBehavior::FollowCallBaseSelectSchedule() 
+{
+	if ( GetOuter()->GetState() == NPC_STATE_COMBAT )
+	{
+		return GetOuter()->SelectCombatSchedule();
+	}
+
+	return BaseClass::FollowCallBaseSelectSchedule(); 
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CAI_HunterEscortBehavior::StartTask( const Task_t *pTask )
+{
+	switch( pTask->iTask )
+	{
+	case TASK_MOVE_TO_FOLLOW_POSITION:
+		{
+			if ( GetEnemy() )
+			{
+				if ( GetOuter()->OccupyStrategySlot( SQUAD_SLOT_RUN_SHOOT ) )
+				{
+					if ( GetOuter()->GetSquad()->GetSquadMemberNearestTo( GetEnemy()->GetAbsOrigin() ) == GetOuter() )
+					{
+						GetOuter()->BeginVolley( NUM_FLECHETTE_VOLLEY_ON_FOLLOW, gpGlobals->curtime + 1.0 + random->RandomFloat( 0, .25 ) + random->RandomFloat( 0, .25 ) );
+					}
+					else
+					{
+						GetOuter()->VacateStrategySlot();
+					}
+				}
+			}
+			BaseClass::StartTask( pTask );
+			break;
+		}
+
+	default:
+		BaseClass::StartTask( pTask );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CAI_HunterEscortBehavior::RunTask( const Task_t *pTask )
+{
+	switch( pTask->iTask )
+	{
+	case TASK_MOVE_TO_FOLLOW_POSITION:
+		{
+			if ( !GetFollowTarget() )
+			{
+				TaskFail( FAIL_NO_TARGET );
+			}
+			else
+			{
+				if ( GetEnemy() )
+				{
+					CNPC_Hunter *pHunter = GetOuter();
+					Vector vecEnemyLKP = pHunter->GetEnemyLKP();
+					pHunter->AddFacingTarget( pHunter->GetEnemy(), vecEnemyLKP, 1.0, 0.8 );
+					bool bVacate = false;
+
+					bool bHasSlot = pHunter->HasStrategySlot( SQUAD_SLOT_RUN_SHOOT );
+					if ( HasCondition( COND_SEE_ENEMY ) )
+					{
+						float maxDist = hunter_flechette_max_range.GetFloat() * 3;
+						float distSq = ( pHunter->GetAbsOrigin() - pHunter->GetEnemy()->GetAbsOrigin() ).Length2DSqr();
+
+						if ( distSq < Square( maxDist ) )
+						{
+							if ( gpGlobals->curtime >= pHunter->m_flNextFlechetteTime )
+							{
+								if ( !bHasSlot )
+								{
+									if ( GetOuter()->OccupyStrategySlot( SQUAD_SLOT_RUN_SHOOT ) )
+									{
+										if ( GetOuter()->GetSquad()->GetSquadMemberNearestTo( GetEnemy()->GetAbsOrigin() ) == GetOuter() )
+										{
+											bHasSlot = true;
+										}
+										else
+										{
+											GetOuter()->VacateStrategySlot();
+										}
+									}
+								}
+
+								if ( bHasSlot )
+								{
+									// Start the firing sound.
+									//CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+									//if ( controller.SoundGetVolume( pHunter->m_pGunFiringSound ) == 0.0f )
+									//{
+									//	controller.SoundChangeVolume( pHunter->m_pGunFiringSound, 1.0f, 0.0f );
+									//}
+									
+									pHunter->ShootFlechette( GetEnemy(), true );
+
+									if ( --pHunter->m_nFlechettesQueued > 0 )
+									{
+										pHunter->m_flNextFlechetteTime = gpGlobals->curtime + hunter_flechette_delay.GetFloat();
+									}
+									else
+									{
+										// Stop the firing sound.
+										//CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+										//controller.SoundChangeVolume( pHunter->m_pGunFiringSound, 0, 0.01f );
+
+										bVacate = true;
+										pHunter->BeginVolley( NUM_FLECHETTE_VOLLEY_ON_FOLLOW, gpGlobals->curtime + 1.0 + random->RandomFloat( 0, .25 ) + random->RandomFloat( 0, .25 ) );
+									}
+								}
+							}
+						}
+						else if ( bHasSlot )
+						{
+							bVacate = true;
+						}
+					}
+					else if ( bHasSlot )
+					{
+						bVacate = true;
+					}
+
+					if ( bVacate )
+					{
+						pHunter->VacateStrategySlot();
+					}
+				}
+
+				if ( m_FollowAttackTimer.Expired() && IsFollowTargetInRange( .8 )) 
+				{
+					m_FollowAttackTimer.Set( 8, 24 );
+					TaskComplete();
+				}
+				else
+				{
+					BaseClass::RunTask( pTask );
+				}
+			}
+			break;
+		}
+
+	default:
+		BaseClass::RunTask( pTask );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CAI_HunterEscortBehavior::FindFreeHunters( CUtlVector<CNPC_Hunter *> *pFreeHunters )
+{
+	pFreeHunters->EnsureCapacity( g_Hunters.Count() );
+	int i;
+
+	for ( i = 0; i < g_Hunters.Count(); i++ )
+	{
+		CNPC_Hunter *pHunter = g_Hunters[i];
+		if ( pHunter->IsAlive() && pHunter->m_EscortBehavior.m_bEnabled )
+		{
+			if ( pHunter->m_EscortBehavior.GetFollowTarget() == NULL || !pHunter->m_EscortBehavior.GetFollowTarget()->IsAlive() )
+			{
+				pFreeHunters->AddToTail( pHunter);
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CAI_HunterEscortBehavior::DistributeFreeHunters()
+{
+	if ( g_TimeLastDistributeFreeHunters != -1 && gpGlobals->curtime - g_TimeLastDistributeFreeHunters < FREE_HUNTER_DISTRIBUTE_INTERVAL )
+	{
+		return;
+	}
+
+	g_TimeLastDistributeFreeHunters = gpGlobals->curtime;
+
+	CUtlVector<CNPC_Hunter *> freeHunters;
+	int i;
+	FindFreeHunters( &freeHunters );
+
+	CAI_BaseNPC **ppNPCs = g_AI_Manager.AccessAIs();
+	for ( i = 0; i < g_AI_Manager.NumAIs() && freeHunters.Count(); i++ )
+	{
+		int nToAdd;
+		CNPC_Strider *pStrider = ( ppNPCs[i]->IsAlive() ) ? dynamic_cast<CNPC_Strider *>( ppNPCs[i] ) : NULL;
+		if ( pStrider && !pStrider->CarriedByDropship() )
+		{
+			if ( ( nToAdd = 3 - AIGetNumFollowers( pStrider ) ) > 0 )
+			{
+				for ( int j = freeHunters.Count() - 1; j >= 0 && nToAdd > 0; --j )
+				{
+					DevMsg( "npc_hunter %d assigned to npc_strider %d\n", freeHunters[j]->entindex(), pStrider->entindex() );
+					freeHunters[j]->FollowStrider( pStrider );
+					freeHunters.FastRemove( j );
+					nToAdd--;
+				}
+			}
+		}
+	}
+
+	for ( i = 0; i < freeHunters.Count(); i++ )
+	{
+		//DevMsg( "npc_hunter %d assigned to free_hunters_squad\n", freeHunters[i]->entindex() );
+		freeHunters[i]->m_EscortBehavior.SetFollowTarget( NULL );
+		freeHunters[i]->AddToSquad( AllocPooledString( "free_hunters_squad" ) );
+	}
+
+#if 0
+	CBaseEntity *pHunterMaker = gEntList.FindEntityByClassname( NULL, "npc_hunter_maker" ); // TODO: this picks the same one every time!
+	if ( pHunterMaker )
+	{
+		for ( i = 0; i < freeHunters.Count(); i++ )
+		{
+			freeHunters[i]->m_EscortBehavior.SetFollowTarget( pHunterMaker );
+		}
+	}
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CAI_HunterEscortBehavior::DrawDebugGeometryOverlays()
+{
+	if ( !GetFollowTarget() )
+		return;
+
+	Vector vecFollowPos = GetGoalPosition();
+	if ( FarFromFollowTarget() )
+	{
+		if ( gpGlobals->curtime >= m_flTimeEscortReturn )
+		{
+			NDebugOverlay::HorzArrow( GetOuter()->GetAbsOrigin(), vecFollowPos, 16.0f, 255, 0, 0, 0, true, 0 );
+		}
+		else
+		{
+			NDebugOverlay::HorzArrow( GetOuter()->GetAbsOrigin(), vecFollowPos, 16.0f, 255, 255, 0, 0, true, 0 );
+		}
+	}
+	else
+	{
+		NDebugOverlay::HorzArrow( GetOuter()->GetAbsOrigin(), vecFollowPos, 16.0f, 0, 255, 0, 0, true, 0 );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool Hunter_IsHunter(CBaseEntity *pEnt)
+{
+	return dynamic_cast<CNPC_Hunter *>(pEnt) != NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void Hunter_StriderBusterLaunched( CBaseEntity *pBuster )
+{
+	CAI_BaseNPC **ppAIs = g_AI_Manager.AccessAIs();
+	int nAIs = g_AI_Manager.NumAIs();
+
+	for ( int i = 0; i < nAIs; i++ )
+	{
+		CAI_BaseNPC *pNPC = ppAIs[ i ];
+		if ( pNPC && ( pNPC->Classify() == CLASS_COMBINE_HUNTER ) && pNPC->m_lifeState == LIFE_ALIVE )
+		{
+			if ( !pNPC->GetEnemy() || !IsStriderBuster( pNPC->GetEnemy() ) )
+			{
+				Vector vecDelta = pNPC->GetAbsOrigin() - pBuster->GetAbsOrigin();
+				if ( vecDelta.Length2DSqr() < 9437184.0f ) // 3072 * 3072
+				{
+					pNPC->SetEnemy( pBuster );
+					pNPC->SetState( NPC_STATE_COMBAT );
+					pNPC->UpdateEnemyMemory( pBuster, pBuster->GetAbsOrigin() );
+
+					// Stop whatever we're doing.
+					pNPC->SetCondition( COND_SCHEDULE_DONE );
+				}
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void Hunter_StriderBusterAttached( CBaseEntity *pHunter, CBaseEntity *pAttached )
+{
+	Assert(dynamic_cast<CNPC_Hunter *>(pHunter));
+
+	static_cast<CNPC_Hunter *>(pHunter)->StriderBusterAttached(pAttached);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void Hunter_StriderBusterDetached( CBaseEntity *pHunter, CBaseEntity *pAttached )
+{
+	Assert(dynamic_cast<CNPC_Hunter *>(pHunter));
+
+	static_cast<CNPC_Hunter *>(pHunter)->StriderBusterDetached(pAttached);
+}
+
+//-------------------------------------------------------------------------------------------------
+//
+// ep2_outland_12 custom npc makers
+//
+//-------------------------------------------------------------------------------------------------
+
+class CHunterMaker : public CTemplateNPCMaker
+{
+	typedef CTemplateNPCMaker BaseClass;
+public:
+	void MakeMultipleNPCS( int nNPCs )
+	{
+		const float MIN_HEALTH_PCT = 0.2;
+
+		CUtlVector<CNPC_Hunter *> candidates;
+		CUtlVectorFixed<CNPC_Hunter *, 3> freeHunters;
+		CAI_HunterEscortBehavior::FindFreeHunters( &candidates );
+
+		freeHunters.EnsureCapacity( 3 );
+		int i;
+
+		for ( i = 0; i < candidates.Count() && freeHunters.Count() < 3; i++ )
+		{
+			if ( candidates[i]->GetHealth() > candidates[i]->GetMaxHealth() * MIN_HEALTH_PCT )
+			{
+				freeHunters.AddToTail( candidates[i] );
+			}
+		}
+
+		int nRequested = nNPCs;
+		if ( nNPCs < 3 )
+		{
+			nNPCs = MIN( 3, nNPCs + freeHunters.Count() );
+		}
+
+		int nSummoned = 0;
+		for ( i = 0; i < freeHunters.Count() && nNPCs; i++ )
+		{
+			freeHunters[i]->m_EscortBehavior.SetFollowTarget( this ); // this will make them not "free"
+			freeHunters[i]->SetName( m_iszTemplateName ); // this will force the hunter to get the FollowStrider input
+			nNPCs--;
+			nSummoned++;
+		}
+
+		DevMsg( "Requested %d to spawn, Summoning %d free hunters, spawning %d new hunters\n", nRequested, nSummoned, nNPCs );
+		if ( nNPCs )
+		{
+			BaseClass::MakeMultipleNPCS( nNPCs );
+		}
+	}
+};
+
+LINK_ENTITY_TO_CLASS( npc_hunter_maker, CHunterMaker );
+
+
+//-------------------------------------------------------------------------------------------------
+//
+// Schedules
+//
+//-------------------------------------------------------------------------------------------------
+AI_BEGIN_CUSTOM_NPC( npc_hunter, CNPC_Hunter )
+
+	DECLARE_TASK( TASK_HUNTER_AIM )
+	DECLARE_TASK( TASK_HUNTER_FIND_DODGE_POSITION )
+	DECLARE_TASK( TASK_HUNTER_DODGE )
+	DECLARE_TASK( TASK_HUNTER_PRE_RANGE_ATTACK2 )
+	DECLARE_TASK( TASK_HUNTER_SHOOT_COMMIT )
+	DECLARE_TASK( TASK_HUNTER_ANNOUNCE_FLANK )
+	DECLARE_TASK( TASK_HUNTER_BEGIN_FLANK )
+	DECLARE_TASK( TASK_HUNTER_STAGGER )
+	DECLARE_TASK( TASK_HUNTER_CORNERED_TIMER )
+	DECLARE_TASK( TASK_HUNTER_FIND_SIDESTEP_POSITION )
+	DECLARE_TASK( TASK_HUNTER_CHARGE )
+	DECLARE_TASK( TASK_HUNTER_FINISH_RANGE_ATTACK )
+	DECLARE_TASK( TASK_HUNTER_WAIT_FOR_MOVEMENT_FACING_ENEMY )
+	DECLARE_TASK( TASK_HUNTER_CHARGE_DELAY )
+
+	DECLARE_ACTIVITY( ACT_HUNTER_DEPLOYRA2 )
+	DECLARE_ACTIVITY( ACT_HUNTER_DODGER )
+	DECLARE_ACTIVITY( ACT_HUNTER_DODGEL )
+	DECLARE_ACTIVITY( ACT_HUNTER_GESTURE_SHOOT )
+	DECLARE_ACTIVITY( ACT_HUNTER_FLINCH_STICKYBOMB )
+	DECLARE_ACTIVITY( ACT_HUNTER_STAGGER )
+	DECLARE_ACTIVITY( ACT_DI_HUNTER_MELEE )
+	DECLARE_ACTIVITY( ACT_DI_HUNTER_THROW )
+	DECLARE_ACTIVITY( ACT_HUNTER_MELEE_ATTACK1_VS_PLAYER )
+	DECLARE_ACTIVITY( ACT_HUNTER_ANGRY )
+	DECLARE_ACTIVITY( ACT_HUNTER_WALK_ANGRY )
+	DECLARE_ACTIVITY( ACT_HUNTER_FOUND_ENEMY )
+	DECLARE_ACTIVITY( ACT_HUNTER_FOUND_ENEMY_ACK )
+	DECLARE_ACTIVITY( ACT_HUNTER_CHARGE_START )
+	DECLARE_ACTIVITY( ACT_HUNTER_CHARGE_RUN )
+	DECLARE_ACTIVITY( ACT_HUNTER_CHARGE_STOP )
+	DECLARE_ACTIVITY( ACT_HUNTER_CHARGE_CRASH )
+	DECLARE_ACTIVITY( ACT_HUNTER_CHARGE_HIT )
+	DECLARE_ACTIVITY( ACT_HUNTER_RANGE_ATTACK2_UNPLANTED )
+	DECLARE_ACTIVITY( ACT_HUNTER_IDLE_PLANTED )
+	DECLARE_ACTIVITY( ACT_HUNTER_FLINCH_N )
+	DECLARE_ACTIVITY( ACT_HUNTER_FLINCH_S )
+	DECLARE_ACTIVITY( ACT_HUNTER_FLINCH_E )
+	DECLARE_ACTIVITY( ACT_HUNTER_FLINCH_W )
+
+	DECLARE_INTERACTION( g_interactionHunterFoundEnemy );
+
+	DECLARE_SQUADSLOT( SQUAD_SLOT_HUNTER_CHARGE )
+	DECLARE_SQUADSLOT( SQUAD_SLOT_HUNTER_FLANK_FIRST )
+	DECLARE_SQUADSLOT( SQUAD_SLOT_RUN_SHOOT )
+
+	DECLARE_CONDITION( COND_HUNTER_SHOULD_PATROL )
+	DECLARE_CONDITION( COND_HUNTER_FORCED_FLANK_ENEMY )
+	DECLARE_CONDITION( COND_HUNTER_CAN_CHARGE_ENEMY )
+	DECLARE_CONDITION( COND_HUNTER_STAGGERED )
+	DECLARE_CONDITION( COND_HUNTER_IS_INDOORS )
+	DECLARE_CONDITION( COND_HUNTER_HIT_BY_STICKYBOMB )
+	DECLARE_CONDITION( COND_HUNTER_SEE_STRIDERBUSTER )
+	DECLARE_CONDITION( COND_HUNTER_FORCED_DODGE )
+	DECLARE_CONDITION( COND_HUNTER_INCOMING_VEHICLE )
+	DECLARE_CONDITION( COND_HUNTER_NEW_HINTGROUP )
+	DECLARE_CONDITION( COND_HUNTER_CANT_PLANT )
+	DECLARE_CONDITION( COND_HUNTER_SQUADMATE_FOUND_ENEMY )
+	
+	DECLARE_ANIMEVENT( AE_HUNTER_FOOTSTEP_LEFT )
+	DECLARE_ANIMEVENT( AE_HUNTER_FOOTSTEP_RIGHT )
+	DECLARE_ANIMEVENT( AE_HUNTER_FOOTSTEP_BACK )
+	DECLARE_ANIMEVENT( AE_HUNTER_MELEE_ANNOUNCE )
+	DECLARE_ANIMEVENT( AE_HUNTER_MELEE_ATTACK_LEFT )
+	DECLARE_ANIMEVENT( AE_HUNTER_MELEE_ATTACK_RIGHT )
+	DECLARE_ANIMEVENT( AE_HUNTER_DIE )
+	DECLARE_ANIMEVENT( AE_HUNTER_SPRAY_BLOOD )
+	DECLARE_ANIMEVENT( AE_HUNTER_START_EXPRESSION )
+	DECLARE_ANIMEVENT( AE_HUNTER_END_EXPRESSION )
+
+	//=========================================================
+	// Attack (Deploy/shoot/finish)
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_RANGE_ATTACK1,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING					0"
+		"		TASK_HUNTER_SHOOT_COMMIT			0"
+		"		TASK_RANGE_ATTACK1					0"
+		"	"
+		"	Interrupts"
+		"		COND_NEW_ENEMY"
+		"		COND_ENEMY_DEAD"
+		"		COND_LOST_ENEMY"
+		"		COND_ENEMY_OCCLUDED"
+		"		COND_WEAPON_SIGHT_OCCLUDED"
+		"		COND_TOO_CLOSE_TO_ATTACK"
+		"		COND_TOO_FAR_TO_ATTACK"
+		"		COND_NOT_FACING_ATTACK"
+	)
+
+	//=========================================================
+	// Attack (Deploy/shoot/finish)
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_RANGE_ATTACK2,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING				0"
+		"		TASK_HUNTER_PRE_RANGE_ATTACK2	0"
+		"		TASK_HUNTER_SHOOT_COMMIT		0"
+		"		TASK_RANGE_ATTACK2				0"
+		"		TASK_HUNTER_FINISH_RANGE_ATTACK	0"
+		"		TASK_SET_ACTIVITY				ACTIVITY:ACT_IDLE"
+		"		TASK_WAIT        				0.4"
+		"		TASK_WAIT_RANDOM				0.2"
+		"	"
+		"	Interrupts"
+		"		COND_NEW_ENEMY"
+	)
+
+	//=========================================================
+	// Shoot at striderbuster. Distinct from generic range attack
+	// because of BuildScheduleTestBits.
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_RANGE_ATTACK2_VS_STRIDERBUSTER,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING				0"
+		"		TASK_HUNTER_SHOOT_COMMIT		0"
+		"		TASK_RANGE_ATTACK2				0"
+		"	"
+		"	Interrupts"
+	)
+
+	//=========================================================
+	// Shoot at striderbuster with a little latency beforehand
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_RANGE_ATTACK2_VS_STRIDERBUSTER_LATENT,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING				0"
+		"		TASK_HUNTER_SHOOT_COMMIT		0"
+		"		TASK_WAIT						0.2"
+		"		TASK_PLAY_SEQUENCE_FACE_ENEMY	ACTIVITY:ACT_RANGE_ATTACK2"
+		"		TASK_RANGE_ATTACK2				0"
+		"	"
+		"	Interrupts"
+	)
+
+	//=========================================================
+	// Dodge Incoming vehicle
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_DODGE,
+
+		"	Tasks"
+		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_HUNTER_FAIL_DODGE"
+		"		TASK_HUNTER_FIND_DODGE_POSITION			0"
+		"		TASK_HUNTER_DODGE						0"
+		""
+		"	Interrupts"
+	)
+
+	//=========================================================
+	// Dodge Incoming vehicle
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_FAIL_DODGE,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING		0"
+		"		TASK_SET_ACTIVITY		ACTIVITY:ACT_IDLE"
+		"		TASK_FACE_ENEMY			0"
+		""
+		"	Interrupts"
+	)
+
+	//==================================================
+	// > SCHED_HUNTER_CHARGE_ENEMY
+	// Rush at my enemy and head-butt them.
+	//==================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_CHARGE_ENEMY,
+
+		"	Tasks"
+		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_HUNTER_FAIL_CHARGE_ENEMY"
+		"		TASK_STOP_MOVING				0"
+		"		TASK_FACE_ENEMY					0"
+		"		TASK_HUNTER_CHARGE				0"
+		""
+		"	Interrupts"
+		"		COND_TASK_FAILED"
+		"		COND_ENEMY_DEAD"
+	)
+
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_FAIL_CHARGE_ENEMY,
+
+		"	Tasks"
+		"		TASK_HUNTER_CHARGE_DELAY		10"
+	)
+
+	//=========================================================
+	// Chase the enemy with intent to claw
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_CHASE_ENEMY_MELEE,
+
+		"	Tasks"
+		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_ESTABLISH_LINE_OF_FIRE"
+		"		TASK_STOP_MOVING				0"
+		"		TASK_GET_CHASE_PATH_TO_ENEMY	300"
+		"		TASK_RUN_PATH					0"
+		"		TASK_WAIT_FOR_MOVEMENT			0"
+		"		TASK_FACE_ENEMY					0"
+		""
+		"	Interrupts"
+		"		COND_NEW_ENEMY"
+		"		COND_ENEMY_DEAD"
+		"		COND_ENEMY_UNREACHABLE"
+		"		COND_CAN_MELEE_ATTACK1"
+		"		COND_CAN_MELEE_ATTACK2"
+		//"		COND_TOO_CLOSE_TO_ATTACK"
+		"		COND_LOST_ENEMY"
+	)
+
+	//=========================================================
+	// Chase my enemy, shoot or claw when possible to do so.
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_CHASE_ENEMY,
+
+		"	Tasks"
+		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_ESTABLISH_LINE_OF_FIRE"
+		"		TASK_STOP_MOVING				0"
+		"		TASK_GET_CHASE_PATH_TO_ENEMY	300"
+		"		TASK_RUN_PATH					0"
+		"		TASK_WAIT_FOR_MOVEMENT			0"
+		"		TASK_FACE_ENEMY					0"
+		""
+		"	Interrupts"
+		"		COND_NEW_ENEMY"
+		"		COND_ENEMY_DEAD"
+		"		COND_ENEMY_UNREACHABLE"
+		"		COND_CAN_RANGE_ATTACK1"
+		"		COND_CAN_RANGE_ATTACK2"
+		"		COND_CAN_MELEE_ATTACK1"
+		"		COND_CAN_MELEE_ATTACK2"
+		"		COND_TOO_CLOSE_TO_ATTACK"
+		"		COND_LOST_ENEMY"
+	)
+
+	//=========================================================
+	// Move to a flanking position, then shoot if possible.
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_FLANK_ENEMY,
+
+		"	Tasks"
+		"		TASK_SET_FAIL_SCHEDULE					SCHEDULE:SCHED_ESTABLISH_LINE_OF_FIRE"
+		"		TASK_STOP_MOVING						0"
+		"		TASK_HUNTER_BEGIN_FLANK					0"
+		"		TASK_GET_FLANK_ARC_PATH_TO_ENEMY_LOS	30"
+		"		TASK_HUNTER_ANNOUNCE_FLANK				0"
+		"		TASK_RUN_PATH							0"
+		"		TASK_WAIT_FOR_MOVEMENT					0"
+		"		TASK_FACE_ENEMY							0"
+		//"		TASK_HUNTER_END_FLANK					0"
+		""
+		"	Interrupts"
+		"		COND_NEW_ENEMY"
+		//"		COND_CAN_RANGE_ATTACK1"
+		//"		COND_CAN_RANGE_ATTACK2"
+		"		COND_CAN_MELEE_ATTACK1"
+		"		COND_CAN_MELEE_ATTACK2"
+		"		COND_ENEMY_DEAD"
+		"		COND_ENEMY_UNREACHABLE"
+		"		COND_TOO_CLOSE_TO_ATTACK"
+		"		COND_LOST_ENEMY"
+	)
+
+	//=========================================================
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_COMBAT_FACE,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING		0"
+		"		TASK_SET_ACTIVITY		ACTIVITY:ACT_IDLE"
+		"		TASK_WAIT_FACE_ENEMY	1"
+		""
+		"	Interrupts"
+		"		COND_CAN_RANGE_ATTACK1"
+		"		COND_CAN_RANGE_ATTACK2"
+		"		COND_CAN_MELEE_ATTACK1"
+		"		COND_CAN_MELEE_ATTACK2"
+		"		COND_NEW_ENEMY"
+		"		COND_ENEMY_DEAD"
+	)
+	
+	//=========================================================
+	// Like the base class, only don't stop in the middle of 
+	// swinging if the enemy is killed, hides, or new enemy.
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_MELEE_ATTACK1,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING		0"
+		"		TASK_FACE_ENEMY			0"
+		"		TASK_MELEE_ATTACK1		0"
+		//"		TASK_SET_SCHEDULE		SCHEDULE:SCHED_HUNTER_POST_MELEE_WAIT"
+		""
+		"	Interrupts"
+	)
+
+	//=========================================================
+	// In a fight with nothing to do. Make busy!
+	//=========================================================
+	DEFINE_SCHEDULE	
+	(
+		SCHED_HUNTER_CHANGE_POSITION,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING				0"
+		"		TASK_WANDER						720432" // 6 feet to 36 feet
+		"		TASK_RUN_PATH					0"
+		"		TASK_HUNTER_WAIT_FOR_MOVEMENT_FACING_ENEMY	0"
+		"		TASK_STOP_MOVING				0"
+		"		TASK_SET_SCHEDULE				SCHEDULE:SCHED_HUNTER_CHANGE_POSITION_FINISH"
+		""
+		"	Interrupts"
+		"		COND_ENEMY_DEAD"
+		"		COND_CAN_MELEE_ATTACK1"
+		"		COND_CAN_MELEE_ATTACK2"
+		"		COND_HEAR_DANGER"
+		"		COND_HEAR_MOVE_AWAY"
+		"		COND_NEW_ENEMY"
+	)
+
+	//=========================================================
+	// In a fight with nothing to do. Make busy!
+	//=========================================================
+	DEFINE_SCHEDULE	
+	(
+		SCHED_HUNTER_CHANGE_POSITION_FINISH,
+
+		"	Tasks"
+		"		TASK_FACE_ENEMY					0"
+		"		TASK_WAIT_FACE_ENEMY_RANDOM		5"
+		""
+		"	Interrupts"
+		"		COND_ENEMY_DEAD"
+		"		COND_CAN_RANGE_ATTACK1"
+		"		COND_CAN_RANGE_ATTACK2"
+		"		COND_CAN_MELEE_ATTACK1"
+		"		COND_CAN_MELEE_ATTACK2"
+		"		COND_HEAR_DANGER"
+		"		COND_HEAR_MOVE_AWAY"
+		"		COND_NEW_ENEMY"
+	)
+
+	//=========================================================
+	// In a fight with nothing to do. Make busy!
+	//=========================================================
+	DEFINE_SCHEDULE	
+	(
+		SCHED_HUNTER_SIDESTEP,
+
+		"	Tasks"
+		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_HUNTER_FAIL_IMMEDIATE" // used because sched_fail includes a one second pause. ick!
+		"		TASK_STOP_MOVING						0"
+		"		TASK_HUNTER_FIND_SIDESTEP_POSITION		0"
+		"		TASK_GET_PATH_TO_SAVEPOSITION			0"
+		"		TASK_RUN_PATH							0"
+		"		TASK_WAIT_FOR_MOVEMENT					0"
+		"		TASK_FACE_ENEMY							0"
+		""
+		"	Interrupts"
+	)
+
+	//=========================================================
+	//=========================================================
+	DEFINE_SCHEDULE	
+	(
+		SCHED_HUNTER_PATROL,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING				0"
+		"		TASK_WANDER						720432" // 6 feet to 36 feet
+		"		TASK_WALK_PATH					0"
+		"		TASK_WAIT_FOR_MOVEMENT			0"
+		"		TASK_STOP_MOVING				0"
+		"		TASK_FACE_REASONABLE			0"
+		"		TASK_WAIT_RANDOM				3"
+		""
+		"	Interrupts"
+		"		COND_ENEMY_DEAD"
+		"		COND_LIGHT_DAMAGE"
+		"		COND_HEAVY_DAMAGE"
+		"		COND_HEAR_DANGER"
+		"		COND_HEAR_COMBAT"
+		"		COND_HEAR_PLAYER"
+		"		COND_HEAR_BULLET_IMPACT"
+		"		COND_HEAR_MOVE_AWAY"
+		"		COND_NEW_ENEMY"
+		"		COND_SEE_ENEMY"
+		"		COND_CAN_RANGE_ATTACK1"
+		"		COND_CAN_RANGE_ATTACK2"
+		"		COND_CAN_MELEE_ATTACK1"
+		"		COND_CAN_MELEE_ATTACK2"
+	)
+
+	//=========================================================
+	// Stagger because I got hit by something heavy
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_STAGGER,
+
+		"	Tasks"
+		"		TASK_HUNTER_STAGGER			0"
+		""
+		"	Interrupts"
+	)
+
+	//=========================================================
+	// Run around randomly until we detect an enemy
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_PATROL_RUN,
+
+		"	Tasks"
+		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_COMBAT_FACE"
+		"		TASK_SET_ROUTE_SEARCH_TIME		5"	// Spend 5 seconds trying to build a path if stuck
+		"		TASK_GET_PATH_TO_RANDOM_NODE	200"
+		"		TASK_RUN_PATH					0"
+		"		TASK_WAIT_FOR_MOVEMENT			0"
+		""
+		"	Interrupts"
+		"		COND_CAN_RANGE_ATTACK1 "
+		"		COND_CAN_RANGE_ATTACK2 "
+		"		COND_CAN_MELEE_ATTACK1 "
+		"		COND_CAN_MELEE_ATTACK2"
+		"		COND_GIVE_WAY"
+		"		COND_NEW_ENEMY"
+		"		COND_HEAR_COMBAT"
+		"		COND_HEAR_DANGER"
+		"		COND_HEAR_PLAYER"
+		"		COND_LIGHT_DAMAGE"
+		"		COND_HEAVY_DAMAGE"
+	)
+
+	//=========================================================
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_TAKE_COVER_FROM_ENEMY,
+
+		"	Tasks"
+		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_HUNTER_CHASE_ENEMY_MELEE"
+		"		TASK_HUNTER_CORNERED_TIMER		10.0"
+		"		TASK_WAIT						0.0"
+	//	"		TASK_SET_TOLERANCE_DISTANCE		24"
+	//	"		TASK_FIND_COVER_FROM_ENEMY		0"
+		"		TASK_FIND_FAR_NODE_COVER_FROM_ENEMY 200.0"
+		"		TASK_RUN_PATH					0"
+		"		TASK_HUNTER_CORNERED_TIMER		0.0"
+	//	"		TASK_CLEAR_FAIL_SCHEDULE		0" // not used because sched_fail includes a one second pause. ick!
+		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_HUNTER_FAIL_IMMEDIATE"
+		"		TASK_WAIT_FOR_MOVEMENT			0"
+		"		TASK_REMEMBER					MEMORY:INCOVER"
+		"		TASK_SET_SCHEDULE				SCHEDULE:SCHED_HUNTER_HIDE_UNDER_COVER"
+		/*
+		"		TASK_FACE_ENEMY					0"
+		"		TASK_SET_ACTIVITY				ACTIVITY:ACT_IDLE"	// Translated to cover
+		"		TASK_WAIT						1"
+		*/
+		""
+		"	Interrupts"
+		"		COND_NEW_ENEMY"
+		"		COND_HEAR_DANGER"
+	)
+
+	//=========================================================
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_HIDE_UNDER_COVER,
+
+		"	Tasks"
+		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_HUNTER_FAIL_IMMEDIATE" // used because sched_fail includes a one second pause. ick!
+		"		TASK_FACE_ENEMY					0"
+		"		TASK_SET_ACTIVITY				ACTIVITY:ACT_IDLE"	// Translated to cover
+		"		TASK_WAIT						1"
+		""
+		"	Interrupts"
+		"		COND_NEW_ENEMY"
+		"		COND_HEAR_DANGER"
+		"		COND_HAVE_ENEMY_LOS"
+	)
+	
+	//=========================================================
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_FOUND_ENEMY,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING				0"
+		"		TASK_FACE_ENEMY					0"
+		"		TASK_PLAY_SEQUENCE_FACE_ENEMY	ACTIVITY:ACT_HUNTER_FOUND_ENEMY"
+		""
+		"	Interrupts"
+		"		COND_LIGHT_DAMAGE"
+		"		COND_HEAVY_DAMAGE"
+	)
+	
+	//=========================================================
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_FOUND_ENEMY_ACK,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING				0"
+		"		TASK_WAIT_RANDOM				0.75"
+		"		TASK_FACE_ENEMY					0"
+		"		TASK_PLAY_SEQUENCE_FACE_ENEMY	ACTIVITY:ACT_HUNTER_FOUND_ENEMY_ACK"
+		""
+		"	Interrupts"
+		"		COND_LIGHT_DAMAGE"
+		"		COND_HEAVY_DAMAGE"
+	)
+	
+	//=========================================================
+	// An empty schedule that immediately bails out, faster than
+	// SCHED_FAIL which stops moving and waits for one second.
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_FAIL_IMMEDIATE,
+
+		"	Tasks"
+		"		TASK_WAIT			0"
+
+	)
+
+	DEFINE_SCHEDULE
+	( 
+		SCHED_HUNTER_GOTO_HINT,
+		"	Tasks"
+		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_HUNTER_CLEAR_HINTNODE" // used because sched_fail includes a one second pause. ick!
+		"		TASK_GET_PATH_TO_HINTNODE		1"
+		"		TASK_WAIT_FOR_MOVEMENT			0"
+		"		TASK_CLEAR_HINTNODE				0"
+		""
+		""
+		"	Interrupts"
+	)
+
+	DEFINE_SCHEDULE
+	( 
+		SCHED_HUNTER_CLEAR_HINTNODE,
+		"	Tasks"
+		"		TASK_CLEAR_HINTNODE				0"
+		""
+		""
+		"	Interrupts"
+	)
+
+	DEFINE_SCHEDULE
+	(
+		SCHED_HUNTER_SIEGE_STAND,
+		"	Tasks"
+		"		TASK_STOP_MOVING				0"
+		"		TASK_SET_ACTIVITY				ACTIVITY:ACT_IDLE"
+		"		TASK_FACE_PLAYER				0"
+		"		TASK_WAIT						10"
+		"		TASK_WAIT_RANDOM				2"
+		"		TASK_SET_SCHEDULE				SCHEDULE:SCHED_HUNTER_CHANGE_POSITION_SIEGE"
+		""
+		""
+		"	Interrupts"
+		"		COND_SEE_PLAYER"
+		"		COND_NEW_ENEMY"
+	)
+
+	DEFINE_SCHEDULE	
+	(
+		SCHED_HUNTER_CHANGE_POSITION_SIEGE,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING				0"
+		"		TASK_WANDER						2400480"
+		"		TASK_RUN_PATH					0"
+		"		TASK_WAIT_FOR_MOVEMENT			0"
+		"		TASK_STOP_MOVING				0"
+		"		TASK_SET_ACTIVITY				ACTIVITY:ACT_IDLE"
+		"		TASK_FACE_PLAYER				0"
+		""
+		"	Interrupts"
+		"		COND_NEW_ENEMY"
+	)
+
+	// formula is MIN_DIST * 10000 + MAX_DIST
+
+AI_END_CUSTOM_NPC()