Merge remote-tracking branch 'upstream/master'

1 files changed, 5745 insertions, 5745 deletions

diff --git a/mp/src/game/server/hl2/npc_strider.cpp b/mp/src/game/server/hl2/npc_strider.cpp
index 015fe0e6..b0cb2edf 100644
--- a/mp/src/game/server/hl2/npc_strider.cpp
+++ b/mp/src/game/server/hl2/npc_strider.cpp
@@ -1,5745 +1,5745 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//

-//

-// Purpose: Giant walking strider thing!

-//

-// $NoKeywords: $

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

-

-#include "cbase.h"

-

-#include "npc_strider.h"

-

-#include "ai_senses.h"

-#include "ai_task.h"

-#include "ai_default.h"

-#include "ai_schedule.h"

-#include "ai_hull.h"

-#include "ai_basenpc.h"

-#include "ai_pathfinder.h"

-#include "ai_waypoint.h"

-#include "ai_link.h"

-#include "ai_hint.h"

-#include "ai_tacticalservices.h"

-#include "ai_behavior_follow.h"

-#include "simtimer.h"

-#include "trains.h"

-#include "npcevent.h"

-#include "te_particlesystem.h"

-#include "shake.h"

-#include "soundent.h"

-#include "IEffects.h"

-#include "engine/IEngineSound.h"

-#include "bone_setup.h"

-#include "vcollide_parse.h"

-#include "studio.h"

-#include "physics_bone_follower.h"

-#include "ai_navigator.h"

-#include "ai_route.h"

-#include "ammodef.h"

-#include "npc_bullseye.h"

-#include "rope.h"

-#include "ai_memory.h"

-#include "player_pickup.h"

-#include "collisionutils.h"

-#include "in_buttons.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 "filters.h"

-#include "saverestore_utlvector.h"

-#include "eventqueue.h"

-

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

-#include "tier0/memdbgon.h"

-

-int g_interactionPlayerLaunchedRPG = 0;

-

-// Changing this classname avoids bugs where ai_relationship entities that change the

-// strider's relationship with bullseyes would affect its relationship with the focus

-LINK_ENTITY_TO_CLASS( bullseye_strider_focus, CNPC_Bullseye );

-

-

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

-

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

-ConVar sk_strider_health( "sk_strider_health", "350" );

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

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

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

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

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

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

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

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

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

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

-ConVar strider_pct_height_no_crouch_move( "strider_pct_height_no_crouch_move", "90" );

-

-ConVar strider_peek_time( "strider_peek_time", "0.75" );

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

-ConVar strider_peek_eye_dist( "strider_peek_eye_dist", "1.75" );

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

-ConVar strider_free_pass_start_time( "strider_free_pass_start_time", "3" );

-ConVar strider_free_pass_cover_dist( "strider_free_pass_cover_dist", "120" );

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

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

-ConVar strider_free_pass_move_tolerance( "strider_free_pass_move_tolerance", "320" );

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

-

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

-ConVar strider_free_pass_tolerance_after_escorts_dead( "strider_free_pass_tolerance_after_escorts_dead", "600" );

-

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

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

-

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

-

-// Number of RPG hits it takes to kill a strider on each skill level.

-ConVar sk_strider_num_missiles1("sk_strider_num_missiles1", "5");

-ConVar sk_strider_num_missiles2("sk_strider_num_missiles2", "7");

-ConVar sk_strider_num_missiles3("sk_strider_num_missiles3", "7");

-

-ConVar strider_missile_suppress_dist( "strider_missile_suppress_dist", "240" );

-ConVar strider_missile_suppress_time( "strider_missile_suppress_time", "3" );

-

-

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

-

-float GetCurrentGravity( void );

-

-extern void CreateConcussiveBlast( const Vector &origin, const Vector &surfaceNormal, CBaseEntity *pOwner, float magnitude );

-

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

-

-enum bodygroups

-{

-	STRIDER_BODYGROUP_VENT = 1,

-};

-

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

-

-#define STRIDER_DEFAULT_SHOOT_DURATION			2.5 // spend this much time stitching to each target.

-#define STRIDER_SHOOT_ON_TARGET_TIME			0.5 // How much of DEFAULT_SHOOT_DURATION is spent on-target (vs. stitching up to a target)

-#define STRIDER_SHOOT_VARIATION					1.0 // up to 1 second of variance

-#define STRIDER_SHOOT_DOWNTIME					1.0 // This much downtime between bursts

-#define STRIDER_SUBSEQUENT_TARGET_DURATION		1.5 // Spend this much time stitching to targets chosen by distributed fire.

-#define STRIDER_IGNORE_TARGET_DURATION			1.0

-#define STRIDER_IGNORE_PLAYER_DURATION			1.5

-#define STRIDER_DEFAULT_RATE_OF_FIRE			5	// Rounds per second

-

-#define STRIDER_EP1_RATE_OF_FIRE			10.0f

-#define STRIDER_EP1_SHOOT_ON_TARGET_TIME	 0.3f

-#define STRIDER_EP1_SHOOT_DURATION			 1.1f

-#define STRIDER_EP1_SHOOT_DOWNTIME			 1.0f

-#define STRIDER_EP1_SHOOT_VARIATION			 0.3f

-

-//Animation events

-#define STRIDER_AE_FOOTSTEP_LEFT		1

-#define STRIDER_AE_FOOTSTEP_RIGHT		2

-#define STRIDER_AE_FOOTSTEP_BACK		3

-#define STRIDER_AE_FOOTSTEP_LEFTM		4

-#define STRIDER_AE_FOOTSTEP_RIGHTM		5

-#define STRIDER_AE_FOOTSTEP_BACKM		6

-#define STRIDER_AE_FOOTSTEP_LEFTL		7

-#define STRIDER_AE_FOOTSTEP_RIGHTL		8

-#define STRIDER_AE_FOOTSTEP_BACKL		9

-#define STRIDER_AE_WHOOSH_LEFT			11

-#define STRIDER_AE_WHOOSH_RIGHT			12

-#define STRIDER_AE_WHOOSH_BACK			13

-#define STRIDER_AE_CREAK_LEFT			21

-#define STRIDER_AE_CREAK_RIGHT			22

-#define STRIDER_AE_CREAK_BACK			23

-#define STRIDER_AE_SHOOTCANNON			100

-#define STRIDER_AE_CANNONHIT			101

-#define STRIDER_AE_SHOOTMINIGUN			105

-#define STRIDER_AE_STOMPHITL			110

-#define STRIDER_AE_STOMPHITR			111

-#define STRIDER_AE_FLICKL				112

-#define STRIDER_AE_FLICKR				113

-#define STRIDER_AE_WINDUPCANNON			114

-

-#define STRIDER_AE_DIE					999

-

-// UNDONE: Share properly with the client code!!!

-#define STRIDER_MSG_BIG_SHOT			1

-#define STRIDER_MSG_STREAKS				2

-#define STRIDER_MSG_DEAD				3

-#define STOMP_IK_SLOT					11

-

-// can hit anything within this range

-#define STRIDER_STOMP_RANGE				260

-

-// Crouch down if trying to shoot an enemy that's this close

-#define STRIDER_CROUCH_RANGE			4000.0f

-

-// Stand up again if crouched and engaging an enemy at this distance

-#define STRIDER_STAND_RANGE				6000.0f

-

-#define STRIDER_NO_TRACK_NAME			"null"

-

-// Time after which if you haven't seen your enemy you stop facing him

-#define STRIDER_TIME_STOP_FACING_ENEMY 3.0 

-

-// Spawnflags

-enum

-{

-	SF_CAN_STOMP_PLAYER					= 0x10000,

-	SF_TAKE_MINIMAL_DAMAGE_FROM_NPCS	= 0x20000

-};

-

-const float STRIDER_SPEED = 500;

-const float STRIDER_SPEED_CHANGE = .0067; // per think

-

-

-static void MoveToGround( Vector *position, CBaseEntity *ignore, const Vector &mins, const Vector &maxs );

-

-int s_iImpactEffectTexture = -1;

-

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

-// Custom Activities

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

-

-int	ACT_STRIDER_LOOKL;

-int	ACT_STRIDER_LOOKR;

-int ACT_STRIDER_DEPLOYRA1;

-int ACT_STRIDER_AIMRA1;

-int ACT_STRIDER_FINISHRA1;

-int ACT_STRIDER_DODGER;

-int ACT_STRIDER_DODGEL;

-int ACT_STRIDER_STOMPL;

-int ACT_STRIDER_STOMPR;

-int ACT_STRIDER_FLICKL;

-int ACT_STRIDER_FLICKR;

-int ACT_STRIDER_CARRIED;

-int ACT_STRIDER_DEPLOY;

-int	ACT_STRIDER_GESTURE_DEATH;

-

-// UNDONE: Split sleep into 3 activities (start, loop, end)

-int ACT_STRIDER_SLEEP;

-

-// These bones have physics shadows

-// It allows a one-way interaction between the strider and

-// the physics world

-static const char *pFollowerBoneNames[] =

-{

-	// Head

-	"Combine_Strider.Body_Bone",

-#ifdef HL2_EPISODIC

-	"Combine_Strider.Neck_Bone",

-	"Combine_Strider.Gun_Bone1",

-	"Combine_Strider.Gun_Bone2",

-#endif //HL2_EPISODIC

-

-	// lower legs

-	"Combine_Strider.Leg_Left_Bone1",

-	"Combine_Strider.Leg_Right_Bone1",

-	"Combine_Strider.Leg_Hind_Bone1",

-	

-	// upper legs

-	"Combine_Strider.Leg_Left_Bone",

-	"Combine_Strider.Leg_Right_Bone",

-	"Combine_Strider.Leg_Hind_Bone",

-};

-

-// NOTE: These indices must directly correlate with the above list!

-enum

-{

-	STRIDER_BODY_FOLLOWER_INDEX = 0,

-#ifdef HL2_EPISODIC

-	STRIDER_NECK_FOLLOWER_INDEX,

-	STRIDER_GUN1_FOLLOWER_INDEX,

-	STRIDER_GUN2_FOLLOWER_INDEX,

-#endif //HL2_EPISODIC

-	

-	STRIDER_LEFT_LEG_FOLLOWER_INDEX,

-	STRIDER_RIGHT_LEG_FOLLOWER_INDEX,

-	STRIDER_BACK_LEG_FOLLOWER_INDEX,

-

-	STRIDER_LEFT_UPPERLEG_FOLLOWER_INDEX,

-	STRIDER_RIGHT_UPPERLEG_FOLLOWER_INDEX,

-	STRIDER_BACK_UPPERLEG_FOLLOWER_INDEX,

-};

-

-#define MINIGUN_MAX_YAW		90.0f

-#define MINIGUN_MIN_YAW		-90.0f

-#define MINIGUN_MAX_PITCH	45.0f

-#define MINIGUN_MIN_PITCH	-45.0f

-

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

-//

-// CNPC_Strider

-//

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

-

-IMPLEMENT_SERVERCLASS_ST(CNPC_Strider, DT_NPC_Strider)

-	SendPropVector(SENDINFO(m_vecHitPos), -1, SPROP_COORD),

-	SendPropVector( SENDINFO_NETWORKARRAYELEM( m_vecIKTarget, 0 ), -1, SPROP_COORD ),

-	SendPropVector( SENDINFO_NETWORKARRAYELEM( m_vecIKTarget, 1 ), -1, SPROP_COORD ),

-	SendPropVector( SENDINFO_NETWORKARRAYELEM( m_vecIKTarget, 2 ), -1, SPROP_COORD ),

-	SendPropVector( SENDINFO_NETWORKARRAYELEM( m_vecIKTarget, 3 ), -1, SPROP_COORD ),

-	SendPropVector( SENDINFO_NETWORKARRAYELEM( m_vecIKTarget, 4 ), -1, SPROP_COORD ),

-	SendPropVector( SENDINFO_NETWORKARRAYELEM( m_vecIKTarget, 5 ), -1, SPROP_COORD ),

-END_SEND_TABLE()

-

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

-

-LINK_ENTITY_TO_CLASS( npc_strider, CNPC_Strider );

-

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

-

-BEGIN_DATADESC( CNPC_Strider )

-

-#ifdef HL2_EPISODIC

-	DEFINE_UTLVECTOR( m_hAttachedBusters,	FIELD_EHANDLE ),

-#endif // HL2_EPISODIC

-

-	DEFINE_EMBEDDED( m_EnemyUpdatedTimer ),

-	DEFINE_EMBEDDEDBYREF( m_pMinigun ),

-	DEFINE_FIELD( m_miniGunAmmo,			FIELD_INTEGER ),

-	DEFINE_FIELD( m_miniGunDirectAmmo,		FIELD_INTEGER ),

-	DEFINE_FIELD( m_nextStompTime,		FIELD_TIME ),

-	DEFINE_FIELD( m_nextShootTime,		FIELD_TIME ),

-	DEFINE_FIELD( m_ragdollTime,			FIELD_TIME ),

-	DEFINE_FIELD( m_miniGunShootDuration, FIELD_FLOAT ),

-	DEFINE_FIELD( m_aimYaw,				FIELD_FLOAT ),

-	DEFINE_FIELD( m_aimPitch,				FIELD_FLOAT ),

-	DEFINE_FIELD( m_blastHit,				FIELD_VECTOR ),

-	DEFINE_FIELD( m_blastNormal,			FIELD_VECTOR ),

-	DEFINE_FIELD( m_vecHitPos,				FIELD_POSITION_VECTOR ),

-	DEFINE_AUTO_ARRAY( m_vecIKTarget, FIELD_POSITION_VECTOR ),

-

-	DEFINE_EMBEDDED( m_PlayerFreePass ), 

-	

-	DEFINE_EMBEDDED( m_PostureAnimationTimer ),

-

-	DEFINE_EMBEDDED( m_BoneFollowerManager ),

-

-	// m_iszStriderBusterName - recreated at load time

-	// m_iszMagnadeClassname - recreated at load time

-	// m_iszHunterClassname - recreated at load time

-

-	DEFINE_FIELD( m_hRagdoll,				FIELD_EHANDLE ),

-	DEFINE_FIELD( m_hCannonTarget,		FIELD_EHANDLE ),

-	DEFINE_EMBEDDED( m_AttemptCannonLOSTimer ),

-

-	DEFINE_FIELD( m_flSpeedScale, FIELD_FLOAT ),

-	DEFINE_FIELD( m_flTargetSpeedScale, FIELD_FLOAT ),

-

-	DEFINE_EMBEDDED( m_LowZCorrectionTimer ),

-	DEFINE_FIELD( m_BodyTargetBone,		FIELD_INTEGER ),

-

-	DEFINE_FIELD( m_iVisibleEnemies, FIELD_INTEGER ),

-	DEFINE_FIELD( m_flTargetAcquiredTime, FIELD_FLOAT ),

-	DEFINE_FIELD( m_bCrouchLocked, FIELD_BOOLEAN ),

-	DEFINE_FIELD( m_bNoCrouchWalk, FIELD_BOOLEAN ),

-	DEFINE_FIELD( m_bDontCrouch, FIELD_BOOLEAN ),

-	DEFINE_FIELD( m_bNoMoveToLOS, FIELD_BOOLEAN ),

-	DEFINE_KEYFIELD( m_bDisableBoneFollowers, FIELD_BOOLEAN, "disablephysics" ),

-

-	DEFINE_FIELD( m_idealHeight, FIELD_FLOAT ),

-	DEFINE_FIELD( m_HeightVelocity, FIELD_FLOAT ),

-

-	DEFINE_FIELD( m_prevYaw, FIELD_FLOAT ),

-	DEFINE_FIELD( m_doTurn, FIELD_FLOAT ),

-	DEFINE_FIELD( m_doLeft, FIELD_FLOAT ),

-	DEFINE_FIELD( m_doRight, FIELD_FLOAT ),

-	DEFINE_FIELD( m_flNextTurnAct, FIELD_TIME ),

-

-	DEFINE_FIELD( m_strTrackName, FIELD_STRING ),

-	DEFINE_FIELD( m_hFocus, FIELD_EHANDLE ),

-	DEFINE_FIELD( m_hSmoke,	FIELD_EHANDLE ),

-

-	DEFINE_FIELD( m_flTimeLastAlertSound, FIELD_TIME ),

-	DEFINE_FIELD( m_flTimeNextHuntSound, FIELD_TIME ),

-	DEFINE_FIELD( m_flTimePlayerMissileDetected, FIELD_TIME ),

-	DEFINE_FIELD( m_hPlayersMissile, FIELD_EHANDLE ),

-	DEFINE_FIELD( m_bMinigunUseDirectFire, FIELD_BOOLEAN ),

-

-	DEFINE_FIELD( m_bUseAggressiveBehavior, FIELD_BOOLEAN ),

-

-	DEFINE_FIELD( m_bFastCrouch, FIELD_BOOLEAN ),

-	DEFINE_FIELD( m_bMinigunEnabled, FIELD_BOOLEAN ),

-	DEFINE_FIELD( m_bExploding, FIELD_BOOLEAN ),

-

-	// inputs

-	DEFINE_INPUTFUNC( FIELD_FLOAT, "SetMinigunTime", InputSetMinigunTime ),

-	DEFINE_INPUTFUNC( FIELD_STRING, "SetMinigunTarget", InputSetMinigunTarget ),

-	DEFINE_INPUTFUNC( FIELD_STRING, "SetCannonTarget", InputSetCannonTarget ),

-	DEFINE_INPUTFUNC( FIELD_STRING, "FlickRagdoll", InputFlickRagdoll ),

-	DEFINE_INPUTFUNC( FIELD_VOID, "Crouch", InputCrouch ),

-	DEFINE_INPUTFUNC( FIELD_VOID, "CrouchInstantly", InputCrouchInstantly ),

-	DEFINE_INPUTFUNC( FIELD_VOID, "Stand", InputStand ),

-	DEFINE_INPUTFUNC( FIELD_FLOAT, "SetHeight", InputSetHeight ),

-	DEFINE_INPUTFUNC( FIELD_STRING, "SetTargetPath", InputSetTargetPath ),

-	DEFINE_INPUTFUNC( FIELD_STRING, "ClearTargetPath", InputClearTargetPath ),

-	DEFINE_INPUTFUNC( FIELD_VOID, "DisableCrouchWalk", InputDisableCrouchWalk ),

-	DEFINE_INPUTFUNC( FIELD_VOID, "EnableCrouchWalk", InputEnableCrouchWalk ),

-	DEFINE_INPUTFUNC( FIELD_VOID, "EnableAggressiveBehavior", InputEnableAggressiveBehavior ),

-	DEFINE_INPUTFUNC( FIELD_VOID, "DisableAggressiveBehavior", InputDisableAggressiveBehavior ),

-	DEFINE_INPUTFUNC( FIELD_VOID, "DisableMinigun", InputDisableMinigun ),

-	DEFINE_INPUTFUNC( FIELD_VOID, "EnableMinigun", InputEnableMinigun ),

-	DEFINE_INPUTFUNC( FIELD_FLOAT, "StopShootingMinigunForSeconds", InputStopShootingMinigunForSeconds ),

-	DEFINE_INPUTFUNC( FIELD_VOID, "DisableCrouch", InputDisableCrouch ),

-	DEFINE_INPUTFUNC( FIELD_VOID, "DisableMoveToLOS", InputDisableMoveToLOS ),

-	DEFINE_INPUTFUNC( FIELD_STRING, "DisableCollisionWith", InputDisableCollisionWith ),

-	DEFINE_INPUTFUNC( FIELD_STRING, "EnableCollisionWith", InputEnableCollisionWith ),

-	DEFINE_INPUTFUNC( FIELD_VOID, "Explode", InputExplode ),

-	DEFINE_INPUTFUNC( FIELD_FLOAT, "ScaleGroundSpeed", InputScaleGroundSpeed ),

-

-	// Function Pointers

-//	DEFINE_FUNCTION( JumpTouch ),

-	DEFINE_THINKFUNC( CarriedThink ),

-	DEFINE_THINKFUNC( CannonHitThink ),

-

-END_DATADESC()

-

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

-

-float CNPC_Strider::gm_strideLength;

-

-int CNPC_Strider::gm_BodyHeightPoseParam;

-int CNPC_Strider::gm_YawControl;

-int CNPC_Strider::gm_PitchControl;

-int CNPC_Strider::gm_CannonAttachment;

-

-float CNPC_Strider::gm_zCannonDist;

-float CNPC_Strider::gm_zMinigunDist;

-Vector CNPC_Strider::gm_vLocalRelativePositionCannon;

-Vector CNPC_Strider::gm_vLocalRelativePositionMinigun;

-

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

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

-CNPC_Strider::CNPC_Strider()

-{

-	m_strTrackName = MAKE_STRING( STRIDER_NO_TRACK_NAME );

-	m_hFocus = NULL;

-	m_pMinigun = new CStriderMinigun;

-	m_hSmoke = NULL;

-	m_PlayerFreePass.SetOuter( this );

-	m_bExploding = false;

-}

-

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

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

-CNPC_Strider::~CNPC_Strider()

-{

-	delete m_pMinigun;

-}

-

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

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

-void CNPC_Strider::Precache()

-{

-	if ( !GetModelName() )

-	{

-		SetModelName( MAKE_STRING( "models/combine_strider.mdl" ) );

-	}

-

-	PrecacheModel( STRING( GetModelName() ) );

-

-	PropBreakablePrecacheAll( GetModelName() );

-

-	PrecacheScriptSound( "NPC_Strider.StriderBusterExplode" );

-	PrecacheScriptSound( "explode_5" );

-	PrecacheScriptSound( "NPC_Strider.Charge" );

-	PrecacheScriptSound( "NPC_Strider.RagdollDetach" );

-	PrecacheScriptSound( "NPC_Strider.Whoosh" );

-	PrecacheScriptSound( "NPC_Strider.Creak" );

-	PrecacheScriptSound( "NPC_Strider.Alert" );

-	PrecacheScriptSound( "NPC_Strider.Pain" );

-	PrecacheScriptSound( "NPC_Strider.Death" );

-	PrecacheScriptSound( "NPC_Strider.FireMinigun" );

-	PrecacheScriptSound( "NPC_Strider.Shoot" );

-	PrecacheScriptSound( "NPC_Strider.OpenHatch" );

-	PrecacheScriptSound( "NPC_Strider.Footstep" );

-	PrecacheScriptSound( "NPC_Strider.Skewer" );

-	PrecacheScriptSound( "NPC_Strider.Hunt" );

-	PrecacheMaterial( "effects/water_highlight" );

-	s_iImpactEffectTexture = PrecacheModel( "sprites/physbeam.vmt" );

-	PrecacheMaterial( "sprites/bluelaser1" );

-	PrecacheMaterial( "effects/blueblacklargebeam" );

-	PrecacheMaterial( "effects/strider_pinch_dudv" );

-	PrecacheMaterial( "effects/blueblackflash" );

-	PrecacheMaterial( "effects/strider_bulge_dudv" );

-	PrecacheMaterial( "effects/strider_muzzle" );

-

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

-

-	UTIL_PrecacheOther( "sparktrail" );

-

-	BaseClass::Precache();

-}

-

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

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

-void CNPC_Strider::Spawn()

-{

-	Precache();

-

-	m_miniGunAmmo = GetAmmoDef()->Index("StriderMinigun"); 

-	m_miniGunDirectAmmo = GetAmmoDef()->Index("StriderMinigunDirect");

-	m_pMinigun->Init();

-

-	EnableServerIK();

-	

-	SetModel( STRING( GetModelName() ) );

-

-	BaseClass::Spawn();

-

-	//m_debugOverlays |= OVERLAY_NPC_ROUTE_BIT | OVERLAY_BBOX_BIT;

-	SetHullType( HULL_LARGE_CENTERED );

-	SetHullSizeNormal();

-	SetDefaultEyeOffset();

-	

-	SetNavType( NAV_FLY );

-	m_flGroundSpeed	= STRIDER_SPEED;

-	m_flSpeedScale = m_flTargetSpeedScale = 1.0;

-	m_NPCState = NPC_STATE_NONE;

-	m_bloodColor = DONT_BLEED;

-	

-	m_iHealth = sk_strider_health.GetFloat();

-	m_iMaxHealth = 500;

-

-	m_flFieldOfView = 0.0; // 180 degrees

-

-	AddFlag( FL_FLY );

-	SetCollisionGroup( HL2COLLISION_GROUP_STRIDER );

-	SetSolid( SOLID_BBOX );

-	AddSolidFlags( FSOLID_NOT_STANDABLE );

-	SetMoveType( MOVETYPE_STEP );

-	AddEFlags( EFL_NO_DISSOLVE | EFL_NO_MEGAPHYSCANNON_RAGDOLL );

-

-	// Cached for quick comparisons

-	m_iszStriderBusterName = AllocPooledString( "weapon_striderbuster" );

-	m_iszMagnadeClassname  = AllocPooledString( "npc_grenade_magna" );

-	m_iszHunterClassname   = AllocPooledString( "npc_hunter" );

-

-	// BMCD: Force collision hooks

-	AddSolidFlags( FSOLID_CUSTOMRAYTEST | FSOLID_CUSTOMBOXTEST );

-	SetupGlobalModelData();

-	

-	CapabilitiesAdd( bits_CAP_MOVE_FLY | bits_CAP_INNATE_RANGE_ATTACK2 | bits_CAP_INNATE_MELEE_ATTACK1 | bits_CAP_INNATE_MELEE_ATTACK2 | bits_CAP_SQUAD );

-

-	// Don't allow us to skip animation setup because our attachments are critical to us!

-	SetBoneCacheFlags( BCF_NO_ANIMATION_SKIP );

-

-	// find the ground, move up to strider stand height

-	Vector mins(-16,-16,-16), maxs(16,16,16);

-	Vector origin = GetLocalOrigin();

-

-	MoveToGround( &origin, this, mins, maxs );

-	origin.z += GetMaxHeight();//(GetAbsOrigin().z - vecSurroundMins.z) + mins.z;

-

-	SetLocalOrigin( origin );

-

-	NPCInit();

-

-	// Strider doesn't care about missiles for now.

-	AddClassRelationship( CLASS_MISSILE, D_NU, 0 );

-

-	m_bCrouchLocked = false;

-	m_bMinigunEnabled = true;

-

-	m_PostureAnimationTimer.Set( 8, 16 );

-

-	m_BodyTargetBone = -1;

-

-	CreateFocus();

-

-	m_EnemyUpdatedTimer.Set( 0 );

-

-	// Don't minigun things farther than 500 feet away. 

-	m_flDistTooFar = 500.0f * 12.0f;

-

-	GetEnemies()->SetFreeKnowledgeDuration( strider_free_knowledge.GetFloat() );

-

-	m_hPlayersMissile.Set( NULL );

-	m_flTimeNextHuntSound = gpGlobals->curtime - 1.0f;

-}

-

-void CNPC_Strider::SetupGlobalModelData()

-{

-	gm_BodyHeightPoseParam = LookupPoseParameter( "body_height" );

-	gm_YawControl = LookupPoseParameter( "yaw" );

-	gm_PitchControl = LookupPoseParameter( "pitch" );

-	gm_CannonAttachment = LookupAttachment( "BigGun" );

-

-	// BMCD: Get the conservative boxes from sequences

-	Vector mins, maxs;

-	ExtractBbox( SelectHeaviestSequence( ACT_WALK ), mins, maxs );

-	CNPC_Strider::gm_strideLength = (maxs.x - mins.x) * 0.5;

-

-	// UNDONE: use crouch when crouched

-	CollisionProp()->SetSurroundingBoundsType( USE_HITBOXES );

-}

-

-void CNPC_Strider::OnRestore()

-{

-	BaseClass::OnRestore();

-	SetupGlobalModelData();

-	CreateVPhysics();

-

-	// Cached for quick comparisons

-	m_iszStriderBusterName = FindPooledString( "weapon_striderbuster" );

-	m_iszMagnadeClassname  = FindPooledString( "npc_grenade_magna" );

-}

-

-bool CNPC_Strider::m_sbStaticPoseParamsLoaded = false;

-int CNPC_Strider::m_poseMiniGunYaw = 0;

-int CNPC_Strider::m_poseMiniGunPitch = 0;

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

-// Purpose: Cache whatever pose parameters we intend to use

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

-void CNPC_Strider::PopulatePoseParameters( void )

-{

-	if (!m_sbStaticPoseParamsLoaded)

-	{

-		m_poseMiniGunYaw		= LookupPoseParameter( "miniGunYaw");

-		m_poseMiniGunPitch		= LookupPoseParameter( "miniGunPitch" );

-

-		m_sbStaticPoseParamsLoaded = true;

-	}

-

-	BaseClass::PopulatePoseParameters();

-}

-

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

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

-bool CNPC_Strider::CreateVPhysics()

-{

-	// The strider has bone followers for every solid part of its body, 

-	// so there's no reason for the bounding box to be solid.

-	//BaseClass::CreateVPhysics();

-

-	if ( !m_bDisableBoneFollowers )

-	{

-		InitBoneFollowers();

-	}

-

-	return true;

-}

-

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

-// Purpose: 

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

-void CNPC_Strider::InitBoneFollowers( void )

-{

-	// Don't do this if we're already loaded

-	if ( m_BoneFollowerManager.GetNumBoneFollowers() != 0 )

-		return;

-

-	// Init our followers

-	m_BoneFollowerManager.InitBoneFollowers( this, ARRAYSIZE(pFollowerBoneNames), pFollowerBoneNames );

-}

-

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

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

-void CNPC_Strider::PostNPCInit()

-{

-	BaseClass::PostNPCInit();

-

-	if( CarriedByDropship() )

-	{

-		SetMoveType( MOVETYPE_NONE );

-		SetActivity( (Activity)ACT_STRIDER_CARRIED );

-		SetThink( &CNPC_Strider::CarriedThink );

-		RemoveFlag( FL_FLY );

-	}

-

-	m_PlayerFreePass.SetPassTarget( UTIL_PlayerByIndex(1) );

-	

-	AI_FreePassParams_t freePassParams = 

-	{

-		strider_free_pass_start_time.GetFloat(),		// timeToTrigger

-		strider_free_pass_duration.GetFloat(), 			// duration

-		strider_free_pass_move_tolerance.GetFloat(), 	// moveTolerance

-		strider_free_pass_refill_rate.GetFloat(), 		// refillRate

-		strider_free_pass_cover_dist.GetFloat(), 		// coverDist

-		strider_peek_time.GetFloat(), 					// peekTime

-		strider_peek_time_after_damage.GetFloat(), 		// peekTimeAfterDamage

-		strider_peek_eye_dist.GetFloat(), 				// peekEyeDist

-		strider_peek_eye_dist_z.GetFloat(), 			// peekEyeDistZ

-	};

-	

-	m_PlayerFreePass.SetParams( freePassParams );

-}

-

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

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

-void CNPC_Strider::Activate()

-{

-	BaseClass::Activate();

-

-	const char *pszBodyTargetBone = "combine_strider.neck_bone";

-

-	m_BodyTargetBone = LookupBone( pszBodyTargetBone );

-

-	if ( m_BodyTargetBone == -1 )

-	{

-		DevMsg( "Couldn't find npc_strider bone %s, which is used as target for others\n", pszBodyTargetBone );

-	}

-

-	gm_BodyHeightPoseParam = LookupPoseParameter( "body_height" );

-	gm_YawControl = LookupPoseParameter( "yaw" );

-	gm_PitchControl = LookupPoseParameter( "pitch" );

-	gm_CannonAttachment = LookupAttachment( "BigGun" );

-

-	if ( gm_zCannonDist == 0 )

-	{

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

-		CNPC_Strider *pStrider = (CNPC_Strider *)CreateEntityByName( "npc_strider" );

-		Assert(pStrider);

-		pStrider->m_bDisableBoneFollowers = true; // don't create these since we're just going to destroy him

-		DispatchSpawn( pStrider );

-

-		pStrider->SetActivity( ACT_DIERAGDOLL );

-		pStrider->InvalidateBoneCache();

-		gm_zCannonDist = pStrider->CannonPosition().z - pStrider->GetAbsOrigin().z;

-

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

-		Vector defEyePos;

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

-		gm_zMinigunDist = defEyePos.z - pStrider->GetAbsOrigin().z;

-

-		Vector position;

-		pStrider->GetAttachment( "biggun", position );

-		VectorITransform( position, pStrider->EntityToWorldTransform(), gm_vLocalRelativePositionCannon );

-

-		pStrider->GetAttachment( "minigun", position );

-		VectorITransform( position, pStrider->EntityToWorldTransform(), gm_vLocalRelativePositionMinigun );

-		UTIL_Remove( pStrider );

-	}

-}

-

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

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

-void CNPC_Strider::UpdateOnRemove()

-{

-	m_BoneFollowerManager.DestroyBoneFollowers();

-

-#ifdef HL2_EPISODIC

-	m_hAttachedBusters.Purge();

-#endif // HL2_EPISODIC

-

-	BaseClass::UpdateOnRemove();

-}

-

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

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

-void CNPC_Strider::InitBoneControllers()

-{

-	BaseClass::InitBoneControllers( );

-	

-	SetHeight( GetMaxHeight() );

-	SetIdealHeight( GetMaxHeight() );

-}

-

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

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

-Class_T CNPC_Strider::Classify()

-{

-	if( CarriedByDropship() )

-		return CLASS_NONE;

-

-	return CLASS_COMBINE;

-}

-

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

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

-bool CNPC_Strider::ShouldAttractAutoAim( CBaseEntity *pAimingEnt )

-{

-#ifdef HL2_EPISODIC

-	if( m_hAttachedBusters.Count() > 0 )

-		return false;

-#endif//HL2_EPISODIC

-

-	return BaseClass::ShouldAttractAutoAim( pAimingEnt );

-}

-

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

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

-int	CNPC_Strider::DrawDebugTextOverlays()

-{

-	int text_offset = BaseClass::DrawDebugTextOverlays();

-

-	if (m_debugOverlays & OVERLAY_TEXT_BIT)

-	{

-		EntityText(text_offset,CFmtStr("Ideal Height: %.1f; Height: %.1f", GetIdealHeight(), GetHeight()),0);

-		text_offset++;

-		if ( m_PlayerFreePass.HasPass() )

-		{

-			EntityText(text_offset,CFmtStr("Free pass: %.1f", m_PlayerFreePass.GetTimeRemaining()),0);

-			text_offset++;

-		}

-

-		CBaseEntity *pPlayer = UTIL_PlayerByIndex(1);

-		if ( pPlayer )

-		{

-			if ( GetSenses()->ShouldSeeEntity( pPlayer ) && GetSenses()->CanSeeEntity( pPlayer ) )

-			{

-				EntityText(text_offset,"See player",0);

-				text_offset++;

-			}

-			else

-			{

-				float temp = m_PlayerFreePass.GetTimeRemaining();

-				m_PlayerFreePass.SetTimeRemaining( 0 );

-

-				if ( BaseClass::FVisible( pPlayer ) && !FVisible( pPlayer ) )

-				{

-					EntityText(text_offset,"Player peeking",0);

-					text_offset++;

-				}

-				m_PlayerFreePass.SetTimeRemaining( temp );

-			}

-		}

-

-		if ( m_flTargetSpeedScale != 1.0 )

-		{

-			EntityText(text_offset,CFmtStr( "Speed scaled to %.1f", m_flGroundSpeed ),0);

-			text_offset++;

-		}

-	}

-

-	return text_offset;

-}

-

-

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

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

-Vector CNPC_Strider::EyePosition()

-{

-	Vector eyePosition = GetAdjustedOrigin();

-	eyePosition.z += gm_zMinigunDist;

-	return eyePosition;

-}

-

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

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

-const Vector &CNPC_Strider::GetViewOffset()

-{

-	Vector vOffset;

-

-	vOffset.x = 0;

-	vOffset.y = 0;

-	vOffset.z = ( GetHeight() - GetMaxHeightModel() ) + gm_zMinigunDist;

-

-	Assert( VectorsAreEqual( GetAbsOrigin() + vOffset, EyePosition(), 0.1 ));

-

-	SetViewOffset( vOffset );

-

-	return BaseClass::GetViewOffset();

-}

-

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

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

-void CNPC_Strider::CalculateIKLocks( float currentTime )

-{

-	BaseClass::CalculateIKLocks( currentTime );

-	if ( m_pIk && m_pIk->m_target.Count() )

-	{

-		Assert(m_pIk->m_target.Count() > STOMP_IK_SLOT);

-		// HACKHACK: Hardcoded 11???  Not a cleaner way to do this

-		CIKTarget &target = m_pIk->m_target[STOMP_IK_SLOT];

-		target.SetPos( m_vecHitPos.Get() );

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

-		{

-			target = m_pIk->m_target[i];

-

-			if (!target.IsActive())

-				continue;

-

-			m_vecIKTarget.Set( i, target.est.pos );

-

-#if 0

-		// yellow box at target pos - helps debugging

-		//if (i == 0)

-			NDebugOverlay::Line( GetAbsOrigin(), m_vecIKTarget[i], 255, 255, 0, 0, 0.1 );

-			NDebugOverlay::Box( m_vecIKTarget[i], Vector(-8,-8,-8), Vector(8,8,8), 255, 255, 0, 0, 4.0 );

-#endif

-		}

-	}

-}

-

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

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

-void CNPC_Strider::NPCThink(void)

-{

-	if ( m_hRagdoll.Get() )

-	{

-		m_nextStompTime = gpGlobals->curtime + 5;

-	}

-

-	if ( m_flTargetSpeedScale > 0.01 )

-	{

-		float deltaSpeedScale = m_flSpeedScale - m_flTargetSpeedScale;

-		if ( fabsf( deltaSpeedScale ) > .01 )

-		{

-			if ( deltaSpeedScale < 0 )

-			{

-				m_flSpeedScale += STRIDER_SPEED_CHANGE;

-				if ( m_flSpeedScale > m_flTargetSpeedScale )

-				{

-					m_flSpeedScale = m_flTargetSpeedScale;

-				}

-			}

-			else

-			{

-				m_flSpeedScale -= STRIDER_SPEED_CHANGE;

-				if ( m_flSpeedScale < m_flTargetSpeedScale )

-				{

-					m_flSpeedScale = m_flTargetSpeedScale;

-				}

-			}

-		}

-		else

-		{

-			m_flSpeedScale = m_flTargetSpeedScale;

-		}

-	}

-	else

-	{

-		m_flTargetSpeedScale = 1.0;

-	}

-

-	BaseClass::NPCThink();

-	

-	m_pMinigun->Think( this, 0.1 );

-

-	// update follower bones

-	m_BoneFollowerManager.UpdateBoneFollowers(this);

-}

-

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

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

-void CNPC_Strider::PrescheduleThink()

-{

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

-	{

-		AddFacingTarget( GetEnemy(), GetEnemies()->LastKnownPosition( GetEnemy() ) , 1.0, 2.0 );

-	}

-

-	// Next missile will kill me!

-	if( GetHealth() <= 50 && random->RandomInt( 0, 20 ) == 0 )

-	{

-		CBaseEntity *pTrail = CreateEntityByName( "sparktrail" );

-		pTrail->SetOwnerEntity( this );

-		pTrail->Spawn();

-	}

-

-#if 0

-	NDebugOverlay::Cross3D( GetAdjustedOrigin(), 16, 128, 128, 128, false, .1 );

-	Vector vIdealOrigin = GetAbsOrigin();

-	vIdealOrigin.z -= GetMaxHeightModel() - GetIdealHeight();

-	NDebugOverlay::Cross3D( vIdealOrigin, 16, 255, 255, 255, false, .1 );

-#endif

-

-	if( strider_eyepositions.GetBool() )

-	{

-		NDebugOverlay::Cross3D( EyePosition(), 16, 0, 255, 0, false, 0.1 );

-		NDebugOverlay::Cross3D( EyePositionCrouched(), 16, 255, 255, 0, false, 0.1 );

-	}

-

-	if( strider_show_focus.GetBool() )

-	{

-		QAngle angles;

-

-		angles.x = gpGlobals->curtime * 20.0f;

-		angles.y = angles.x * 0.5f;

-		angles.z = 0.0f;

-

-		NDebugOverlay::Cross3DOriented( GetFocus()->GetAbsOrigin(), angles, 24, 255, 255, 0, false, 0.1 );

-	}

-}

-

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

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

-void CNPC_Strider::GatherConditions()

-{

-	if ( AIGetNumFollowers( this, m_iszHunterClassname ) == 0 )	

-	{

-		// This works with old data because need to do before base class so as to not choose as enemy

-		if ( m_PlayerFreePass.HasPass() || ( !m_pMinigun->IsShooting() || GetEnemy() != m_PlayerFreePass.GetPassTarget() ) ) // no free pass when in midst of shooting at target

-			m_PlayerFreePass.Update();

-	}

-	else

-	{

-		m_PlayerFreePass.Reset( strider_free_pass_after_escorts_dead.GetFloat(), strider_free_pass_tolerance_after_escorts_dead.GetFloat() );

-	}

-

-	if( IsUsingAggressiveBehavior() )

-	{

-		if( m_PlayerFreePass.HasPass() && !m_pMinigun->IsShooting() )

-		{

-			// Make the minigun stitch

-			m_bMinigunUseDirectFire = false;

-		}

-	}

-

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

-

-	BaseClass::GatherConditions();

-

-	if( IsUsingAggressiveBehavior() )

-	{

-		if( GetEnemy() )

-		{

-			if( HasCondition( COND_SEE_ENEMY ) )

-			{

-				// Keep setting up to play my hunt sound at some random time after losing sight of my enemy.

-				m_flTimeNextHuntSound = gpGlobals->curtime + 1.0f;

-			}

-			else

-			{

-				if( gpGlobals->curtime >= m_flTimeNextHuntSound && !m_pMinigun->IsShooting() )

-				{

-					HuntSound();

-				}

-			}

-		}

-

-		if( m_hPlayersMissile )

-		{

-			if( !m_pMinigun->IsShooting() && GetEnemy() && GetEnemy()->IsPlayer() )

-			{

-				// If the missile is closer to the player than I am, stay suppressed. This is essentially

-				// allowing the missile to strike me if it was fired off before I started shooting. 

-				// If the missile passes me or goes way off course, I can shoot.

-				float flPlayerMissileDist;

-				float flPlayerStriderDist;

-

-				flPlayerMissileDist = GetEnemy()->GetAbsOrigin().DistTo( m_hPlayersMissile->GetAbsOrigin() );

-				flPlayerStriderDist = GetEnemy()->GetAbsOrigin().DistTo( EyePosition() );

-				float flDiff = flPlayerMissileDist - flPlayerStriderDist;

-

-				// Figure out how long it's been since I've fired my cannon because of a player's missile.

-				float flTimeSuppressed = gpGlobals->curtime - m_flTimePlayerMissileDetected;

-

-				if( flDiff < strider_missile_suppress_dist.GetFloat() && flTimeSuppressed < strider_missile_suppress_time.GetFloat() )

-				{

-					// Defer the minigun until/unless the missile has passed me by 10 feet

-					m_pMinigun->StopShootingForSeconds( this, GetEnemy(), 0.5f );

-				}

-			}

-		}

-	}

-

-	// This pair of conditions is nice to have around...

-	if( m_pMinigun->IsShooting() )

-	{

-		SetCondition( COND_STRIDER_MINIGUN_SHOOTING );

-	}

-	else

-	{

-		SetCondition( COND_STRIDER_MINIGUN_NOT_SHOOTING );

-	}

-

-	if( GetCannonTarget() )

-	{

-		SetCondition( COND_STRIDER_HAS_CANNON_TARGET );

-

-		if( strider_show_cannonlos.GetBool() )

-		{

-			trace_t tr;

-			UTIL_TraceLine( CannonPosition(), GetCannonTarget()->WorldSpaceCenter(), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );

-			NDebugOverlay::Line( tr.startpos, tr.endpos, 0, 255, 0, false, 0.1 );

-

-			if( tr.fraction != 1.0 )

-				NDebugOverlay::Line( tr.endpos, GetCannonTarget()->WorldSpaceCenter(), 255, 0, 0, false, 0.1 );

-		}

-	}

-	else

-	{

-		ClearCondition( COND_STRIDER_HAS_CANNON_TARGET );

-	}

-

-	ClearCondition( COND_CAN_RANGE_ATTACK2 );

-	ClearCondition( COND_STRIDER_HAS_LOS_Z );

-

-	// If not locked into a crouch, look into adjusting height to attack targets.

-	if( !m_bCrouchLocked && !m_bDontCrouch )

-	{

-		if( m_hCannonTarget != NULL )

-		{	

-			if( !IsStriderCrouching() && !IsStriderStanding() )

-			{

-				if ( WeaponLOSCondition( GetAdjustedOrigin(), m_hCannonTarget->GetAbsOrigin(), false ) )

-				{

-					SetCondition( COND_CAN_RANGE_ATTACK2 );

-				}

-				else

-				{

-					GatherHeightConditions( GetAdjustedOrigin(), m_hCannonTarget );

-				}

-			}

-		}

-		else if( GetEnemy() )

-		{

-			if ( strider_distributed_fire.GetBool() && !IsUsingAggressiveBehavior() )

-			{

-				m_iVisibleEnemies = 0;

-				AIEnemiesIter_t iter;

-

-				for( AI_EnemyInfo_t *pEMemory = GetEnemies()->GetFirst(&iter); pEMemory != NULL; pEMemory = GetEnemies()->GetNext(&iter) )

-				{

-					if( IRelationType( pEMemory->hEnemy ) != D_NU && IRelationType( pEMemory->hEnemy ) != D_LI )

-					{

-						if( pEMemory->timeLastSeen == gpGlobals->curtime )

-						{

-							m_iVisibleEnemies++;

-						}

-					}

-				}

-

-				// If I'm on target and see more targets than just this one, move on to another target for a bit!

-				// Because the Mingun's state will stay "on target" until the minigun gets a chance to think,

-				// and this function may be called several times per strider think, don't call this code anymore in the same

-				// think when a new enemy is chosen.

-				//

-				// Don't switch targets if shooting at a bullseye! Level designers depend on bullseyes.

-				if( GetEnemy() && m_pMinigun->IsShooting() && GetTimeEnemyAcquired() != gpGlobals->curtime )

-				{

-					if( m_pMinigun->IsOnTarget( 3 ) && !FClassnameIs( GetEnemy(), "npc_bullseye" ) )

-					{

-						if( m_iVisibleEnemies > 1 )

-						{

-							// Time to ignore this guy for a little while and switch targets.

-							GetEnemies()->SetTimeValidEnemy( GetEnemy(), gpGlobals->curtime + ( STRIDER_IGNORE_TARGET_DURATION * m_iVisibleEnemies ) );

-							SetEnemy( NULL, false );

-							ChooseEnemy();

-						}

-						else if( GetEnemy()->IsPlayer() && GetEnemy() == m_pMinigun->GetTarget() )

-						{

-							// Give the poor target a break.

-							m_pMinigun->StopShootingForSeconds( this, GetEnemy(), GetMinigunShootDowntime() );

-						}

-					}

-				}

-			}

-

-			if ( GetEnemy() ) // Can go null above

-			{

-				if ( !IsStriderCrouching() && !IsStriderStanding() &&

-					 ( !HasCondition( COND_SEE_ENEMY ) || 

-					   !WeaponLOSCondition( GetAdjustedOrigin(), GetEnemy()->BodyTarget( GetAdjustedOrigin() ), false ) ) )

-				{

-#if 0

-					if ( !HasCondition( COND_STRIDER_SHOULD_CROUCH ) && !HasCondition( COND_STRIDER_SHOULD_CROUCH ) )

-						SetIdealHeight( MIN( GetMaxHeight(), GetHeight() + 75.0 * 0.1 ) ); // default to rising up

-#endif

-					GatherHeightConditions( GetAdjustedOrigin(), GetEnemy() );

-				}

-			}

-		}

-		else

-			SetIdealHeight( GetMaxHeight() );

-	}

-	else

-	{

-		if( m_hCannonTarget != NULL && CurrentWeaponLOSCondition( m_hCannonTarget->GetAbsOrigin(), false ) )

-			SetCondition( COND_CAN_RANGE_ATTACK2 );

-	}

-

-	if( m_bDontCrouch )

-	{

-		if( HasCondition( COND_STRIDER_SHOULD_CROUCH ) )

-		{

-			Msg("TELL WEDGE I'M TRYING TO CROUCH!\n");

-		}

-

-		ClearCondition( COND_STRIDER_SHOULD_CROUCH );

-	}

-}

-

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

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

-void CNPC_Strider::GatherHeightConditions( const Vector &vTestPos, CBaseEntity *pEntity )

-{

-	if ( HasCondition( COND_STRIDER_SHOULD_CROUCH ) && HasCondition( COND_STRIDER_SHOULD_CROUCH ) )

-		return;

-

-	float maxZ = (GetAbsOrigin().z - (GetMaxHeightModel() - GetMaxHeight()));

-	float minZ = (maxZ - ( GetMaxHeight() - GetMinHeight()));;

-	float newHeight = FLT_MAX;

-

-	if( FInViewCone( pEntity ) && GetWeaponLosZ( vTestPos, minZ, maxZ, GetHeightRange() * .1, pEntity, &newHeight ) )

-	{

-		bool bDoProceduralHeightChange = true;

-		newHeight = GetMaxHeightModel() - ( GetAbsOrigin().z - newHeight);

-

-		if ( m_LowZCorrectionTimer.Expired() )

-		{

-			// Hack to handle discrepency between ideal gun pos and actual pos due to strider head tilt in crouch pos

-			if ( pEntity && fabs( newHeight - GetHeight() ) < 12 && newHeight < GetMinHeight() + GetHeightRange() * .33 )

-			{

-				Vector muzzlePos;

-				Vector targetPos = pEntity->BodyTarget( GetAdjustedOrigin() );

-

-				GetAttachment( "minigun", muzzlePos );

-				

-				trace_t tr;

-				AI_TraceLine( muzzlePos, targetPos, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);

-

-				if ( ( tr.m_pEnt != pEntity) && tr.fraction != 1.0 && !CanShootThrough( tr, targetPos ) )

-				{

-					if ( !GetWeaponLosZ( vTestPos, minZ + GetHeightRange() * .33, maxZ, GetHeightRange() * .1, pEntity, &newHeight ) )

-					{

-						return;

-					}

-					newHeight = GetMaxHeightModel() - ( GetAbsOrigin().z - newHeight);

-				}

-				else

-				{

-					m_LowZCorrectionTimer.Set( 5.0 );

-				}

-			}

-		}

-

-		if ( !strider_always_use_procedural_height.GetBool() )

-		{

-			// If going from max to min, or min to max, use animations 60% of the time

-			if ( fabsf(GetMaxHeight() - GetHeight()) < 0.1 && fabsf(GetMinHeight() - newHeight) < 0.1 )

-			{

-				if ( random->RandomInt(1, 10 ) <= 6 )

-				{

-					SetCondition( COND_STRIDER_SHOULD_CROUCH );

-					bDoProceduralHeightChange = false;

-				}

-			}

-			else if ( fabsf(GetMinHeight() - GetHeight()) < 0.1 && fabsf(GetMaxHeight() - newHeight) < 0.1 )

-			{

-				if ( random->RandomInt(1, 10 ) <= 6 )

-				{

-					SetCondition( COND_STRIDER_SHOULD_STAND );

-					bDoProceduralHeightChange = false;

-				}

-			}

-

-			// Otherwise, if going from near max or near min to the other, use animations based on time

-			if ( bDoProceduralHeightChange && m_PostureAnimationTimer.Expired() )

-			{

-				if ( GetHeight() - GetMinHeight() > GetHeightRange() * .85 && newHeight - GetMinHeight() < GetHeightRange() * .15 )

-				{

-					m_PostureAnimationTimer.Reset();

-					SetCondition( COND_STRIDER_SHOULD_CROUCH );

-					bDoProceduralHeightChange = false;

-				}

-				else if ( newHeight - GetMinHeight() > GetHeightRange() * .85 && GetHeight() - GetMinHeight() < GetHeightRange() * .15 )

-				{

-					m_PostureAnimationTimer.Reset();

-					SetCondition( COND_STRIDER_SHOULD_STAND );

-					bDoProceduralHeightChange = false;

-				}

-			}

-		}

-

-		if ( bDoProceduralHeightChange )

-		{

-			SetCondition( COND_STRIDER_HAS_LOS_Z );

-			SetIdealHeight( newHeight );

-			if ( strider_test_height.GetFloat() > .1 )

-				SetIdealHeight( strider_test_height.GetFloat() );

-		}

-		else

-			SetIdealHeight( GetHeight() );

-	}

-}

-

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

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

-void CNPC_Strider::OnStateChange( NPC_STATE oldState, NPC_STATE newState )

-{

-	if ( oldState == NPC_STATE_SCRIPT )

-	{

-		m_pMinigun->Enable( this, m_bMinigunEnabled );

-	}

-	else if ( newState == NPC_STATE_SCRIPT )

-	{

-		m_pMinigun->Enable( this, false );

-	}

-}

-

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

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

-void CNPC_Strider::BuildScheduleTestBits()

-{

-	BaseClass::BuildScheduleTestBits();

-	if (m_NPCState != NPC_STATE_SCRIPT)

-	{

-		SetCustomInterruptCondition( COND_STRIDER_DO_FLICK );

-	}

-

-	if( IsCurSchedule( SCHED_ESTABLISH_LINE_OF_FIRE_FALLBACK, false ) || IsCurSchedule( SCHED_ESTABLISH_LINE_OF_FIRE, false ) )

-	{

-		SetCustomInterruptCondition( COND_STRIDER_MINIGUN_SHOOTING );

-	}

-

-	if( IsCurSchedule( SCHED_IDLE_STAND ) )

-	{

-		SetCustomInterruptCondition( COND_STRIDER_HAS_CANNON_TARGET );

-	}

-

-	// If our base-class schedule breaks on CAN_RANGE_ATTACK1, then also break

-	// on HAS_CANNON_TARGET.

-	if( GetCurSchedule()->HasInterrupt( COND_CAN_RANGE_ATTACK1 ) && HasCondition( COND_STRIDER_HAS_CANNON_TARGET ) )

-	{

-		SetCustomInterruptCondition( COND_STRIDER_HAS_CANNON_TARGET );

-	}

-

-	if( IsCurSchedule( SCHED_IDLE_WALK ) || ( IsCurSchedule( SCHED_IDLE_STAND ) && hl2_episodic.GetBool() ) )

-	{

-		SetCustomInterruptCondition(COND_STRIDER_SHOULD_CROUCH);

-	}

-}

-

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

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

-int CNPC_Strider::SelectSchedule()

-{

-/*

-	if( GetMoveType() != MOVETYPE_FLY )

-	{

-		// Dropship just released me.

-		SetMoveType( MOVETYPE_FLY );

-		return SCHED_STRIDER_FALL_TO_GROUND;

-	}

-*/

-	if ( strider_idle_test.GetBool() )

-	{

-		m_pMinigun->Enable( this, false );

-		return SCHED_IDLE_STAND;

-	}

-	else

-	{

-		m_pMinigun->Enable( this, m_bMinigunEnabled );

-	}

-

-	if( m_NPCState == NPC_STATE_SCRIPT )

-		return BaseClass::SelectSchedule();

-

-	// If we're starting to die, then just wait for this to happen

-	if ( m_lifeState == LIFE_DYING )

-		return SCHED_IDLE_STAND;

-

-	if( m_NPCState == NPC_STATE_DEAD )

-		return SCHED_STRIDER_DIE;

-

-	if( HasPendingTargetPath() )

-	{

-#if 0

-		if( IsInCrouchedPosture() && !m_bCrouchLocked )

-		{

-			// Make the strider stand!

-			return SCHED_STRIDER_STAND;

-		}

-		else

-		{

-			SetTargetPath();

-		}

-#else

-		SetTargetPath();

-#endif

-	}

-

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

-

-	if( HasCondition( COND_STRIDER_SHOULD_CROUCH ) && GetHeight() - GetMinHeight() > GetHeightRange() * .5 )

-	{

-		return SCHED_STRIDER_CROUCH;

-	}

-	if( HasCondition( COND_STRIDER_SHOULD_STAND ) && !m_bCrouchLocked  && GetHeight() - GetMinHeight() < GetHeightRange() * .5 )

-	{

-		return SCHED_STRIDER_STAND;

-	}

-

-	if( HasCondition( COND_CAN_RANGE_ATTACK2 ) )

-	{

-		return SCHED_STRIDER_RANGE_ATTACK2;

-	}

-	else if( m_AttemptCannonLOSTimer.Expired() && HasCondition( COND_STRIDER_HAS_CANNON_TARGET ) )

-	{

-		m_AttemptCannonLOSTimer.Set( 5 );

-		return SCHED_STRIDER_ESTABLISH_LINE_OF_FIRE_CANNON;

-	}

-

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

-

-	if( m_NPCState == NPC_STATE_COMBAT )

-	{

-		if ( !HasCondition( COND_NEW_ENEMY ) )

-		{

-			if ( m_hRagdoll.Get() && (gpGlobals->curtime > m_ragdollTime  || HasCondition( COND_STRIDER_DO_FLICK ) ) )

-			{

-				return SCHED_STRIDER_FLICKL;

-			}

-		}

-

-		if ( HasCondition( COND_STRIDER_SHOULD_CROUCH ) )

-		{

-			return SCHED_STRIDER_CROUCH;

-		}

-

-		if ( HasCondition( COND_STRIDER_SHOULD_STAND ) )

-		{

-			return SCHED_STRIDER_STAND;

-		}

-		

-		if ( HasCondition( COND_CAN_MELEE_ATTACK1 ) )

-		{

-			return SCHED_MELEE_ATTACK1;

-		}

-		if ( HasCondition( COND_CAN_RANGE_ATTACK1 ) )

-		{

-			return SCHED_STRIDER_RANGE_ATTACK1;

-		}

-

-		ClearCondition( COND_STRIDER_ENEMY_UPDATED );

-		if ( !m_EnemyUpdatedTimer.Expired() )

-		{

-			int baseResult = BaseClass::SelectSchedule();

-			if ( baseResult != SCHED_COMBAT_FACE || !GetGoalEnt() )

-				return baseResult;

-		}

-

-		if ( !GetGoalEnt() )

-			return BaseClass::SelectSchedule();

-

-		return SCHED_STRIDER_HUNT;

-	}

-

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

-

-	if ( !GetGoalEnt() )

-		return SCHED_IDLE_STAND;

-

-	return SCHED_STRIDER_HUNT;

-}

-

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

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

-

-#define TIME_CARE_ENEMY 7.0

-

-int CNPC_Strider::TranslateSchedule( int scheduleType )

-{

-	switch( scheduleType )

-	{

-	case SCHED_RANGE_ATTACK1:

-		return SCHED_STRIDER_RANGE_ATTACK1;

-	case SCHED_RANGE_ATTACK2:

-		return SCHED_STRIDER_RANGE_ATTACK2;

-	case SCHED_MELEE_ATTACK1:

-		return SCHED_STRIDER_STOMPL;

-	case SCHED_MELEE_ATTACK2:

-		return SCHED_STRIDER_STOMPR;

-	case SCHED_CHASE_ENEMY:

-		{

-			if( HasCondition( COND_SEE_ENEMY ) )

-			{

-				return SCHED_STRIDER_COMBAT_FACE;

-			}

-

-			return SCHED_STRIDER_CHASE_ENEMY;

-		}

-

-	case SCHED_ESTABLISH_LINE_OF_FIRE:

-	case SCHED_ESTABLISH_LINE_OF_FIRE_FALLBACK:

-		if ( m_bNoMoveToLOS )

-		{

-			return SCHED_COMBAT_FACE;

-		}

-

-		if ( !m_bCrouchLocked )

-		{

-			if( IsInCrouchedPosture() )

-			{

-				if( m_pMinigun->IsShooting() )

-				{

-					// Don't stand yet.

-					return SCHED_STRIDER_COMBAT_FACE;

-				}

-			}

-			else if ( HasCondition( COND_STRIDER_HAS_LOS_Z ) && HasCondition( COND_SEE_ENEMY ) )

-			{

-				return SCHED_STRIDER_COMBAT_FACE;

-			}

-		}

-		if ( scheduleType == SCHED_ESTABLISH_LINE_OF_FIRE_FALLBACK )

-		{

-			if ( gpGlobals->curtime - GetEnemyLastTimeSeen() < TIME_CARE_ENEMY )

-				return SCHED_STRIDER_COMBAT_FACE;

-			else if ( GetGoalEnt() )

-				return SCHED_STRIDER_HUNT;

-			else

-			{

-				if( IsUsingAggressiveBehavior() )

-				{

-					return SCHED_STRIDER_AGGRESSIVE_COMBAT_STAND;

-				}

-

-				return SCHED_COMBAT_PATROL;

-			}

-		}

-

-		break;

-

-	case SCHED_COMBAT_FACE:

-		return SCHED_STRIDER_COMBAT_FACE;

-		break;

-	}

-

-	return BaseClass::TranslateSchedule( scheduleType );

-}

-

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

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

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

-{

-	switch ( pTask->iTask )

-	{

-	case TASK_GET_PATH_TO_ENEMY_LOS:

-		ChainStartTask( TASK_GET_PATH_TO_ENEMY_LKP_LOS, pTask->flTaskData );

-		break;

-

-	case TASK_STRIDER_FALL_TO_GROUND:

-		break;

-

-	case TASK_STRIDER_FIRE_CANNON:

-		FireCannon();

-		TaskComplete();

-		break;

-

-	case TASK_STRIDER_SET_CANNON_HEIGHT:

-		{

-			if ( m_hCannonTarget )

-				SetAbsIdealHeight( m_hCannonTarget->WorldSpaceCenter().z );

-			TaskComplete();

-		}

-		break;

-

-	case TASK_STRIDER_AIM:

-		{

-			// Stop the minigun for a bit, the big gun's about to shoot!

-			m_pMinigun->StopShootingForSeconds( this, m_pMinigun->GetTarget(), 5 );

-

-			//SetIdealActivity( (Activity)ACT_STRIDER_AIMRA1 );

-			SetWait( pTask->flTaskData );

-			m_aimYaw = 0;

-			m_aimPitch = 0;

-			// clear out the previous shooting

-			SetPoseParameter( gm_YawControl, m_aimYaw );

-			SetPoseParameter( gm_PitchControl, m_aimPitch );

-			Vector vecShootPos;

-			GetAttachment( gm_CannonAttachment, vecShootPos );

-		

-			// tell the client side effect to complete

-			EntityMessageBegin( this, true );

-				WRITE_BYTE( STRIDER_MSG_STREAKS );

-				WRITE_VEC3COORD( vecShootPos );

-			MessageEnd();

-			CPASAttenuationFilter filter2( this, "NPC_Strider.Charge" );

-			EmitSound( filter2, entindex(), "NPC_Strider.Charge" );

-

-			//	CPVSFilter filter( vecShootPos );

-			//te->StreakSphere( filter, 0, 0, 150, 100, entindex(), gm_CannonAttachment );

-		}

-		break;

-

-	case TASK_STRIDER_DODGE:

-		break;

-

-	case TASK_STRIDER_STOMP:

-		{

-			m_nextStompTime = gpGlobals->curtime + 5;

-			Activity stompAct = (Activity) ( pTask->flTaskData > 0 ? ACT_STRIDER_STOMPR : ACT_STRIDER_STOMPL );

-			ResetIdealActivity( stompAct );

-		}

-		break;

-

-	case TASK_RANGE_ATTACK1:

-		CBaseCombatWeapon *pWeapon;

-		pWeapon = GetActiveWeapon();

-

-		if( pWeapon )

-		{

-			pWeapon->PrimaryAttack();

-		}

-		else

-		{

-			TaskFail("no primary weapon");

-		}

-

-		TaskComplete();

-		break;

-

-	case TASK_STRIDER_BREAKDOWN:

-		SetIdealActivity( (Activity)ACT_STRIDER_SLEEP );

-		break;

-

-	case TASK_STRIDER_REFRESH_HUNT_PATH:

-		Assert( GetGoalEnt() );

-		if ( GetGoalEnt() )

-		{

-			AI_NavGoal_t goal(GOALTYPE_PATHCORNER, GetGoalEnt()->GetLocalOrigin(), ACT_WALK, AIN_DEF_TOLERANCE, AIN_YAW_TO_DEST);

-

-			TranslateNavGoal( GetGoalEnt(), goal.dest );

-

-			if ( ( m_debugOverlays & OVERLAY_NPC_SELECTED_BIT ) && ( m_debugOverlays & OVERLAY_NPC_ROUTE_BIT ) )

-			{

-				NDebugOverlay::Line( GetAbsOrigin() + Vector( 0, 0, 4), goal.dest, 255, 0, 255, true, 3 );

-			}

-

-			if ( GetNavigator()->SetGoal( goal ) )

-			{

-				TaskComplete();

-				break;

-			}

-			TaskFail( FAIL_NO_ROUTE );

-		}

-		break;

-

-	case TASK_STRIDER_START_MOVING:

-		TaskComplete();

-		break;

-

-	case TASK_STRIDER_GET_PATH_TO_CANNON_LOS:

-		{

-			if ( GetCannonTarget() == NULL )

-			{

-				TaskFail("No Cannon Target");

-				return;

-			}

-		

-			AI_PROFILE_SCOPE(CAI_BaseNPC_FindLosToEnemy);

-			Vector vecEnemy 	= GetCannonTarget()->WorldSpaceCenter();

-

-			float flMaxRange = 4096;

-			float flMinRange = 0;

-			

-			Vector posLos;

-			bool found = false;

-

-			if ( GetTacticalServices()->FindLateralLos( vecEnemy, &posLos ) )

-			{

-				found = true;

-			}

-

-			if ( !found && GetTacticalServices()->FindLos( vecEnemy, vecEnemy, flMinRange, flMaxRange, 1.0, &posLos ) )

-			{

-				found = true;

-			}

-

-			if ( found )

-			{

-				AI_NavGoal_t goal( posLos, ACT_RUN, AIN_HULL_TOLERANCE );

-

-				GetNavigator()->SetGoal( goal, AIN_CLEAR_TARGET );

-				GetNavigator()->SetArrivalDirection( vecEnemy - goal.dest );

-

-				// Add the cannon target as a high priority facing entity.

-				AddFacingTarget( GetCannonTarget(), GetCannonTarget()->WorldSpaceCenter(), 5.0, 5.0 );

-			}

-			else

-			{

-				TaskFail( "Can't get LOS to Cannon Target" );

-			}

-		}

-		break;

-

-	case TASK_STRIDER_GET_PATH_TO_CANNON_TARGET:

-		{

-			if( !m_hCannonTarget )

-			{

-				TaskFail( "No cannon target!\n" );

-				return;

-			}

-

-			AI_NavGoal_t goal( m_hCannonTarget->GetAbsOrigin() );

-

-			TranslateNavGoal( m_hCannonTarget, goal.dest );

-

-			if ( GetNavigator()->SetGoal( goal, AIN_CLEAR_TARGET ) )

-			{

-				TaskComplete();

-			}

-			else

-			{

-				DevWarning( 2, "GetPathToCannonTarget failed!!\n" );

-				TaskFail(FAIL_NO_ROUTE);

-			}

-		}

-		break;

-

-	case TASK_STRIDER_FACE_CANNON_TARGET:

-		if ( m_hCannonTarget != NULL )

-		{

-			GetMotor()->SetIdealYawToTarget( m_hCannonTarget->WorldSpaceCenter() );

-			SetTurnActivity(); 

-		}

-		else

-		{

-			TaskFail(FAIL_NO_TARGET);

-		}

-		break;

-		

-	case TASK_STRIDER_SET_HEIGHT:

-		SetIdealHeight( pTask->flTaskData );

-		TaskComplete();

-		break;

-

-	default:

-		BaseClass::StartTask( pTask );

-		break;

-	}

-}

-

-

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

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

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

-{

-	switch ( pTask->iTask )

-	{

-	case TASK_GET_PATH_TO_ENEMY_LOS:

-		ChainRunTask( TASK_GET_PATH_TO_ENEMY_LKP_LOS, pTask->flTaskData );

-		break;

-

-	case TASK_STRIDER_FALL_TO_GROUND:

-		{

-			// This doesn't work right now. (sjb)

-			Vector vecVelocity = GetAbsVelocity();

-

-			vecVelocity.z -= (GetCurrentGravity() * 0.1);

-

-			SetAbsVelocity( vecVelocity );

-

-			Vector pos = GetAbsOrigin();

-			TranslateNavGoal( NULL, pos );

-

-			if( GetAbsOrigin().z - pos.z <= 0.0f )

-			{

-				SetAbsVelocity( vec3_origin );

-				TaskComplete();

-			}

-		}

-		break;

-	

-	case TASK_STRIDER_AIM:

-		{

-			// BUGBUG: Need the real flInterval here, not just 0.1

-			AimCannonAt( GetCannonTarget(), 0.1 );

-			if ( IsWaitFinished() )

-			{

-				TaskComplete();

-			}

-		}

-		break;

-

-	case TASK_STRIDER_DODGE:

-		TaskComplete();

-		break;

-

-	case TASK_STRIDER_STOMP:

-		if ( IsActivityFinished() )

-		{

-			TaskComplete();

-		}

-		if ( GetEnemy() )

-		{

-			m_vecHitPos = CalculateStompHitPosition( GetEnemy() );

-		}

-		break;

-

-	case TASK_STRIDER_BREAKDOWN:

-		if ( IsActivityFinished() )

-		{

-			// UNDONE: Fix this bug!

-			//Assert(!IsMarkedForDeletion());

-			if ( !IsMarkedForDeletion() )

-			{

-				CTakeDamageInfo info;

-				CreateServerRagdoll( this, 0, info, COLLISION_GROUP_NONE );

-				TaskComplete();

-				UTIL_Remove(this);

-			}

-		}

-		break;

-

-	case TASK_STRIDER_FACE_CANNON_TARGET:

-   		GetMotor()->UpdateYaw();

-   		if ( FacingIdeal() )

-   		{

-   			TaskComplete();

-   		}

-   		break;

-

-	case TASK_PLAY_SEQUENCE:

-		if( m_bFastCrouch && pTask->flTaskData == ACT_CROUCH )

-		{

-			SetPlaybackRate( 10.0f );

-			if( IsSequenceFinished() )

-			{

-				m_bFastCrouch = false;

-			}

-		}

-

-		// Hack to make sure client doesn't pop after stand/crouch is done

-		if ( GetCycle() > 0.5 )

-		{

-			if ( IsStriderStanding() && GetHeight() != GetMaxHeight() )

-				SetHeight( GetMaxHeight() );

-			else if ( IsStriderCrouching() && GetHeight() != GetMinHeight() )

-				SetHeight( GetMinHeight() );

-			SetIdealHeight( GetHeight() );

-		}

-		BaseClass::RunTask( pTask );

-		break;

-

-	default:

-		BaseClass::RunTask( pTask );

-		break;		

-	}

-}

-

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

-// Purpose: 

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

-void CNPC_Strider::Explode( void )

-{

-	Vector			velocity = vec3_origin;

-	AngularImpulse	angVelocity = RandomAngularImpulse( -150, 150 );

-

-	// Break into pieces

-	breakablepropparams_t params( EyePosition(), GetAbsAngles(), velocity, angVelocity );

-	params.impactEnergyScale = 1.0f;

-	params.defBurstScale = 600.0f;

-	params.defCollisionGroup = COLLISION_GROUP_NPC;

-	PropBreakableCreateAll( GetModelIndex(), NULL, params, this, -1, true, true );

-

-	// Go away

-	m_lifeState = LIFE_DEAD;

-

-	SetThink( &CNPC_Strider::SUB_Remove );

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

-

-	AddEffects( EF_NODRAW );

-	

-	StopSmoking();

-

-	m_BoneFollowerManager.DestroyBoneFollowers();

-}

-

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

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

-bool CNPC_Strider::HandleInteraction( int interactionType, void *data, CBaseCombatCharacter* sourceEnt )

-{

-	if ( interactionType == g_interactionPlayerLaunchedRPG )

-	{

-		m_flTimePlayerMissileDetected = gpGlobals->curtime;

-		m_hPlayersMissile = sourceEnt;

-		return true;

-	}

-

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

-}

-

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

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

-void CNPC_Strider::HandleAnimEvent( animevent_t *pEvent )

-{

-	Vector footPosition;

-

-	switch( pEvent->event )

-	{

-	case STRIDER_AE_DIE:

-		{

-			Explode();

-		}

-		break;

-	case STRIDER_AE_SHOOTCANNON:

-		{

-			FireCannon();

-		}

-		break;

-	case STRIDER_AE_WINDUPCANNON:

-		{

-			AimCannonAt( GetCannonTarget(), 0.1 );

-

-			// Stop the minigun for a bit, the big gun's about to shoot!

-			m_pMinigun->StopShootingForSeconds( this, m_pMinigun->GetTarget(), 5 );

-

-			m_aimYaw = 0;

-			m_aimPitch = 0;

-

-			// clear out the previous shooting

-			SetPoseParameter( gm_YawControl, m_aimYaw );

-			SetPoseParameter( gm_PitchControl, m_aimPitch );

-			Vector vecShootPos;

-			GetAttachment( gm_CannonAttachment, vecShootPos );

-		

-			// tell the client side effect to start

-			EntityMessageBegin( this, true );

-				WRITE_BYTE( STRIDER_MSG_STREAKS );

-				WRITE_VEC3COORD( vecShootPos );

-			MessageEnd();

-			CPASAttenuationFilter filter2( this, "NPC_Strider.Charge" );

-			EmitSound( filter2, entindex(), "NPC_Strider.Charge" );

-		}

-		break;

-	case STRIDER_AE_CANNONHIT:

-		CreateConcussiveBlast( m_blastHit, m_blastNormal, this, 2.5 );

-		break;

-

-	case STRIDER_AE_SHOOTMINIGUN:

-	{

-		CBaseEntity *pTarget = gEntList.FindEntityGeneric( NULL, pEvent->options, this, this );

-		if ( pTarget )

-		{

-			Vector vecTarget = pTarget->CollisionProp()->WorldSpaceCenter();

-			ShootMinigun( &vecTarget, 0 );

-		}

-		break;

-	}

-

-	case STRIDER_AE_STOMPHITL:

-		StompHit( STRIDER_LEFT_LEG_FOLLOWER_INDEX );

-		break;

-	case STRIDER_AE_STOMPHITR:

-		StompHit( STRIDER_RIGHT_LEG_FOLLOWER_INDEX );

-		break;

-	case STRIDER_AE_FLICKL:

-	case STRIDER_AE_FLICKR:

-		{

-			CBaseEntity *pRagdoll = m_hRagdoll;

-			if ( pRagdoll )

-			{

-				CPASAttenuationFilter filter( pRagdoll, "NPC_Strider.RagdollDetach" );

-				EmitSound( filter, pRagdoll->entindex(), "NPC_Strider.RagdollDetach" );

-				DetachAttachedRagdoll( pRagdoll );

-			}

-			m_hRagdoll = NULL;

-		}

-		break;

-

-	case STRIDER_AE_FOOTSTEP_LEFT:

-	case STRIDER_AE_FOOTSTEP_LEFTM:

-	case STRIDER_AE_FOOTSTEP_LEFTL:

-		LeftFootHit( pEvent->eventtime );

-		break;

-	case STRIDER_AE_FOOTSTEP_RIGHT:

-	case STRIDER_AE_FOOTSTEP_RIGHTM:

-	case STRIDER_AE_FOOTSTEP_RIGHTL:

-		RightFootHit( pEvent->eventtime );

-		break;

-	case STRIDER_AE_FOOTSTEP_BACK:

-	case STRIDER_AE_FOOTSTEP_BACKM:

-	case STRIDER_AE_FOOTSTEP_BACKL:

-		BackFootHit( pEvent->eventtime );

-		break;

-	case STRIDER_AE_WHOOSH_LEFT:

-		{

-			GetAttachment( "left foot", footPosition );

-

-			CPASAttenuationFilter filter( this, "NPC_Strider.Whoosh" );

-			EmitSound( filter, 0, "NPC_Strider.Whoosh", &footPosition );

-		}

-		break;

-	case STRIDER_AE_WHOOSH_RIGHT:

-		{

-			GetAttachment( "right foot", footPosition );

-

-			CPASAttenuationFilter filter( this, "NPC_Strider.Whoosh" );

-			EmitSound( filter, 0, "NPC_Strider.Whoosh", &footPosition );

-		}

-		break;

-	case STRIDER_AE_WHOOSH_BACK:

-		{

-			GetAttachment( "back foot", footPosition );

-

-			CPASAttenuationFilter filter( this, "NPC_Strider.Whoosh" );

-			EmitSound( filter, 0, "NPC_Strider.Whoosh", &footPosition );

-		}

-		break;

-	case STRIDER_AE_CREAK_LEFT:

-	case STRIDER_AE_CREAK_BACK:

-	case STRIDER_AE_CREAK_RIGHT:

-		{

-			EmitSound( "NPC_Strider.Creak" );

-		}

-		break;

-	default:

-		BaseClass::HandleAnimEvent( pEvent );

-		break;

-	}

-}

-

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

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

-Disposition_t CNPC_Strider::IRelationType( CBaseEntity *pTarget )

-{

-	if ( IsCannonTarget( pTarget ) )

-		return D_HT;

-

-	return BaseClass::IRelationType( pTarget );

-}

-

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

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

-void CNPC_Strider::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_Strider::ScheduledMoveToGoalEntity( int scheduleType, CBaseEntity *pGoalEntity, Activity movementActivity )

-{

-	if ( IsCurSchedule( SCHED_STRIDER_RANGE_ATTACK2, false ) )

-	{

-		SetGoalEnt( pGoalEntity );

-		return true;

-	}

-	return BaseClass::ScheduledMoveToGoalEntity( scheduleType, pGoalEntity, movementActivity );

-}

-

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

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

-bool CNPC_Strider::ScheduledFollowPath( int scheduleType, CBaseEntity *pPathStart, Activity movementActivity )

-{

-	m_strTrackName = pPathStart->GetEntityName();

-	if ( IsCurSchedule( SCHED_STRIDER_RANGE_ATTACK2, false ) )

-	{

-		SetGoalEnt( pPathStart );

-		return true;

-	}

-	return BaseClass::ScheduledFollowPath( scheduleType, pPathStart, movementActivity );

-}

-

-

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

-// Disables the minigun until EnableMinigun input is received.

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

-void CNPC_Strider::InputDisableMinigun( inputdata_t &inputdata )

-{

-	m_bMinigunEnabled = false;

-	m_pMinigun->Enable( this, false );

-}

-

-

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

-// Enables the minigun.

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

-void CNPC_Strider::InputEnableMinigun( inputdata_t &inputdata )

-{

-	m_bMinigunEnabled = true;

-	m_pMinigun->Enable( this, true );

-}

-

-

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

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

-void CNPC_Strider::InputSetMinigunTime( inputdata_t &inputdata )

-{

-	m_miniGunShootDuration = inputdata.value.Float();

-	m_pMinigun->SetShootDuration( m_miniGunShootDuration );

-}

-

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

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

-void CNPC_Strider::InputSetMinigunTarget( inputdata_t &inputdata )

-{

-	CBaseEntity *pTargetEntity = gEntList.FindEntityByName( NULL, inputdata.value.String(), NULL, inputdata.pActivator, inputdata.pCaller );

-

-	m_pMinigun->StopShootingForSeconds( this, m_pMinigun->GetTarget(), 0 );

-	m_pMinigun->ShootAtTarget( this, pTargetEntity, m_miniGunShootDuration );

-	m_miniGunShootDuration = 0;

-}

-

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

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

-void CNPC_Strider::InputSetCannonTarget( inputdata_t &inputdata )

-{

-	CBaseEntity *pTarget = gEntList.FindEntityByName( NULL, inputdata.value.String(), NULL, inputdata.pActivator, inputdata.pCaller );

-

-	if ( pTarget )

-	{

-		if ( m_hCannonTarget == pTarget )

-			return;

-			

-		CAI_BaseNPC **ppAIs = g_AI_Manager.AccessAIs();

-		CNPC_Strider *pStrider;

-		for ( int i = 0; i < g_AI_Manager.NumAIs(); i++ )

-		{

-			if ( ppAIs[i] != this && ppAIs[i]->ClassMatches( GetClassname() ) )

-			{

-				pStrider = (CNPC_Strider *)(ppAIs[i]);

-				if ( pStrider->GetCannonTarget() == pTarget )

-					return; // Already accounted for

-			}

-		}

-

-		if( pTarget->MyCombatCharacterPointer() && pTarget->IsAlive() )

-		{

-			m_hCannonTarget = pTarget;

-			m_AttemptCannonLOSTimer.Force();

-			return;

-		}

-	}

-

-	m_hCannonTarget = NULL;

-}

-

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

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

-void CNPC_Strider::InputFlickRagdoll( inputdata_t &inputdata )

-{

-	if ( m_hRagdoll.Get() )

-	{

-		SetCondition( COND_STRIDER_DO_FLICK );

-	}

-}

-

-

-/*

-		IPhysicsObject *pPhysics0 = FindPhysicsObjectByName( STRING(m_nameAttach1), this );

-		IPhysicsObject *pPhysics1 = FindPhysicsObjectByName( STRING(m_nameAttach2), this );

-

-		if ( !pPhysics0 )

-		{

-			pPhysics0 = g_PhysWorldObject;

-		}

-		if ( !pPhysics1 )

-		{

-			pPhysics1 = g_PhysWorldObject;

-		}

-

-		if ( pPhysics0 != pPhysics1 )

-		{

-			m_disabled = !bEnable;

-			m_succeeded = true;

-			if ( bEnable )

-			{

-				PhysEnableEntityCollisions( pPhysics0, pPhysics1 );

-			}

-			else

-			{

-				PhysDisableEntityCollisions( pPhysics0, pPhysics1 );

-			}

-		}

-		else

-		{

-			m_succeeded = false;

-		}

-*/

-/*

-#pragma warning(push)

-#pragma warning(disable : 4706) // I know what I'm doing

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

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

-void CNPC_Strider::InputDisableCollisionWith( inputdata_t &inputdata )

-{

-	IPhysicsObject *pIgnorePhys  = FindPhysicsObjectByName( inputdata.value.String(), this );

-	if ( !pIgnorePhys )

-		return;

-

-	int idx;

-	CBoneFollower *pFol;

-

-	for (idx = 0 ; pFol = GetBoneFollowerByIndex(idx) ; ++idx) // stop when the function starts returning null (idx is no longer good)

-	{

-		IPhysicsObject *pFollowPhys = pFol->VPhysicsGetObject();

-		Assert(pFollowPhys);

-		PhysDisableEntityCollisions( pIgnorePhys, pFollowPhys );

-	}

-}

-#pragma warning(pop)

-*/

-

-

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

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

-void CNPC_Strider::InputDisableCollisionWith( inputdata_t &inputdata )

-{

-	IPhysicsObject *pIgnorePhys  = FindPhysicsObjectByName( inputdata.value.String(), this );

-	if ( !pIgnorePhys )

-		return;

-

-	

-	// CBoneFollower *pFol;

-

-	for (int idx = m_BoneFollowerManager.GetNumBoneFollowers() - 1 ; idx >= 0 ; --idx) // stop when the function starts returning null (idx is no longer good)

-	{

-		IPhysicsObject *pFollowPhys = GetBoneFollowerByIndex(idx)->VPhysicsGetObject();

-		Assert(pFollowPhys);

-		PhysDisableEntityCollisions( pIgnorePhys, pFollowPhys );

-	}

-}

-

-

- 

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

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

-void CNPC_Strider::InputEnableCollisionWith( inputdata_t &inputdata )

-{

-	IPhysicsObject *pIgnorePhys  = FindPhysicsObjectByName( inputdata.value.String(), this );

-	if ( !pIgnorePhys )

-		return;

-

-	int idx;

-	// CBoneFollower *pFol;

-

-	for (idx = m_BoneFollowerManager.GetNumBoneFollowers() - 1 ; idx >= 0 ; --idx) // stop when the function starts returning null (idx is no longer good)

-	{

-		/*

-		pFol = GetBoneFollowerByIndex(idx);

-		Assert(pFol);

-		IPhysicsObject *pFollowPhys = pFol->VPhysicsGetObject();

-		Assert(pFollowPhys);

-		*/

-		IPhysicsObject *pFollowPhys = GetBoneFollowerByIndex(idx)->VPhysicsGetObject();

-		PhysEnableEntityCollisions( pIgnorePhys, pFollowPhys );

-	}

-} 

-

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

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

-void CNPC_Strider::InputCrouch( inputdata_t &inputdata )

-{

-	if ( !IsCurSchedule( SCHED_STRIDER_CROUCH ) && !IsInCrouchedPosture() )

-		SetCondition( COND_STRIDER_SHOULD_CROUCH );

-	m_bCrouchLocked = true;

-}

-

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

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

-void CNPC_Strider::InputCrouchInstantly( inputdata_t &inputdata )

-{

-	if ( !IsCurSchedule( SCHED_STRIDER_CROUCH ) && !IsInCrouchedPosture() )

-	{

-		m_bFastCrouch = true;

-		SetCondition( COND_STRIDER_SHOULD_CROUCH );

-	}

-	m_bCrouchLocked = true;

-}

-

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

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

-void CNPC_Strider::InputStand( inputdata_t &inputdata )

-{

-	if ( !IsCurSchedule( SCHED_STRIDER_STAND ) && !IsInStandingPosture() )

-		SetCondition( COND_STRIDER_SHOULD_STAND );

-	m_bCrouchLocked = false;

-}

-

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

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

-void CNPC_Strider::InputSetHeight( inputdata_t &inputdata )

-{

-	SetIdealHeight( inputdata.value.Float() );

-}

-

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

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

-void CNPC_Strider::InputSetTargetPath( inputdata_t &inputdata )

-{

-	m_strTrackName = MAKE_STRING( inputdata.value.String() );

-	SetGoalEnt( NULL );

-

-	if( !IsStriderCrouching() && !IsStriderStanding() && !IsInCrouchedPosture() )

-	{

-		SetTargetPath();

-	}

-

-	// Otherwise, we just leave the track name set and the AI will

-	// get to it as soon as possible (as soon as the strider can be

-	// made to stand).

-}

-

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

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

-void CNPC_Strider::InputClearTargetPath( inputdata_t &inputdata )

-{

-	if (GetNavigator()->IsGoalActive() && GetNavigator()->GetGoalType() == GOALTYPE_PATHCORNER )

-	{

-		GetNavigator()->ClearGoal();

-		ClearSchedule( "Target path cleared via input" );

-	}

-	m_strTrackName = MAKE_STRING( STRIDER_NO_TRACK_NAME );

-	SetGoalEnt(NULL);

-}

-

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

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

-void CNPC_Strider::InputDisableCrouchWalk( inputdata_t &inputdata )

-{

-	m_bNoCrouchWalk = true;

-}

-

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

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

-void CNPC_Strider::InputEnableCrouchWalk( inputdata_t &inputdata )

-{

-	m_bNoCrouchWalk = false;

-}

-

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

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

-void CNPC_Strider::InputEnableAggressiveBehavior( inputdata_t &inputdata )

-{

-	m_bUseAggressiveBehavior = true;

-	GetEnemies()->SetEnemyDiscardTime( 601.0f );	// Make the assert in SetFreeKnowledgeDuration() happy.

-	GetEnemies()->SetFreeKnowledgeDuration( 600.0f );

-

-	AI_FreePassParams_t params = m_PlayerFreePass.GetParams();

-	params.duration = 0.8f;

-	params.coverDist = 1200.0f;

-	m_PlayerFreePass.SetParams( params );

-

-	GetTacticalServices()->AllowFindLateralLos( false );

-}

-

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

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

-void CNPC_Strider::InputDisableAggressiveBehavior( inputdata_t &inputdata )

-{

-	m_bUseAggressiveBehavior = false;

-	GetEnemies()->SetFreeKnowledgeDuration( strider_free_knowledge.GetFloat() );

-	GetEnemies()->SetEnemyDiscardTime( AI_DEF_ENEMY_DISCARD_TIME );

-

-	AI_FreePassParams_t params = m_PlayerFreePass.GetParams();

-	params.duration = strider_free_pass_duration.GetFloat();

-	params.coverDist = strider_free_pass_cover_dist.GetFloat();

-	m_PlayerFreePass.SetParams( params );

-

-	GetTacticalServices()->AllowFindLateralLos( true );

-}

-

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

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

-void CNPC_Strider::InputStopShootingMinigunForSeconds( inputdata_t &inputdata )

-{

-	m_pMinigun->StopShootingForSeconds( this, NULL, inputdata.value.Float() );

-}

-

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

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

-void CNPC_Strider::InputDisableCrouch( inputdata_t &inputdata )

-{

-	m_bDontCrouch = true;

-}

-

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

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

-void CNPC_Strider::InputDisableMoveToLOS( inputdata_t &inputdata )

-{

-	m_bNoMoveToLOS = true;

-}

-

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

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

-void CNPC_Strider::InputExplode( inputdata_t &inputdata )

-{

-	CTakeDamageInfo killInfo;

-	killInfo.SetAttacker( this );

-	killInfo.SetInflictor( this );

-	killInfo.SetDamage( GetHealth() );

-	TakeDamage( killInfo );

-}

-

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

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

-void CNPC_Strider::InputScaleGroundSpeed( inputdata_t &inputdata )

-{

-	m_flTargetSpeedScale = inputdata.value.Float();

-}

-

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

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

-bool CNPC_Strider::FVisible( CBaseEntity *pEntity, int traceMask, CBaseEntity **ppBlocker )

-{

-	bool bIsVisible = BaseClass::FVisible( pEntity, traceMask, ppBlocker );

-	

-	if ( bIsVisible && pEntity == m_PlayerFreePass.GetPassTarget() )

-	{

-		bIsVisible = m_PlayerFreePass.ShouldAllowFVisible( bIsVisible );

-

-		if( !bIsVisible && IsUsingAggressiveBehavior() && FInViewCone(pEntity) )

-		{

-			AlertSound();

-		}

-	}

-

-	return bIsVisible;

-}

-

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

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

-Vector CNPC_Strider::BodyTarget( const Vector &posSrc, bool bNoisy )

-{

-	if ( m_BodyTargetBone != -1 )

-	{

-		Vector position;

-		QAngle angles;

-		GetBonePosition( m_BodyTargetBone, position, angles );

-		return position;

-	}

-	return BaseClass::BodyTarget( posSrc, bNoisy );

-}

-

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

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

-bool CNPC_Strider::IsValidEnemy( CBaseEntity *pTarget )

-{

-	if ( HasCannonTarget() )

-	{

-		return IsCannonTarget(pTarget);

-	}

-

-	if ( pTarget->IsPlayer() )

-	{

-		if ( AIGetNumFollowers( this, m_iszHunterClassname ) > 0 )

-			return false;

-	}

-

-	CBaseCombatCharacter *pEnemy = ToBaseCombatCharacter( pTarget );

-	if ( pEnemy )

-	{

-		// Test our enemy filter

-		if ( m_hEnemyFilter.Get()!= NULL && m_hEnemyFilter->PassesFilter( this, pEnemy ) == false )

-			return false;

-

-		return true;

-	}

-

-	return BaseClass::IsValidEnemy( pTarget );

-}

-

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

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

-bool CNPC_Strider::UpdateEnemyMemory( CBaseEntity *pEnemy, const Vector &position, CBaseEntity *pInformer )

-{

-	if( pInformer && FClassnameIs( pInformer, "npc_cscanner" ) )

-	{

-		EmitSound( "NPC_Strider.Alert" );

-		// Move Strider's focus to this location and make strider mad at it

-		// (but less mad than at any other potential entities in the scene).

-#if 1

-		GetFocus()->SetAbsOrigin( position + Vector( 0, 0, 32 ) );

-#else

-		trace_t tr;

-		AI_TraceLine( EyePosition(), position + Vector( 0, 0, 32 ), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );

-		GetFocus()->SetAbsOrigin( tr.endpos );

-#endif

-

-		SetCondition( COND_STRIDER_ENEMY_UPDATED );

-

-		m_EnemyUpdatedTimer.Set( 20 );

-

-		AddEntityRelationship( GetFocus(), D_HT, -1 );

-

-		if( pEnemy->IsPlayer() )

-		{

-			m_PlayerFreePass.Revoke();

-		}

-		

-		BaseClass::UpdateEnemyMemory( GetFocus(), GetFocus()->GetAbsOrigin(), pInformer );

-

-		// Change the informer to myself so that information provided by a scanner is 

-		// as good as firsthand knowledge insofar as enemy memory is concerned.

-		pInformer = this;

-	}

-

-	return BaseClass::UpdateEnemyMemory( pEnemy, position, pInformer );

-}

-

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

-// HACKHACK: The base class looks at distance from the head of the strider

-// But when stomping, we need distance from the feet.  Recompute it here.

-// UNDONE: make enemy distance aware of strider

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

-float CNPC_Strider::StriderEnemyDistance( CBaseEntity *pEnemy )

-{

-	Vector enemyDelta = pEnemy->WorldSpaceCenter() - WorldSpaceCenter();

-	

-	// NOTE: We ignore rotation for computing height.  Assume it isn't an effect

-	// we care about, so we simply use OBBSize().z for height.  

-	// Otherwise you'd do this:

-	// float enemyHeight = enemyMaxs.z - enemyMins.z;

-

-	float enemyHeight = pEnemy->CollisionProp()->OBBSize().z;

-	Vector striderSurroundMins, striderSurroundMaxs;

-	CollisionProp()->WorldSpaceSurroundingBounds( &striderSurroundMins, &striderSurroundMaxs );

-	float myHeight = striderSurroundMaxs.z - striderSurroundMins.z;

-	

-	// max distance our centers can be apart with the boxes still overlapping

-	float flMaxZDist = ( enemyHeight + myHeight ) * 0.5f;

-

-	// see if the enemy is closer to my head, feet or in between

-	if ( enemyDelta.z > flMaxZDist )

-	{

-		// enemy feet above my head, compute distance from my head to his feet

-		enemyDelta.z -= flMaxZDist;

-	}

-	else if ( enemyDelta.z < -flMaxZDist )

-	{

-		// enemy head below my feet, return distance between my feet and his head

-		enemyDelta.z += flMaxZDist;

-	}

-	else

-	{

-		// boxes overlap in Z, no delta

-		enemyDelta.z = 0;

-	}

-

-	return enemyDelta.Length();

-}

-

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

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

-bool CNPC_Strider::FCanCheckAttacks()

-{

-	// Strider has direct and indirect attacks, so he's always checking

-	// as long as the enemy is in front of him.

-	if( FInViewCone( GetEnemy() ) )

-	{

-		return true;

-	}

-

-	return false;

-}

-

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

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

-int CNPC_Strider::RangeAttack2Conditions( float flDot, float flDist )

-{

-	// All of this code has moved to GatherConditions(), since the 

-	// strider uses the cannon on things that aren't the enemy!

-	return COND_NONE;

-}

-

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

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

-int CNPC_Strider::MeleeAttack1Conditions( float flDot, float flDist )

-{

-	if ( m_bDisableBoneFollowers )

-	{

-		return COND_NONE;

-	}

-

-	if (gpGlobals->curtime < m_nextStompTime)

-	{

-		return COND_NONE;

-	}

-

-	if ( IsInCrouchedPosture() )

-	{

-		return COND_NONE;

-	}

-

-	CBaseEntity *pEnemy = GetEnemy();

-	if ( !pEnemy )

-		return COND_NONE;

-

-	// No more stabbing players.

-	if ( pEnemy->IsPlayer() && !HasSpawnFlags(SF_CAN_STOMP_PLAYER) )

-		return COND_NONE;

-

-	if( !HasCondition( COND_SEE_ENEMY ) )

-	{

-		return COND_NONE;

-	}

-

-	// recompute this because the base class function does not work for the strider

-	flDist = StriderEnemyDistance( pEnemy );

-	

-	if ( flDist > STRIDER_STOMP_RANGE )

-	{

-		return COND_NONE;

-	}

-

-	// strider will cross his feet, but only 6ft over

-	Vector right;

-	GetVectors( NULL, &right, NULL );

-	if ( DotProduct( pEnemy->GetAbsOrigin() - GetAbsOrigin(), right ) > 72 )

-	{

-		return COND_NONE;

-	}

-

-	// Don't skewer if crouched too low.

-	if( GetHeight() < GetMaxHeight() - ( (GetMaxHeight()-GetMinHeight()) / 2 ) )

-	{

-		return COND_NONE;

-	}

-

-	// Don't skewer if target is too high above or below ground.

-	Vector vecGround = GetAbsOrigin();

-	MoveToGround( &vecGround, this, Vector( -16, -16, -16 ), Vector( 16, 16, 16 ) );

-	if( fabs( vecGround.z - GetEnemy()->GetAbsOrigin().z ) > 64.0f )

-	{

-		return COND_NONE;

-	}

-

-	// too far, but don't change schedules/movement

-	return COND_CAN_MELEE_ATTACK1;

-}

-

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

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

-int CNPC_Strider::MeleeAttack2Conditions( float flDot, float flDist )

-{

-	// HACKHACK: Disabled until we get a good right-leg animation

-	return COND_NONE;

-}

-

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

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

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

-{

-	CBaseEntity *pTargetEnt;

-	Vector vRootOffset;

-	Vector vBarrelOffset;

-

-	vRootOffset.x = vRootOffset.y = 0;

-	if ( GetCannonTarget() )

-	{

-		//Assert( targetPos == GetCannonTarget()->GetAbsOrigin() );

-		pTargetEnt = GetCannonTarget();

-		vRootOffset.z = gm_zCannonDist;

-		vBarrelOffset = gm_vLocalRelativePositionCannon;

-	}

-	else

-	{

-		pTargetEnt = GetEnemy();

-		vRootOffset.z = gm_zMinigunDist;

-		vBarrelOffset = gm_vLocalRelativePositionMinigun;

-	}

-

-	trace_t tr;

-	AI_TraceLine( ownerPos + vRootOffset, targetPos, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);

-

-	// Hit the enemy, or hit nothing (traced all the way to a nonsolid enemy like a bullseye)

-	if ( ( pTargetEnt && tr.m_pEnt == pTargetEnt) || tr.fraction == 1.0 || CanShootThrough( tr, targetPos ) )

-	{

-		Vector vBarrelPos;

-		matrix3x4_t losTestToWorld;

-

-		Vector xaxis;

-		VectorSubtract( targetPos, ownerPos, xaxis );

-

-		// @TODO (toml 03-07-04): Add an angle test

-		//float flAngle = acos( xaxis.z / xaxis.Length() );

-

-		xaxis.z = 0.0f;

-		float flLength = VectorNormalize( xaxis );

-		if ( flLength < 1e-3 )

-			return false;

-

-		Vector yaxis( -xaxis.y, xaxis.x, 0.0f );

-

-		MatrixInitialize( losTestToWorld, ownerPos, xaxis, yaxis, Vector(0,0,1) );

-

-		VectorTransform( vBarrelOffset, losTestToWorld, vBarrelPos );

-

-		AI_TraceLine( vBarrelPos, targetPos, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);

-		if ( ( pTargetEnt && tr.m_pEnt == pTargetEnt) || tr.fraction == 1.0 || CanShootThrough( tr, targetPos ) )

-		{

-			if ( strider_show_weapon_los_condition.GetBool() )

-			{

-				NDebugOverlay::Line( ownerPos + vRootOffset, targetPos, 255, 0, 255, false, 0.1 );

-				NDebugOverlay::Line( vBarrelPos, targetPos, 128, 0, 128, false, 0.1 );

-			}

-			return true;

-		}

-		else

-		{

-			if ( strider_show_weapon_los_condition.GetBool() )

-			{

-				NDebugOverlay::Line( ownerPos + vRootOffset, targetPos, 255, 0, 255, false, 0.1 );

-				NDebugOverlay::Line( vBarrelPos, tr.endpos, 128, 0, 0, false, 0.1 );

-			}

-		}

-	}

-	else

-	{

-		if ( strider_show_weapon_los_condition.GetBool() )

-		{

-			NDebugOverlay::Line( ownerPos + vRootOffset, tr.endpos, 255, 0, 0, false, 0.1 );

-		}

-	}

-

-	return false;

-}

-

-

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

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

-bool CNPC_Strider::CurrentWeaponLOSCondition(const Vector &targetPos, bool bSetConditions)

-{

-	return WeaponLOSCondition( GetAdjustedOrigin(), targetPos, bSetConditions );

-}

-

-

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

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

-bool CNPC_Strider::IsValidShootPosition( const Vector &vecCoverLocation, CAI_Node *pNode, CAI_Hint const *pHint )

-{

-	if ( ( pNode && !pHint ) || ( pHint && pHint->HintType() != HINT_STRIDER_NODE ) )

-		return false;

-	return BaseClass::IsValidShootPosition( vecCoverLocation, pNode, pHint );

-}

-

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

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

-bool CNPC_Strider::TestShootPosition(const Vector &vecShootPos, const Vector &targetPos )	

-{ 

-	if ( BaseClass::TestShootPosition( vecShootPos, targetPos ) )

-	{

-		return true;

-	}

-

-	// What if I crouched?

-	float zDelta = ( ( vecShootPos.z - targetPos.z ) + gm_vLocalRelativePositionMinigun.z ) - 12;

-	if ( zDelta > 0 )

-	{

-		if ( zDelta > GetHeightRange() )

-			zDelta = GetHeightRange();

-

-		Vector vecTestPos = vecShootPos;

-		vecTestPos.z -= zDelta;

-

-		if ( BaseClass::TestShootPosition( vecTestPos, targetPos ) )

-		{

-			return true;

-		}

-	}

-	return false;

-}

-

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

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

-Vector CNPC_Strider::Weapon_ShootPosition( )

-{

-	Vector vecShootPos;

-	GetAttachment( gm_CannonAttachment, vecShootPos );

-

-	return vecShootPos;

-}

-

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

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

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

-{

-	float flTracerDist;

-	Vector vecDir;

-	Vector vecEndPos;

-

-	vecDir = tr.endpos - vecTracerSrc;

-

-	flTracerDist = VectorNormalize( vecDir );

-

-	UTIL_Tracer( vecTracerSrc, tr.endpos, 0, TRACER_DONT_USE_ATTACHMENT, 5000, true, "StriderTracer" );

-}

-

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

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

-void CNPC_Strider::DoImpactEffect( trace_t &tr, int nDamageType )

-{

-	BaseClass::DoImpactEffect( tr, nDamageType );

-

-	// Add a halo

-	CBroadcastRecipientFilter filter;

-	te->BeamRingPoint( filter, 0.0, 

-		tr.endpos,							//origin

-		0,									//start radius

-		64,									//end radius

-		s_iImpactEffectTexture,				//texture

-		0,									//halo index

-		0,									//start frame

-		0,									//framerate

-		0.2,								//life

-		10,									//width

-		0,									//spread

-		0,									//amplitude

-		255,								//r

-		255,								//g

-		255,								//b

-		50,									//a

-		0,									//speed

-		FBEAM_FADEOUT

-		);

-

-	g_pEffects->EnergySplash( tr.endpos, tr.plane.normal );

-	

-	// Punch the effect through?

-	if( tr.m_pEnt && !tr.m_pEnt->MyNPCPointer() )

-	{

-		Vector vecDir = tr.endpos - tr.startpos;

-		VectorNormalize( vecDir );

-

-		trace_t retrace;

-

-		Vector vecReTrace = tr.endpos + vecDir * 12;

-

-		if( UTIL_PointContents( vecReTrace ) == CONTENTS_EMPTY )

-		{

-			AI_TraceLine( vecReTrace, vecReTrace - vecDir * 24, MASK_SHOT, NULL, COLLISION_GROUP_NONE, &retrace );

-

-			BaseClass::DoImpactEffect( retrace, nDamageType );

-		}

-	}

-}

-

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

-// Trace didn't hit the intended target, but should the strider

-// shoot anyway? We use this to get the strider to destroy 

-// breakables that are between him and his target.

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

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

-{

-	if( GetCannonTarget() )

-	{

-		// Cannon does not have this behavior.

-		return false;

-	}

-

-	if( !tr.m_pEnt )

-	{

-		return false;

-	}

-

-	if( !tr.m_pEnt->GetHealth() )

-	{

-		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;

-}

-

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

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

-void CNPC_Strider::CreateFocus()

-{

-	m_hFocus = CreateEntityByName( "bullseye_strider_focus" );

-

-	ASSERT( m_hFocus != NULL );

-	m_hFocus->AddSpawnFlags( SF_BULLSEYE_NONSOLID | SF_BULLSEYE_NODAMAGE );

-	m_hFocus->SetAbsOrigin( GetAbsOrigin() );

-	m_hFocus->Spawn();

-}

-

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

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

-CNPC_Bullseye *CNPC_Strider::GetFocus()

-{

-	ASSERT( m_hFocus != NULL );

-

-	CNPC_Bullseye *pBull = dynamic_cast<CNPC_Bullseye*>(m_hFocus.Get());

-

-	return pBull;

-}

-

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

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

-bool CNPC_Strider::GetWeaponLosZ( const Vector &vOrigin, float minZ, float maxZ, float increment, CBaseEntity *pTarget, float *pResult )

-{

-	Vector vTestPos;

-	Vector vTargetPos = pTarget->BodyTarget(vOrigin, false);

-	Vector vIncrement( 0, 0, increment );

-

-	// Try right where am

-	if ( vOrigin.z >= minZ && vOrigin.z <= maxZ )

-	{

-		vTestPos = vOrigin;

-		if ( WeaponLOSCondition( vTestPos, vTargetPos, false ) )

-		{

-			if ( strider_show_weapon_los_z.GetBool() )

-				NDebugOverlay::Line( vTestPos, vTargetPos, 0, 255, 0, false, 0.1 );

-			*pResult = vTestPos.z;

-			return true;

-		}

-	}

-

-	// Try at adjusted height of target

-	vTestPos.z = ( vTargetPos.z - gm_vLocalRelativePositionMinigun.z ) + 12;

-

-	if ( vTestPos.z >= minZ && vTestPos.z <= maxZ )

-	{

-		if ( WeaponLOSCondition( vTestPos, vTargetPos, false ) )

-		{

-			if ( strider_show_weapon_los_z.GetBool() )

-				NDebugOverlay::Line( vTestPos, vTargetPos, 0, 255, 0, false, 0.1 );

-			*pResult = vTestPos.z;

-			return true;

-		}

-	}

-	

-

-	// Try at max height

-	vTestPos.z = maxZ;

-	if ( WeaponLOSCondition( vTestPos, vTargetPos, false ) )

-	{

-		if ( strider_show_weapon_los_z.GetBool() )

-			NDebugOverlay::Line( vOrigin, vTargetPos, 0, 255, 0, false, 0.1 );

-		*pResult = vTestPos.z;

-		return true;

-	}

-

-	// Try min height

-	vTestPos.z = minZ;

-	if ( WeaponLOSCondition( vTestPos, vTargetPos, false ) )

-	{

-		if ( strider_show_weapon_los_z.GetBool() )

-			NDebugOverlay::Line( vTestPos, vTargetPos, 0, 255, 0, false, 0.1 );

-		*pResult = vTestPos.z;

-		return true;

-	}

-	

-	// Test up from min

-	vTestPos = vOrigin + vIncrement;

-	while ( vTestPos.z <= maxZ && !WeaponLOSCondition( vTestPos, vTargetPos, false ) )

-	{

-		vTestPos += vIncrement;

-	}

-	

-	if ( vTestPos.z <= maxZ )

-	{

-		if ( strider_show_weapon_los_z.GetBool() )

-			NDebugOverlay::Line( vTestPos, vTargetPos, 0, 255, 0, false, 0.1 );

-		*pResult = vTestPos.z;

-		return true;

-	}

-

-	// Test down

-	vTestPos = vOrigin - vIncrement;

-	while ( vTestPos.z >= minZ && !WeaponLOSCondition( vTestPos, vTargetPos, false ) )

-	{

-		vTestPos -= vIncrement;

-	}

-	

-	if ( vTestPos.z >= minZ )

-	{

-		if ( strider_show_weapon_los_z.GetBool() )

-			NDebugOverlay::Line( vTestPos, vTargetPos, 0, 255, 0, false, 0.1 );

-		*pResult = vTestPos.z;

-		return true;

-	}

-		

-	return false;

-}

-

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

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

-void CNPC_Strider::AlertSound()

-{

-	if( ( gpGlobals->curtime - m_flTimeLastAlertSound ) > 2.0f )

-	{

-		EmitSound( "NPC_Strider.Alert" );

-		m_flTimeLastAlertSound = gpGlobals->curtime;

-	}

-}

-

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

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

-void CNPC_Strider::PainSound( const CTakeDamageInfo &info )

-{

-	// This means that we've exploded into pieces and have no way to whimper

-	if ( ShouldExplodeFromDamage( info ) )

-		return;

-

-	EmitSound( "NPC_Strider.Pain" );

-}

-

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

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

-void CNPC_Strider::DeathSound( const CTakeDamageInfo &info )

-{

-	// This means that we've exploded into pieces and have no way to whimper

-	if ( m_bExploding )

-	{

-		EmitSound( "NPC_Strider.StriderBusterExplode" );

-		EmitSound( "explode_5" );

-		return;

-	}

-

-	EmitSound( "NPC_Strider.Death" );

-}

-

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

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

-void CNPC_Strider::HuntSound()

-{

-	if( m_PlayerFreePass.HasPass() )

-	{

-		EmitSound( "NPC_Strider.Hunt" );

-		m_flTimeNextHuntSound = gpGlobals->curtime + random->RandomFloat( 8.0f, 12.0f );

-	}

-}

-

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

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

-void CNPC_Strider::TraceAttack( const CTakeDamageInfo &inputInfo, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )

-{

-	CTakeDamageInfo info = inputInfo;

-

-	bool ricochetBullets = true;

-

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

-	{

-		if ( !HasMemory( bits_MEMORY_PROVOKED ) )

-		{

-			GetEnemies()->ClearMemory( info.GetAttacker() );

-			Remember( bits_MEMORY_PROVOKED );

-			SetCondition( COND_LIGHT_DAMAGE );

-		}

-	}

-

-#ifdef HL2_EPISODIC

-

-	// Attempt to hit strider busters in the area

-	float flDistSqr;

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

-	{

-		if ( m_hAttachedBusters[i] == NULL )

-			continue;

-

-		flDistSqr = ( m_hAttachedBusters[i]->WorldSpaceCenter() - inputInfo.GetDamagePosition() ).LengthSqr();

-		if ( flDistSqr < Square( 50.0f ) )

-		{

-			// Kill the buster and stop the trace going through

-			CTakeDamageInfo killInfo = inputInfo;

-			killInfo.SetDamage( 100 );

-

-			m_hAttachedBusters[i]->TakeDamage( killInfo );

-			return;

-		}

-	}

-

-#endif	//HL2_EPISODIC

-

-	if ( (info.GetDamageType() & DMG_BULLET) && ricochetBullets )

-	{

-		g_pEffects->Ricochet(ptr->endpos,ptr->plane.normal);

-		if ( ptr->hitgroup != HITGROUP_HEAD )

-		{

-			info.SetDamage( 0.01 );

-		}

-	}

-

-	BaseClass::TraceAttack( info, vecDir, ptr, pAccumulator );

-}

-

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

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

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

-{

-	// don't take damage from my own weapons!!!

-	if ( info.GetInflictor() && info.GetInflictor()->GetOwnerEntity() == this )

-		return 0;

-

-	// special interaction with combine balls

-	if ( UTIL_IsCombineBall( info.GetInflictor() ) )

-		return TakeDamageFromCombineBall( info );

-

-	if ( info.GetDamageType() == DMG_GENERIC )

-		return BaseClass::OnTakeDamage_Alive( info );

-

-	if( IsUsingAggressiveBehavior() )

-	{

-		// Any damage the player inflicts gets my attention, even if it doesn't actually harm me.

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

-		{

-			UpdateEnemyMemory( info.GetAttacker(), info.GetAttacker()->GetAbsOrigin() );

-		}

-	}

-

-	//int healthIncrement = 5 - ( m_iHealth / ( m_iMaxHealth / 5 ) );

-	if ( (info.GetDamageType() & DMG_BLAST) && info.GetMaxDamage() > 50 )

-	{

-		Vector headPos = BodyTarget( info.GetDamagePosition(), false );

-		

-		float dist = CalcDistanceToAABB( WorldAlignMins(), WorldAlignMaxs(), info.GetDamagePosition() - headPos );

-		// close enough to do damage?

-		if ( dist < 200 )

-		{

-			bool bPlayer = info.GetAttacker()->IsPlayer();

-			if ( bPlayer )

-			{

-				m_PlayerFreePass.Revoke();

-				AddFacingTarget( info.GetAttacker(), info.GetAttacker()->GetAbsOrigin(), 1.0, 2.0 );

-

-				UpdateEnemyMemory( info.GetAttacker(), info.GetAttacker()->GetAbsOrigin() );

-			}

-			else

-				AddFacingTarget( info.GetAttacker(), info.GetAttacker()->GetAbsOrigin(), 0.5, 2.0 );

-

-			// Default to NPC damage value

-			int damage = 20;

-

-			if( HasSpawnFlags(SF_TAKE_MINIMAL_DAMAGE_FROM_NPCS) )

-				damage = 1;

-

-			if( bPlayer )

-			{

-				if( g_pGameRules->IsSkillLevel(SKILL_EASY) )

-				{

-					damage = GetMaxHealth() / sk_strider_num_missiles1.GetFloat();

-				}

-				else if( g_pGameRules->IsSkillLevel(SKILL_HARD) )

-				{

-					damage = GetMaxHealth() / sk_strider_num_missiles3.GetFloat();

-				}

-				else // Medium, or unspecified

-				{

-					damage = GetMaxHealth() / sk_strider_num_missiles2.GetFloat();

-				}

-			}

-

-			m_iHealth -= damage;

-

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

-

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

-			{

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

-

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

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

-			}

-			else

-			{

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

-				CAI_BaseNPC *pAttacker = dynamic_cast<CAI_BaseNPC *>( info.GetAttacker() );

-				CBasePlayer *pPlayer = AI_GetSinglePlayer();

-

-				if( pAttacker && pAttacker->IsAlive() && pPlayer )

-				{

-					if( pAttacker->GetSquad() != NULL && pAttacker->IsInPlayerSquad() )

-					{

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

-					}

-				}

-			}

-

-			if ( m_iHealth <= ( m_iMaxHealth / 2 ) )

-			{

-				m_OnHalfHealth.FireOutput(this, this);

-			}

-

-			RestartGesture( ACT_GESTURE_SMALL_FLINCH );

-			PainSound( info );

-

-			// Interrupt our gun during the flinch

-			m_pMinigun->StopShootingForSeconds( this, m_pMinigun->GetTarget(), 1.1f );

-

-			GetEnemies()->OnTookDamageFrom( info.GetAttacker() );

-

-			if( !IsSmoking() && m_iHealth <= sk_strider_health.GetInt() / 2 )

-			{

-				StartSmoking();

-			}

-			return damage;

-		}

-

-// NOTE: Currently radius damage doesn't even call this because it uses the origin, not the box for distance

-#if 0

-		NDebugOverlay::Box( headPos, WorldAlignMins(), WorldAlignMaxs(), 255, 0, 0, 0, 5.0 );

-		NDebugOverlay::Cross3D( inf

-			o.GetDamagePosition(), 24, 0, 255, 0, false, 5.0 );

-		// too far from head, apply damage to nearest leg?

-#endif

-	}

-

-#if 0

-	if ( (info.GetDamageType() & DMG_BULLET) && info.GetDamage() > 1  && m_iHealth > 1 )

-	{

-		m_iHealth -= 1;

-		return 1;

-	}

-#endif

-

-	return 0;

-}

-

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

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

-int CNPC_Strider::TakeDamageFromCombineBall( const CTakeDamageInfo &info )

-{

-	float damage = info.GetDamage();

-

-	// If it's only an AR2 alt-fire, we don't take much damage

-	if ( UTIL_IsAR2CombineBall( info.GetInflictor() ) )

-	{

-		damage = strider_ar2_altfire_dmg.GetFloat();

-	}

-	else

-	{

-		// Always start smoking when we're struck by a normal combine ball

-		StartSmoking();

-	}

-

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

-	{

-		// Route combine ball damage through the regular skill level code.

-		damage = g_pGameRules->AdjustPlayerDamageInflicted(damage);

-	}

-

-	AddFacingTarget( info.GetInflictor(), info.GetInflictor()->GetAbsOrigin(), 0.5, 2.0 );

-	if ( !UTIL_IsAR2CombineBall( info.GetInflictor() ) )

-		RestartGesture( ACT_GESTURE_BIG_FLINCH );

-	else

-		RestartGesture( ACT_GESTURE_SMALL_FLINCH );

-	

-	PainSound( info );

-

-	m_iHealth -= damage;

-

-	return damage;

-}

-

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

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

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

-{

-	// Do a special death if we're killed by a combine ball in the Citadel

-	if ( info.GetInflictor() && UTIL_IsCombineBall( info.GetInflictor() ) )

-	{

-		if ( m_lifeState == LIFE_DYING )

-			return;

-

-		// Tracker 23610:  Strider playing death sounds twice (AI_BaseNPC calls it in Event_Killed, too)

-		// DeathSound( info );

-		m_lifeState = LIFE_DYING;

-

-		// Start dying

-		RestartGesture( (Activity) ACT_STRIDER_GESTURE_DEATH );

-

-		// Stop our mini-cannon

-		m_pMinigun->StopShootingForSeconds( this, m_pMinigun->GetTarget(), 100.0f );

-	}

-	else

-	{

-		StopSmoking();

-

-		m_BoneFollowerManager.DestroyBoneFollowers();

-	

-	}

-

-	if( IsUsingAggressiveBehavior() )

-	{

-		// Lifted this code from the gunship.

-		Vector vecExplode;

-		GetAttachment( "minigun", vecExplode );

-		ExplosionCreate( vecExplode, QAngle(0,0,1), this, 100, 128, false );

-	}

-

-	// Determine if we're going to explode into pieces

-	m_bExploding = ShouldExplodeFromDamage( info );

-

-	BaseClass::Event_Killed( info );

-

-	// Stop our large cannon

-	EntityMessageBegin( this, true );

-		WRITE_BYTE( STRIDER_MSG_DEAD );

-	MessageEnd();

-}

-

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

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

-void CNPC_Strider::RagdollDeathEffect( CRagdollProp *pRagdoll, float flDuration )

-{

-	UTIL_ScreenShake( EyePosition(), 50, 150.0, 1.0, 1024, SHAKE_START );

-

-	int i;

-	for( i = 0 ; i < 2 ; i++ )

-	{

-		SmokeTrail *pSmoke = SmokeTrail::CreateSmokeTrail();

-		if ( pSmoke )

-		{

-			if( i == 0 )

-			{

-				pSmoke->m_SpawnRate			= 16;

-				pSmoke->m_Opacity 			= 0.25;

-				pSmoke->m_StartColor.Init( 0.45f, 0.45f, 0.45f );

-			}

-			else

-			{

-				pSmoke->m_SpawnRate			= 32;

-				pSmoke->m_Opacity 			= 0.3;

-				pSmoke->m_StartColor.Init( 0.5f, 0.5f, 0.5f );

-			}

-

-			pSmoke->m_ParticleLifetime	= 3.0;

-			pSmoke->m_StartSize			= 16;

-			pSmoke->m_EndSize			= 64;

-			pSmoke->m_SpawnRadius		= 20;

-			pSmoke->m_MinSpeed			= 8;

-			pSmoke->m_MaxSpeed			= 64;

-			pSmoke->m_EndColor.Init( 0, 0, 0 );

-

-			pSmoke->SetLifetime( flDuration );

-

-			if( i == 0 )

-			{

-				pSmoke->FollowEntity( pRagdoll, "MiniGunBase" );

-			}

-			else

-			{

-				pSmoke->FollowEntity( pRagdoll, "vehicle_driver_eyes" );

-			}

-		}

-	}

-}

-

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

-// Purpose: 

-// Input  : &info - 

-// Output : Returns true on success, false on failure.

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

-bool CNPC_Strider::ShouldExplodeFromDamage( const CTakeDamageInfo &info )

-{

-	CBaseEntity *pInflictor = info.GetInflictor();

-	if ( pInflictor == NULL )

-		return false;

-

-	// Combine balls make us explode

-	if ( UTIL_IsCombineBall( info.GetInflictor() ) )

-		return true;

-

-	// Stickybombs make us explode

-	CBaseEntity *pAttacker = info.GetAttacker();

-	if ( pAttacker != NULL && (FClassnameIs( pAttacker, "weapon_striderbuster" ) ||

-								FClassnameIs( pAttacker, "npc_grenade_magna" )))

-		return true;

-

-	if ( pInflictor == this && pAttacker == this )

-		return true;

-

-	return false;

-}

-

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

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

-ConVarRef mat_dxlevel( "mat_dxlevel" );

-bool CNPC_Strider::BecomeRagdoll( const CTakeDamageInfo &info, const Vector &forceVector ) 

-{ 

-	// Combine balls make us explode

-	if ( m_bExploding )

-	{

-		Explode();

-	}

-	else

-	{

-		// Otherwise just keel over

-		CRagdollProp *pRagdoll = NULL;

-		CBasePlayer *pPlayer = AI_GetSinglePlayer();

-		if ( pPlayer && mat_dxlevel.GetInt() > 0 )

-		{

-			int dxlevel = mat_dxlevel.GetInt();

-			int maxRagdolls = ( dxlevel >= 90 ) ? 2 : ( dxlevel >= 80 ) ? 1 : 0;

-

-			if ( maxRagdolls > 0 )

-			{

-				CUtlVectorFixed<CRagdollProp *, 2> striderRagdolls;

-				while ( ( pRagdoll = gEntList.NextEntByClass( pRagdoll ) ) != NULL )

-				{

-					if ( pRagdoll->GetModelName() == GetModelName() && !pRagdoll->IsFading() )

-					{

-						Assert( striderRagdolls.Count() < striderRagdolls.NumAllocated() );

-						if ( striderRagdolls.Count() < striderRagdolls.NumAllocated() )

-							striderRagdolls.AddToTail( pRagdoll );

-					}

-				}

-

-				if ( striderRagdolls.Count() >= maxRagdolls )

-				{

-					float distSqrFurthest = FLT_MAX;

-					CRagdollProp *pFurthest = NULL;

-

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

-					{

-						float distSqrCur = CalcSqrDistanceToAABB( striderRagdolls[i]->WorldAlignMins(), striderRagdolls[i]->WorldAlignMaxs(), pPlayer->GetAbsOrigin() );

-						if ( distSqrCur < distSqrFurthest )

-						{

-							distSqrFurthest = distSqrCur;

-							pFurthest = striderRagdolls[i];

-						}

-					}

-

-					if ( pFurthest )

-						pFurthest->FadeOut( 0.75, 1.5 );

-				}

-			}

-

-			pRagdoll = assert_cast<CRagdollProp *>( CreateServerRagdoll( this, m_nForceBone, info, HL2COLLISION_GROUP_STRIDER ) );

-			pRagdoll->DisableAutoFade();

-

-			if ( maxRagdolls == 0 )

-			{

-				pRagdoll->FadeOut( 6.0, .75 );

-				RagdollDeathEffect( pRagdoll, 6.0f );

-			}

-			else

-			{

-				RagdollDeathEffect( pRagdoll, 600.0f );

-			}

-		}

-		else

-		{

-			// Otherwise just keel over

-			pRagdoll = assert_cast<CRagdollProp *>( CreateServerRagdoll( this, m_nForceBone, info, HL2COLLISION_GROUP_STRIDER ) );

-			pRagdoll->DisableAutoFade();

-		}

-	}

-	

-	UTIL_Remove(this);

-

-	return true; 

-}

-

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

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

-void CNPC_Strider::StartSmoking( void )

-{

-	if ( m_hSmoke != NULL )

-		return;

-

-	m_hSmoke = SmokeTrail::CreateSmokeTrail();

-	

-	if ( m_hSmoke )

-	{

-		m_hSmoke->m_SpawnRate			= 32;

-		m_hSmoke->m_ParticleLifetime	= 3.0;

-		m_hSmoke->m_StartSize			= 16;

-		m_hSmoke->m_EndSize				= 64;

-		m_hSmoke->m_SpawnRadius			= 20;

-		m_hSmoke->m_MinSpeed			= 8;

-		m_hSmoke->m_MaxSpeed			= 64;

-		m_hSmoke->m_Opacity 			= 0.3;

-		

-		m_hSmoke->m_StartColor.Init( 0.25f, 0.25f, 0.25f );

-		m_hSmoke->m_EndColor.Init( 0, 0, 0 );

-		m_hSmoke->SetLifetime( 500.0f );

-		m_hSmoke->FollowEntity( this, "MiniGunBase" );

-	}

-}

-

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

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

-void CNPC_Strider::StopSmoking( float flDelay )

-{

-	if ( m_hSmoke )

-	{

-		m_hSmoke->SetLifetime( flDelay );

-	}

-}

-

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

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

-void CNPC_Strider::SetHeight( float h )

-{

-	if ( h > GetMaxHeight() )

-		h = GetMaxHeight();

-	else if ( h < GetMinHeight() )

-		h = GetMinHeight();

-

-	SetPoseParameter( gm_BodyHeightPoseParam, h );

-}

-

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

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

-void CNPC_Strider::SetIdealHeight( float h )

-{

-	if ( h > GetMaxHeight() )

-		h = GetMaxHeight();

-	else if ( h < GetMinHeight() )

-		h = GetMinHeight();

-

-	m_idealHeight = h;

-}

-

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

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

-void CNPC_Strider::SetAbsIdealHeight( float z )

-{

-	float h = GetMaxHeight() - ( z - GetAbsOrigin().z );

-	

-	SetIdealHeight( h );

-}

-

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

-// At this moment, am I in the PROCESS of crouching? 

-// as in, and I transitioning from standing to crouch?

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

-bool CNPC_Strider::IsStriderCrouching()

-{

-	if( IsCurSchedule( SCHED_STRIDER_CROUCH, false ) )

-		return true;

-

-	return false;

-}

-

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

-// As IsStriderCrouching(), but for obvious differences.

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

-bool CNPC_Strider::IsStriderStanding()

-{

-	if( IsCurSchedule( SCHED_STRIDER_STAND, false ) )

-		return true;

-

-	return false;

-}

-

-

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

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

-

-bool CNPC_Strider::OverrideMove( float flInterval )

-{

-	if ( GetCannonTarget() )

-	{

-		AddFacingTarget( GetCannonTarget(), GetCannonTarget()->GetAbsOrigin(), 1.0, 0.5 );

-	}

-	else if ( GetEnemy() )

-	{

-		bool bPlayer = GetEnemy()->IsPlayer();

-		float timeSinceSeenEnemy = gpGlobals->curtime - GetEnemyLastTimeSeen();

-		if ( ( !bPlayer && timeSinceSeenEnemy < STRIDER_TIME_STOP_FACING_ENEMY ) ||

-			 ( bPlayer && !m_PlayerFreePass.HasPass() ) )

-		{

-			AddFacingTarget( GetEnemy(), GetEnemies()->LastKnownPosition( GetEnemy() ), 1.0, 0.5 );

-		}

-

-		if ( !m_bCrouchLocked && !m_hCannonTarget && GetIdealHeight() < GetMaxHeight() && timeSinceSeenEnemy > TIME_CARE_ENEMY )

-			SetIdealHeight( GetMaxHeight() );

-	}

-	else if ( !m_bCrouchLocked && !m_hCannonTarget )

-		SetIdealHeight( GetMaxHeight() );

-

-	if ( strider_test_height.GetFloat() > .1 )

-		SetIdealHeight( strider_test_height.GetFloat() );

-

-	// If we're not supposed to crouch walk and we're under the threshold for what we consider crouch walking, stand back up!

-	if ( !m_bCrouchLocked && m_bNoCrouchWalk && IsMoving() && ( GetIdealHeight() < ( GetMinHeight() + GetHeightRange() * ( strider_pct_height_no_crouch_move.GetFloat() / 100.0 ) ) ) )

-	{

-		SetIdealHeight( GetMinHeight() + GetHeightRange() * ( strider_pct_height_no_crouch_move.GetFloat() / 100.0 ) );

-	}

-

-	float heightMove = GetIdealHeight() - GetHeight();

-	float heightMoveSign = ( heightMove < 0 ) ? -1 : 1;

-	heightMove = fabsf( heightMove );

-	if ( heightMove > 0.01 )

-	{

-		const float maxVelocity = 300;

-		const float minVelocity = 10;

-

-		#define HEIGHTINVDECAY	0.8	// maintain X percent of velocity when slowing down

-		#define HEIGHTDECAYTIME	0.4161	// Sum( 1..cycle, HEIGHTINVDECAY^cycle ) 

-		#define HEIGHTACCEL		0.5		// accel toward maxVelocity by X percent each cycle

-

-		if (fabsf( m_HeightVelocity ) < minVelocity)

-			m_HeightVelocity = minVelocity * heightMoveSign;

-

-		if (heightMove < m_HeightVelocity * heightMoveSign * HEIGHTDECAYTIME )

-		{

-			m_HeightVelocity = m_HeightVelocity * HEIGHTINVDECAY;

-

-			if (heightMove < m_HeightVelocity * heightMoveSign * flInterval)

-			{

-				m_HeightVelocity = heightMove * heightMoveSign / flInterval;

-			}

-		}

-		else

-		{

-			m_HeightVelocity = m_HeightVelocity * (1.0f - HEIGHTACCEL) + maxVelocity * HEIGHTACCEL * heightMoveSign;

-			if (heightMove < m_HeightVelocity * heightMoveSign * HEIGHTDECAYTIME)

-			{

-				m_HeightVelocity = heightMove * heightMoveSign / HEIGHTDECAYTIME;

-			}

-		}

-

-		float newHeight = GetHeight() + m_HeightVelocity * flInterval;

-		SetHeight( newHeight );

-	}

-

-	// FIXME: where should this go?

-	MaintainTurnActivity( );

-

-	return false;

-}

-

-

-void CNPC_Strider::MaintainTurnActivity( void )

-{

-	// detect that the npc has turned

-	if (m_prevYaw != GetAbsAngles().y)

-	{

-		float diff = UTIL_AngleDiff( m_prevYaw, GetAbsAngles().y );

-		if (diff < 0.0)

-		{

-			m_doLeft += -diff;

-		}

-		else

-		{

-			m_doRight += diff;

-		}

-		m_prevYaw = GetAbsAngles().y;

-	}

-	// accumulate turn angle, delay response for short turns

-	m_doTurn += m_doRight + m_doLeft;

-	if (!IsMoving() && m_doTurn > 180.0f && m_flNextTurnAct < gpGlobals->curtime )

-	{

-		int iSeq = ACT_INVALID;

-		if (m_doLeft > m_doRight)

-		{

-			iSeq = SelectWeightedSequence( ACT_GESTURE_TURN_LEFT );

-		}

-		else

-		{

-			iSeq = SelectWeightedSequence( ACT_GESTURE_TURN_RIGHT );

-		}

-		if (iSeq != ACT_INVALID)

-		{

-			int iLayer = AddGestureSequence( iSeq );

-			if (iLayer != -1)

-			{

-				SetLayerPriority( iLayer, 100 );

-				// increase speed if we're getting behind or they're turning quickly

-				if (m_doTurn > 360.0)

-				{

-					SetLayerPlaybackRate( iLayer, 1.5 );

-				}

-				m_flNextTurnAct = gpGlobals->curtime + GetLayerDuration( iLayer );

-			}

-			else

-			{

-				// too busy, try again in half a second

-				m_flNextTurnAct = gpGlobals->curtime + 0.5;

-			}

-		}

-		m_doTurn = m_doLeft = m_doRight = 0.0;

-	}

-}

-

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

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

-bool CNPC_Strider::IsUnusableNode(int iNodeID, CAI_Hint *pHint)

-{

-	if ( !BaseClass::IsUnusableNode(iNodeID, pHint) )

-	{

-		if ( pHint && pHint->HintType() == HINT_STRIDER_NODE )

-			return false;

-	}

-	return true;

-}

-

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

-// Purpose: Compute the nav position for the strider's origin relative to this enemy.

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

-void CNPC_Strider::TranslateNavGoal( CBaseEntity *pEnemy, Vector &chasePosition )

-{

-	if ( pEnemy )

-	{

-		if ( ! (pEnemy->GetFlags() & FL_ONGROUND) )

-		{

-			MoveToGround( &chasePosition, pEnemy, pEnemy->WorldAlignMins(), pEnemy->WorldAlignMaxs() );

-		}

-

-		// move down to enemy's feet for enemy origin at chasePosition

-		chasePosition.z += pEnemy->WorldAlignMins().z;

-

-	}

-	else

-	{

-		MoveToGround( &chasePosition, NULL, Vector( -16, -16, 0 ), Vector( 16, 16, 32 ) );

-	}

-

-	// move up to strider stand height

-	chasePosition.z += GetMaxHeight() + npc_strider_height_adj.GetFloat();

-}

-

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

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

-bool CNPC_Strider::HasPendingTargetPath()

-{

-	bool bReturn = ( !FStrEq( STRING(m_strTrackName), STRIDER_NO_TRACK_NAME ) && !GetGoalEnt() );

-

-	return bReturn;

-}

-

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

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

-void CNPC_Strider::SetTargetPath()

-{

-	SetGoalEnt( NULL );

-	CBaseEntity *pGoalEnt = gEntList.FindEntityByName( NULL, m_strTrackName );

-	if ( pGoalEnt == NULL )

-	{

-		DevWarning( "%s: Could not find target path '%s'!\n", GetClassname(), STRING( m_strTrackName ) );

-

-		// Don't try anymore. It just hurts the AI.

-		m_strTrackName = MAKE_STRING( STRIDER_NO_TRACK_NAME );

-

-		UTIL_Remove( this );

-		return;

-	}

-

-	const Vector &absOrigin = GetAbsOrigin();

-	CBaseEntity *pClosestEnt = NULL;

-	CBaseEntity *pCurEnt = pGoalEnt;

-	float distClosestSq = FLT_MAX;

-

-	CUtlRBTree<CBaseEntity *> visits;

-	SetDefLessFunc(visits);

-

-	while ( pCurEnt && visits.Find( pCurEnt ) == visits.InvalidIndex() )

-	{

-		float distCurSq = ( pCurEnt->GetAbsOrigin() - absOrigin ).LengthSqr();

-		if ( distCurSq < distClosestSq )

-		{

-			distClosestSq = distCurSq;

-			pClosestEnt = pCurEnt;

-		}

-		visits.Insert( pCurEnt );

-		pCurEnt = GetNavigator()->GetNextPathcorner( pCurEnt );

-	}

-

-	ScheduledFollowPath( SCHED_IDLE_WALK, pClosestEnt, ACT_WALK );

-}

-

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

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

-

-float CNPC_Strider::GetDefaultNavGoalTolerance()

-{

-	return 64;

-}

-

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

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

-void CNPC_Strider::OnMovementComplete()

-{

-	if ( GetGoalEnt() && 

-		 ( IsCurSchedule( SCHED_IDLE_WALK ) ||

-		   IsCurSchedule( SCHED_ALERT_WALK ) ||

-		   IsCurSchedule( SCHED_COMBAT_WALK ) ||

-		   IsCurSchedule( SCHED_STRIDER_HUNT ) ) )

-	{

-		m_strTrackName = MAKE_STRING( STRIDER_NO_TRACK_NAME );

-		SetGoalEnt( NULL );

-	}

-	BaseClass::OnMovementComplete();

-}

-

-

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

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

-float CNPC_Strider::GetSequenceGroundSpeed( CStudioHdr *pStudioHdr, int iSequence )

-{

-	return ( BaseClass::GetSequenceGroundSpeed( pStudioHdr, iSequence ) * m_flSpeedScale );

-}

-

-

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

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

-float CNPC_Strider::MaxYawSpeed()

-{

-	switch( GetActivity() )

-	{

-	case ACT_90_LEFT:

-	case ACT_90_RIGHT:

-		return 10;

-

-	case ACT_TURN_LEFT:

-	case ACT_TURN_RIGHT:

-		return 10;

-

-	case ACT_WALK:

-		return 10;

-

-	default:

-		return 10;		// should be zero, but this makes it easy to see when he's turning with default AI code

-		break;

-	}

-}

-

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

-// Purpose: 

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

-void CNPC_Strider::DoMuzzleFlash( void )

-{

-	BaseClass::DoMuzzleFlash();

-	

-	CEffectData data;

-

-	data.m_nAttachmentIndex = LookupAttachment( "MiniGun" );

-	data.m_nEntIndex = entindex();

-	DispatchEffect( "StriderMuzzleFlash", data );

-}

-

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

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

-void CNPC_Strider::ShootMinigun( const Vector *pTarget, float aimError, const Vector &vecSpread )

-{

-	if ( pTarget )

-	{

-		Vector muzzlePos;

-		QAngle muzzleAng;

-

-		GetAttachment( "minigun", muzzlePos, muzzleAng );

-		

-		Vector vecShootDir = *pTarget - muzzlePos;

-		VectorNormalize( vecShootDir );

-

-		if( m_bMinigunUseDirectFire )

-		{

-			// exactly on target w/tracer

-			FireBullets( 1, muzzlePos, vecShootDir, vecSpread, 8192, m_miniGunDirectAmmo, 1 );

-		}

-		else

-		{

-			// exactly on target w/tracer

-			FireBullets( 1, muzzlePos, vecShootDir, vecSpread, 8192, m_miniGunAmmo, 1 );

-		}

-

-		//g_pEffects->MuzzleFlash( muzzlePos, muzzleAng, random->RandomFloat( 2.0f, 4.0f ) , MUZZLEFLASH_TYPE_STRIDER );

-		DoMuzzleFlash();

-

-		EmitSound( "NPC_Strider.FireMinigun" );

-	}

-}

-

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

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

-void CNPC_Strider::UpdateMinigunControls( float &yaw, float &pitch ) 

-{

-	SetPoseParameter( m_poseMiniGunYaw, yaw );

-	SetPoseParameter( m_poseMiniGunPitch, pitch );

-

-	yaw = GetPoseParameter( m_poseMiniGunYaw );

-	pitch = GetPoseParameter( m_poseMiniGunPitch );

-}

-

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

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

-void CNPC_Strider::GetViewCone( StriderMinigunViewcone_t &cone )

-{

-	cone.origin = EyePosition();

-	GetVectors( &cone.axis, NULL, NULL );

-	cone.cosAngle = 0.5; // 60 degree cone

-	cone.length = 2048;

-}

-

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

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

-void CNPC_Strider::OnMinigunStopShooting( CBaseEntity *pTarget )

-{

-	// Stop hating the focus.

-	if( GetFocus() && pTarget == GetFocus() )

-	{

-		AddEntityRelationship( GetFocus(), D_NU, 0 );

-	}

-

-	if( IsUsingAggressiveBehavior() )

-	{

-		// From now on, direct fire. 

-		m_bMinigunUseDirectFire = true;

-	}

-}

-

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

-// How fast the minigun fires (rounds per second)

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

-float CNPC_Strider::GetMinigunRateOfFire()

-{

-	if( IsUsingAggressiveBehavior() && m_bMinigunUseDirectFire )

-		return STRIDER_EP1_RATE_OF_FIRE;

-

-	return STRIDER_DEFAULT_RATE_OF_FIRE;

-}

-

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

-// How much of shoot duration is spent firing directly at

-// the target (the balance of time is spent stitching towards)

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

-float CNPC_Strider::GetMinigunOnTargetTime()

-{

-	if( IsUsingAggressiveBehavior() )

-	{

-		if( m_bMinigunUseDirectFire )

-		{

-			// On target the whole time. Just send a large number that

-			// will be clipped, since shooting duration is random and

-			// we don't know how long the burst will actually be.

-			return 100.0f;

-		}

-

-		return STRIDER_EP1_SHOOT_ON_TARGET_TIME;

-	}

-

-	return STRIDER_SHOOT_ON_TARGET_TIME;

-}

-

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

-// How long (seconds) a burst of minigun fire lasts.

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

-float CNPC_Strider::GetMinigunShootDuration()

-{

-	if( IsUsingAggressiveBehavior() )

-		return STRIDER_EP1_SHOOT_DURATION;

-

-	return STRIDER_DEFAULT_SHOOT_DURATION; 

-}

-

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

-// How long (seconds) a strider must wait between bursts

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

-float CNPC_Strider::GetMinigunShootDowntime()

-{

-	if( IsUsingAggressiveBehavior() )

-		return STRIDER_EP1_SHOOT_DOWNTIME;

-

-	return STRIDER_SHOOT_DOWNTIME;

-}

-

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

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

-float CNPC_Strider::GetMinigunShootVariation()

-{

-	if( IsUsingAggressiveBehavior() )

-	{

-		if( m_bMinigunUseDirectFire )

-			return 0.0f;

-

-		return STRIDER_EP1_SHOOT_VARIATION;

-	}

-

-	return STRIDER_SHOOT_VARIATION;

-}

-

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

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

-Vector CNPC_Strider::CannonPosition()

-{

-	Vector position;

-

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

-	GetAttachment( "biggun", position );

-	position.x = GetAbsOrigin().x;

-	position.y = GetAbsOrigin().y;

-

-	return position;

-}

-

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

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

-CBaseEntity *CNPC_Strider::GetCannonTarget()

-{

-	CBaseEntity *pTarget = m_hCannonTarget;

-	return pTarget;

-}

-

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

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

-bool CNPC_Strider::HasCannonTarget() const

-{

-	return ( m_hCannonTarget.Get() != NULL );

-}

-

-

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

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

-bool CNPC_Strider::IsCannonTarget( CBaseEntity *pTarget ) const

-{

-	CBaseEntity *pCannonTarget = m_hCannonTarget;

-	if ( pCannonTarget && pCannonTarget == pTarget )

-	{

-		return true;

-	}

-

-	return false;

-}

-

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

-// Purpose: Aim Gun at a target

-// Output : Returns true if you hit the target, false if not there yet

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

-bool CNPC_Strider::AimCannonAt( CBaseEntity *pEntity, float flInterval )

-{

-	if ( !pEntity )

-		return true;

-

-	matrix3x4_t gunMatrix;

-	GetAttachment( gm_CannonAttachment, gunMatrix );

-

-	// transform the enemy into gun space

-	m_vecHitPos = pEntity->GetAbsOrigin();

-	Vector localEnemyPosition;

-	VectorITransform( pEntity->GetAbsOrigin(), gunMatrix, localEnemyPosition );

-	

-	// do a look at in gun space (essentially a delta-lookat)

-	QAngle localEnemyAngles;

-	VectorAngles( localEnemyPosition, localEnemyAngles );

-	

-	// convert to +/- 180 degrees

-	localEnemyAngles.x = UTIL_AngleDiff( localEnemyAngles.x, 0 );	

-	localEnemyAngles.y = UTIL_AngleDiff( localEnemyAngles.y, 0 );

-

-	float targetYaw = m_aimYaw + localEnemyAngles.y;

-	float targetPitch = m_aimPitch + localEnemyAngles.x;

-	

-	Vector unitAngles = Vector( localEnemyAngles.x, localEnemyAngles.y, localEnemyAngles.z ); 

-	float angleDiff = VectorNormalize(unitAngles);

-	const float aimSpeed = 16;

-

-	// Exponentially approach the target

-	float yawSpeed = fabsf(aimSpeed*flInterval*localEnemyAngles.y);

-	float pitchSpeed = fabsf(aimSpeed*flInterval*localEnemyAngles.x);

-

-	yawSpeed = MAX(yawSpeed,5);

-	pitchSpeed = MAX(pitchSpeed,5);

-

-	m_aimYaw = UTIL_Approach( targetYaw, m_aimYaw, yawSpeed );

-	m_aimPitch = UTIL_Approach( targetPitch, m_aimPitch, pitchSpeed );

-

-	SetPoseParameter( gm_YawControl, m_aimYaw );

-	SetPoseParameter( gm_PitchControl, m_aimPitch );

-

-	// read back to avoid drift when hitting limits

-	// as long as the velocity is less than the delta between the limit and 180, this is fine.

-	m_aimPitch = GetPoseParameter( gm_PitchControl );

-	m_aimYaw = GetPoseParameter( gm_YawControl );

-

-	// UNDONE: Zero out any movement past the limit and go ahead and fire if the strider hit its 

-	// target except for clamping.  Need to clamp targets to limits and compare?

-	if ( angleDiff < 1 )

-		return true;

-

-	return false;

-}

-

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

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

-void CNPC_Strider::FireCannon() 

-{

-	ASSERT( m_hCannonTarget != NULL );

-	if ( !m_hCannonTarget )

-	{

-		DevMsg( "Strider firing cannon at NULL target\n" );

-		

-		// Turn the cannon off

-		EntityMessageBegin( this, true );

-			WRITE_BYTE( STRIDER_MSG_DEAD );

-		MessageEnd();

-

-		return;

-	}

-

-	if ( GetNextThink( "CANNON_HIT" ) > gpGlobals->curtime )

-	{

-		DevMsg( "Strider refiring cannon?\n" );

-		return;

-	}

-

-	m_nextShootTime = gpGlobals->curtime + 5;

-	trace_t tr;

-	Vector vecShootPos;

-	GetAttachment( gm_CannonAttachment, vecShootPos );

-

-	Vector vecShootDir;

-	vecShootDir = m_hCannonTarget->WorldSpaceCenter() - vecShootPos;

-	float flDist = VectorNormalize( vecShootDir );

-

-	AI_TraceLine( vecShootPos, vecShootPos + vecShootDir * flDist, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );

-	m_blastHit = tr.endpos;

-	m_blastHit += tr.plane.normal * 16;

-	m_blastNormal = tr.plane.normal;

-

-	// tell the client side effect to complete

-	EntityMessageBegin( this, true );

-		WRITE_BYTE( STRIDER_MSG_BIG_SHOT );

-		WRITE_VEC3COORD( tr.endpos );

-	MessageEnd();

-

-	CPASAttenuationFilter filter2( this, "NPC_Strider.Shoot" );

-	EmitSound( filter2, entindex(), "NPC_Strider.Shoot");

-	SetContextThink( &CNPC_Strider::CannonHitThink, gpGlobals->curtime + 0.2f, "CANNON_HIT" );

-}

-

-void CNPC_Strider::CannonHitThink()

-{

-	CBaseEntity *pCannonTarget = m_hCannonTarget;

-	if ( pCannonTarget )

-	{

-		bool fAlive = pCannonTarget->IsAlive();

-

-		CreateConcussiveBlast( m_blastHit, m_blastNormal, this, 2.5 );

-

-		// If the target was alive, check to make sure it is now dead. If not,

-		// Kill it and warn the designer.

-		if( fAlive && pCannonTarget->IsAlive() )

-		{

-			DevWarning("* * * * * * * * * * * * * * *\n");

-			DevWarning("NASTYGRAM: STRIDER failed to kill its cannon target. Killing directly...\n");

-			DevWarning("* * * * * * * * * * * * * * *\n");

-

-			CTakeDamageInfo info;

-

-			info.SetDamage( pCannonTarget->GetHealth() );

-			info.SetDamageType( DMG_GENERIC );

-			info.SetAttacker( this );

-			info.SetInflictor( this );

-

-			pCannonTarget->TakeDamage( info );

-		}

-		

-		// Clear this guy now that we've shot him

-		m_hCannonTarget = NULL;

-	}

-

-	// Allow the cannon back on.

-	m_pMinigun->StopShootingForSeconds( this, m_pMinigun->GetTarget(), 1 );

-}

-

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

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

-void CNPC_Strider::VPhysicsShadowCollision( int index, gamevcollisionevent_t *pEvent )

-{

-	if ( !HasMemory( bits_MEMORY_PROVOKED ) )

-	{

-		// if the player threw this in the last 1 seconds

-		CBasePlayer *pPlayer = pEvent->pEntities[!index]->HasPhysicsAttacker( 1 );

-		if ( pPlayer )

-		{

-			GetEnemies()->ClearMemory( pPlayer );

-			Remember( bits_MEMORY_PROVOKED );

-			SetCondition( COND_LIGHT_DAMAGE );

-		}

-	}

-

-	int otherIndex = !index;

-	CBaseEntity *pOther = pEvent->pEntities[otherIndex];

-	if ( pOther && UTIL_IsCombineBall( pOther ) )

-	{

-		Vector damagePos;

-		pEvent->pInternalData->GetContactPoint( damagePos );

-		CTakeDamageInfo dmgInfo( pOther, pOther, vec3_origin, damagePos, (m_iMaxHealth / 3) + 1, DMG_BLAST | DMG_PREVENT_PHYSICS_FORCE );

-

-		// FIXME: is there a better way for physics objects to keep track of what root entity responsible for them moving?

-		CBasePlayer *pPlayer = pOther->HasPhysicsAttacker( 1.0 );

-		if (pPlayer)

-		{

-			dmgInfo.SetAttacker( pPlayer );

-		}

-

-		// UNDONE: Find one near damagePos?

-		m_nForceBone = 0;

-		PhysCallbackDamage( this, dmgInfo, *pEvent, index );

-		return;

-	}

-

-	BaseClass::VPhysicsShadowCollision( index, pEvent );

-}

-

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

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

-bool CNPC_Strider::TestCollision( const Ray_t &ray, unsigned int mask, trace_t& trace )

-{

-	// Let normal hitbox code handle rays

-	if ( mask & CONTENTS_HITBOX )

-	{

-		return BaseClass::TestCollision( ray, mask, trace );

-	}

-

-	if ( IntersectRayWithBox( ray, WorldAlignMins() + GetAbsOrigin(), WorldAlignMaxs() + GetAbsOrigin(), DIST_EPSILON, &trace ) )

-	{

-		trace.hitbox = 0;

-		trace.hitgroup = HITGROUP_HEAD;

-		return true;

-	}

-	return false;

-}

-

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

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

-bool CNPC_Strider::CarriedByDropship()

-{

-	if( GetOwnerEntity() && FClassnameIs( GetOwnerEntity(), "npc_combinedropship" ) )

-		return true;

-

-	return false;

-}

-

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

-// Carried by a dropship

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

-void CNPC_Strider::CarriedThink()

-{

-	SetNextThink( gpGlobals->curtime + 0.05 );

-	StudioFrameAdvance();

-

-	Vector vecGround = GetAbsOrigin();

-	TranslateNavGoal( NULL, vecGround );

-

-	if( !CarriedByDropship() )

-	{

-		SetSolid( SOLID_BBOX );

-		SetThink ( &CAI_BaseNPC::CallNPCThink );

-	}

-}

-

-

-

-

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

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

-Vector CNPC_Strider::LeftFootHit( float eventtime )

-{

-	Vector footPosition;

-	QAngle angles;

-

-	GetAttachment( "left foot", footPosition, angles );

-

-	if ( hl2_episodic.GetBool() )

-	{

-		CPASAttenuationFilter filter( this, "NPC_Strider.FootstepEverywhere" );

-		EmitSound( filter, 0, "NPC_Strider.FootstepEverywhere", &footPosition, eventtime );

-	}

-	else

-	{

-		CPASAttenuationFilter filter( this, "NPC_Strider.Footstep" );

-		EmitSound( filter, 0, "NPC_Strider.Footstep", &footPosition, eventtime );

-	}

-

-	FootFX( footPosition );

-

-	return footPosition;

-}

-

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

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

-Vector CNPC_Strider::RightFootHit( float eventtime )

-{

-	Vector footPosition;

-

-	GetAttachment( "right foot", footPosition );

-	

-	if ( hl2_episodic.GetBool() )

-	{

-		CPASAttenuationFilter filter( this, "NPC_Strider.FootstepEverywhere" );

-		EmitSound( filter, 0, "NPC_Strider.FootstepEverywhere", &footPosition, eventtime );

-	}

-	else

-	{

-		CPASAttenuationFilter filter( this, "NPC_Strider.Footstep" );

-		EmitSound( filter, 0, "NPC_Strider.Footstep", &footPosition, eventtime );

-	}

-

-	FootFX( footPosition );

-

-	return footPosition;

-}

-

-

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

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

-Vector CNPC_Strider::BackFootHit( float eventtime )

-{

-	Vector footPosition;

-

-	GetAttachment( "back foot", footPosition );

-

-	if ( hl2_episodic.GetBool() )

-	{

-		CPASAttenuationFilter filter( this, "NPC_Strider.FootstepEverywhere" );

-		EmitSound( filter, 0, "NPC_Strider.FootstepEverywhere", &footPosition, eventtime );

-	}

-	else

-	{

-		CPASAttenuationFilter filter( this, "NPC_Strider.Footstep" );

-		EmitSound( filter, 0, "NPC_Strider.Footstep", &footPosition, eventtime );

-	}

-

-	FootFX( footPosition );

-

-	return footPosition;

-}

-

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

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

-static Vector GetAttachmentPositionInSpaceOfBone( CStudioHdr *pStudioHdr, const char *pAttachmentName, int outputBoneIndex )

-{

-	int attachment = Studio_FindAttachment( pStudioHdr, pAttachmentName );

-

-	Vector localAttach;

-	const mstudioattachment_t &pAttachment = pStudioHdr->pAttachment(attachment);

-	int iBone = pStudioHdr->GetAttachmentBone( attachment );

-	MatrixGetColumn( pAttachment.local, 3, localAttach );

-

-	matrix3x4_t inputToOutputBone;

-	Studio_CalcBoneToBoneTransform( pStudioHdr, iBone, outputBoneIndex, inputToOutputBone );

-	

-	Vector out;

-	VectorTransform( localAttach, inputToOutputBone, out );

-

-	return out;

-}

-

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

-

-void CNPC_Strider::StompHit( int followerBoneIndex )

-{

-	CStudioHdr *pStudioHdr = GetModelPtr();

-	physfollower_t *bone = m_BoneFollowerManager.GetBoneFollower( followerBoneIndex );

-	if ( !bone )

-		return;

-

-	const char *pBoneNames[] = {"left skewer", "right skewer" };

-	int nameIndex = followerBoneIndex == STRIDER_LEFT_LEG_FOLLOWER_INDEX ? 0 : 1;

-	Vector localHit = GetAttachmentPositionInSpaceOfBone( pStudioHdr, pBoneNames[nameIndex], bone->boneIndex );

-	IPhysicsObject *pLegPhys = bone->hFollower->VPhysicsGetObject();

-

-	// now transform into the worldspace of the current position of the leg's physics

-	matrix3x4_t legToWorld;

-	pLegPhys->GetPositionMatrix( &legToWorld );

-	Vector hitPosition;

-	VectorTransform( localHit, legToWorld, hitPosition );

-

-	//NDebugOverlay::Box( hitPosition, Vector(-16,-16,-16), Vector(16,16,16), 0, 255, 0, 255, 1.0 );

-	CBaseEntity *pEnemy = GetEnemy();

-	CAI_BaseNPC *pNPC = pEnemy ? pEnemy->MyNPCPointer() : NULL;

-	bool bIsValidTarget = pNPC && pNPC->GetModelPtr();

-	if ( HasSpawnFlags( SF_CAN_STOMP_PLAYER ) )

-	{

-		bIsValidTarget = bIsValidTarget || ( pEnemy && pEnemy->IsPlayer() );

-	}

-

-	if ( !bIsValidTarget )

-		return;

-

-	Vector delta;

-	VectorSubtract( pEnemy->GetAbsOrigin(), hitPosition, delta );

-	if ( delta.LengthSqr() > (STRIDER_STOMP_RANGE * STRIDER_STOMP_RANGE) )

-		return;

-

-	// DVS E3 HACK: Assume we stab our victim midway between their eyes and their center.

-	Vector vecStabPos = ( pEnemy->WorldSpaceCenter() + pEnemy->EyePosition() ) * 0.5f;

-	hitPosition = pEnemy->GetAbsOrigin();

-

-	Vector footPosition;

-	GetAttachment( "left foot", footPosition );

-

-	CPASAttenuationFilter filter( this, "NPC_Strider.Skewer" );

-	EmitSound( filter, 0, "NPC_Strider.Skewer", &hitPosition );

-

-	CTakeDamageInfo damageInfo( this, this, 500, DMG_CRUSH );

-	Vector forward;

-	pEnemy->GetVectors( &forward, NULL, NULL );

-	damageInfo.SetDamagePosition( hitPosition );

-	damageInfo.SetDamageForce( -50 * 300 * forward );

-	pEnemy->TakeDamage( damageInfo );

-

-	if ( !pNPC || pNPC->IsAlive() )

-		return;

-

-	Vector vecBloodDelta = footPosition - vecStabPos;

-	vecBloodDelta.z = 0; // effect looks better 

-	VectorNormalize( vecBloodDelta );

-	UTIL_BloodSpray( vecStabPos + vecBloodDelta * 4, vecBloodDelta, BLOOD_COLOR_RED, 8, FX_BLOODSPRAY_ALL );

-	UTIL_BloodSpray( vecStabPos + vecBloodDelta * 4, vecBloodDelta, BLOOD_COLOR_RED, 11, FX_BLOODSPRAY_DROPS );

-	CBaseEntity *pRagdoll = CreateServerRagdollAttached( pNPC, vec3_origin, -1, COLLISION_GROUP_DEBRIS, pLegPhys, this, bone->boneIndex, vecStabPos, -1, localHit );

-	if ( pRagdoll )

-	{

-		// the strider might drag this through the world

-		pRagdoll->AddSolidFlags( FSOLID_NOT_SOLID );

-

-		m_hRagdoll = pRagdoll;

-		m_ragdollTime = gpGlobals->curtime + 10;

-		UTIL_Remove( pNPC );

-	}

-}

-

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

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

-void CNPC_Strider::FootFX( const Vector &origin )

-{

-	trace_t tr;

-	AI_TraceLine( origin + Vector(0, 0, 48), origin - Vector(0,0,100), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );

-	float yaw = random->RandomInt(0,120);

-	

-	if ( UTIL_PointContents( tr.endpos + Vector( 0, 0, 1 ) ) & MASK_WATER )

-	{

-		float flWaterZ = UTIL_FindWaterSurface( tr.endpos, tr.endpos.z, tr.endpos.z + 100.0f );

-

-		CEffectData	data;

-		data.m_fFlags = 0;

-		data.m_vOrigin = tr.endpos;

-		data.m_vOrigin.z = flWaterZ;

-		data.m_vNormal = Vector( 0, 0, 1 );

-		data.m_flScale = random->RandomFloat( 10.0, 14.0 );

-

-		DispatchEffect( "watersplash", data );

-	}

-	else

-	{

-		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 );

-		}

-	}

-	UTIL_ScreenShake( tr.endpos, 4.0, 1.0, 0.5, 1000, SHAKE_START, false );

-	

-	if ( npc_strider_shake_ropes_radius.GetInt() )

-	{

-		CRopeKeyframe::ShakeRopes( tr.endpos, npc_strider_shake_ropes_radius.GetFloat(), npc_strider_shake_ropes_magnitude.GetFloat() );

-	}

-

-	//

-	// My feet are scary things! NOTE: We might want to make danger sounds as the feet move

-	// through the air. Then soldiers could run from the feet, which would look cool.

-	//

-	CSoundEnt::InsertSound( SOUND_DANGER|SOUND_CONTEXT_EXCLUDE_COMBINE, tr.endpos, 512, 1.0f, this );

-}

-

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

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

-Vector CNPC_Strider::CalculateStompHitPosition( CBaseEntity *pEnemy )

-{

-	Vector skewerPosition, footPosition;

-	GetAttachment( "left skewer", skewerPosition );

-	GetAttachment( "left foot", footPosition );

-	Vector vecStabPos = ( pEnemy->WorldSpaceCenter() + pEnemy->EyePosition() ) * 0.5f;

-

-	return vecStabPos - skewerPosition + footPosition;

-}

-

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

-// Strider Navigation

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

-

-static void MoveToGround( Vector *position, CBaseEntity *ignore, const Vector &mins, const Vector &maxs )

-{

-	trace_t tr;

-	// Find point on floor where enemy would stand at chasePosition

-	Vector floor = *position;

-	floor.z -= 1024;

-	AI_TraceHull( *position, floor, mins, maxs, MASK_NPCSOLID_BRUSHONLY, ignore, COLLISION_GROUP_NONE, &tr );

-	if ( tr.fraction < 1 )

-	{

-		position->z = tr.endpos.z;

-	}

-}

-

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

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

-void AdjustStriderNodePosition( CAI_Network *pNetwork, CAI_Node *pNode )

-{

-	if ( pNode->GetHint() && pNode->GetHint()->HintType() == HINT_STRIDER_NODE )

-	{

-		CNPC_Strider *pStrider = (CNPC_Strider *)gEntList.FindEntityByClassname( NULL, "npc_strider" );

-		bool bCreated = false;

-		if ( !pStrider )

-		{

-			bool allowPrecache = CBaseEntity::IsPrecacheAllowed();

-			CBaseEntity::SetAllowPrecache( true );

-			pStrider = (CNPC_Strider *)CreateEntityByName( "npc_strider" );

-			pStrider->m_bDisableBoneFollowers = true; // don't create these since we're just going to destroy him

-			DispatchSpawn( pStrider );

-			CBaseEntity::SetAllowPrecache( allowPrecache );

-			bCreated = true;

-		}

-

-		if ( pStrider )

-		{

-			pStrider->TranslateNavGoal( NULL, pNode->AccessOrigin() );

-			if ( bCreated )

-				UTIL_Remove( pStrider );

-		}

-	}

-}

-

-

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

-// Implement a navigator so that the strider can get closer to the ground when he's walking on a slope

-// This gives him enough reach for his legs to IK to lower ground points

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

-void LookaheadPath( const Vector &current, AI_Waypoint_t *pWaypoint, float dist, Vector &nextPos )

-{

-	if ( !pWaypoint )

-		return;

-

-	Vector dir = pWaypoint->GetPos() - current;

-	float dist2D = dir.Length2D();

-	if ( dist2D > 0.1 )

-	{

-		if ( dist <= dist2D )

-		{

-			nextPos = ((dist / dist2D) * dir) + current;

-			return;

-		}

-	}

-	nextPos = pWaypoint->GetPos();

-	dist -= dist2D;

-	dir = nextPos;

-	

-	LookaheadPath( dir, pWaypoint->GetNext(), dist, nextPos );

-}

-

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

-// Find the forward slope and lower the strider height when moving downward

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

-void CNPC_Strider::CNavigator::MoveCalcBaseGoal( AILocalMoveGoal_t *pMoveGoal )

-{

-	BaseClass::MoveCalcBaseGoal( pMoveGoal );

-	Vector dest = pMoveGoal->target;

-	LookaheadPath( GetAbsOrigin(), pMoveGoal->pPath->GetCurWaypoint(), CNPC_Strider::gm_strideLength, dest );

-

-	//NDebugOverlay::Box( dest, Vector(-16,-16,-16), Vector(16,16,16), 0, 255, 0, 255, 0.1 );

-	Vector unitDir = pMoveGoal->dir * CNPC_Strider::gm_strideLength;

-	unitDir.z = dest.z - GetAbsOrigin().z;

-	VectorNormalize( unitDir );

-	float heightAdj = unitDir.z * CNPC_Strider::gm_strideLength;

-	pMoveGoal->flags |= ( AILMG_NO_STEER | AILMG_NO_AVOIDANCE_PATHS );

-	if ( heightAdj < -1 )

-	{

-		heightAdj = clamp( heightAdj, -192, 0 );

-		pMoveGoal->target.z += heightAdj;

-		pMoveGoal->dir = unitDir * CNPC_Strider::gm_strideLength * 0.1;

-		pMoveGoal->dir.z += heightAdj;

-		VectorNormalize( pMoveGoal->dir );

-	}

-}

-

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

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

-bool CNPC_Strider::CNavigator::MoveUpdateWaypoint( AIMoveResult_t *pResult )

-{

-	// Note that goal & waypoint tolerances are handled in progress blockage cases (e.g., OnObstructionPreSteer)

-

-	AI_Waypoint_t *pCurWaypoint = GetPath()->GetCurWaypoint();

-	float 		   waypointDist = (pCurWaypoint->GetPos() - GetAbsOrigin()).Length2D();

-	bool		   bIsGoal		= CurWaypointIsGoal();

-	// HACKHACK: adjust this tolerance

-	// The strider is following paths most of the time, but he needs a bunch of freedom

-	// to adjust himself to make his feet look good.

-	float		   tolerance	= 10.0;

-

-	if ( waypointDist <= tolerance )

-	{

-		if ( bIsGoal )

-		{

-			OnNavComplete();

-			*pResult = AIMR_OK;

-			

-		}

-		else

-		{

-			AdvancePath();

-			*pResult = AIMR_CHANGE_TYPE;

-		}

-		return true;

-	}

-	

-	return false;

-}

-

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

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

-bool CNPC_Strider::CNavigator::DoFindPathToPos()

-{

-	DbgNavMsg(  GetOuter(), "Strider overriding DoFindPathToPos\n");

-	if ( BaseClass::DoFindPathToPos() )

-	{

-		// Do special optimization on our first path segment

-		DbgNavMsg(  GetOuter(), "Strider base pathfind worked\n");

-		CAI_WaypointList waypoints( GetPath()->GetCurWaypoint() );

-		AI_Waypoint_t *pFirstWaypoint = waypoints.GetFirst();

-		AI_Waypoint_t *pLast = waypoints.GetLast();

-

-		if ( pFirstWaypoint->IsReducible() && 

-			 pFirstWaypoint->GetNext() && 

-			 pFirstWaypoint->GetNext()->iNodeID != NO_NODE && 

-			 pFirstWaypoint->GetNext()->NavType() == GetNavType() )

-		{

-			// Find nearest point on the line segment of our path

-			Vector vOrigin = GetOuter()->GetAbsOrigin();

-			Vector vClosest;

-			CalcClosestPointOnLineSegment( vOrigin,

-				pFirstWaypoint->GetPos(), 

-				pFirstWaypoint->GetNext()->GetPos(), 

-				vClosest );

-

-			// Find both these positions as offset from the ground

-			TranslateNavGoal( GetPath()->GetTarget(), vClosest );

-			TranslateNavGoal( GetPath()->GetTarget(), vOrigin );

-

-			// If we're seemingly beyond the waypoint and our hull is near enough to the path segment, advance to the next node

-			const float EPS = 0.1f;

-			bool bPastStartNode = ( ( pFirstWaypoint->GetPos() - vClosest ).Length() > EPS );

-			bool bNearPathSegment = ( ( vOrigin - vClosest ).Length() < GetHullWidth() * 0.5f );

-			if ( bPastStartNode && bNearPathSegment )

-			{

-				GetPath()->Advance();

-			}

-		}

-

-		if ( pLast->iNodeID == NO_NODE )

-		{

-			AI_Waypoint_t *pLastNodeWaypoint = pLast->GetPrev();

-

-			if ( pLastNodeWaypoint && pLastNodeWaypoint->iNodeID == NO_NODE )

-			{

-				// Pathfinder triangulated to goal

-				Assert( pLastNodeWaypoint->GetPrev() );

-				if ( pLastNodeWaypoint->GetPrev() )

-				{

-					pLastNodeWaypoint->GetPrev()->SetNext( pLast );

-					delete pLastNodeWaypoint;

-					pLastNodeWaypoint = pLast->GetPrev();

-				}

-			}

-

-			Assert( pLastNodeWaypoint );

-			if ( pLastNodeWaypoint )

-			{

-				Assert( pLastNodeWaypoint->iNodeID != NO_NODE );

-				if ( pLastNodeWaypoint->iNodeID != NO_NODE )

-				{

-					CAI_Node *pLastNode = GetNetwork()->GetNode( pLastNodeWaypoint->iNodeID );

-					float bestDistSq = ( pLast->vecLocation - pLastNodeWaypoint->vecLocation ).LengthSqr();

-					Vector vNewEnd = vec3_invalid;

-					int segmentDestClosest = NO_NODE;

-

-					for (int link=0; link < pLastNode->NumLinks();link++) 

-					{

-						CAI_Link *pLink = pLastNode->GetLinkByIndex(link);

-						if ( !( pLink->m_LinkInfo & bits_LINK_OFF ) && (pLink->m_iAcceptedMoveTypes[GetHullType()] & bits_CAP_MOVE_FLY) )

-						{

-							CAI_Node *pTestNode = GetNetwork()->GetNode( pLink->DestNodeID( pLastNodeWaypoint->iNodeID ) );

-							if ( pTestNode->GetHint() && pTestNode->GetHint()->HintType() == HINT_STRIDER_NODE )

-							{

-								Vector vClosest;

-								CalcClosestPointOnLineSegment( pLast->vecLocation, 

-															   pLastNodeWaypoint->vecLocation, pTestNode->GetPosition(GetHullType()), 

-															   vClosest );

-								float distTestSq = ( pLast->vecLocation - vClosest ).LengthSqr();

-								if ( distTestSq < bestDistSq )

-								{

-									bestDistSq = distTestSq;

-									vNewEnd = vClosest;

-									segmentDestClosest = pTestNode->GetId();

-								}

-							}

-						}

-					}

-					

-					if ( vNewEnd == vec3_invalid )

-					{

-						DbgNavMsg(  GetOuter(), "Strider resetting goal to last node waypoint\n");

-						pLastNodeWaypoint->SetNext( NULL );

-						pLastNodeWaypoint->ModifyFlags( bits_WP_TO_GOAL, true );

-						delete pLast;

-					}

-					else if ( !pLastNodeWaypoint->GetPrev() || pLastNodeWaypoint->GetPrev()->iNodeID != segmentDestClosest )

-					{

-						DbgNavMsg(  GetOuter(), "Strider resetting goal to nearest point on graph\n");

-						pLast->vecLocation = vNewEnd;

-					}

-					else

-					{

-						DbgNavMsg(  GetOuter(), "Strider resetting goal to nearest point on graph, on node\n");

-						pLastNodeWaypoint->vecLocation = vNewEnd;

-						pLastNodeWaypoint->SetNext( NULL );

-						pLastNodeWaypoint->ModifyFlags( bits_WP_TO_GOAL, true );

-						delete pLast;

-					}

-					GetPath()->ResetGoalPosition( GetPath()->GetGoalWaypoint()->vecLocation );

-				}

-			}

-		}

-		else

-			DbgNavMsg(  GetOuter(), "Goal ended on node\n");

-		return true;

-	}

-	else

-		DbgNavMsg(  GetOuter(), "Strider base pathfind failed\n");

-

-	return false;

-}

-

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

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

-bool CNPC_Strider::CNavigator::ShouldOptimizeInitialPathSegment( AI_Waypoint_t *pFirstWaypoint )

-{

-	// We do our own special initial path optimization DoFindPathToPos()

-	return false;

-}

-

-

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

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

-bool CNPC_Strider::CNavigator::GetStoppingPath( CAI_WaypointList *pClippedWaypoints )

-{

-	return false;

-}

-

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

-// Purpose: Returns if a bone follower is a leg piece or not

-// Input  : *pFollower - Bone follower we're testing

-// Output : Returns true if the bone follower is a part of the strider's legs

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

-bool CNPC_Strider::IsLegBoneFollower( CBoneFollower *pFollower )

-{

-	// Find the index of this bone follower, if we have it

-	int nFollowerIndex = GetBoneFollowerIndex( pFollower );

-	if ( nFollowerIndex	== -1 )

-		return false;

-

-	// See if we're a leg

-	if ( nFollowerIndex >= STRIDER_LEFT_LEG_FOLLOWER_INDEX &&

-		 nFollowerIndex <= STRIDER_BACK_UPPERLEG_FOLLOWER_INDEX )

-		 return true;

-

-	// We're something else

-	return false;

-}

-

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

-// Purpose: Finds a bone follower via a supplied index

-// Input  : nIndex - index our bone follower manager will use to retrieve the follower

-// Output : NULL if not found, otherwise the bone follower we were seeking

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

-CBoneFollower *CNPC_Strider::GetBoneFollowerByIndex( int nIndex )

-{

-	physfollower_t *pFollower = m_BoneFollowerManager.GetBoneFollower( nIndex );

-	if ( pFollower != NULL )

-		return pFollower->hFollower;

-	

-	return NULL;

-}

-

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

-// Purpose: Returns the index of a bone follower in our system

-// Input  : *pFollower - Follower we're looking for

-// Output : -1 if not found, otherwise the index of the follower

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

-int CNPC_Strider::GetBoneFollowerIndex( CBoneFollower *pFollower )

-{

-	return m_BoneFollowerManager.GetBoneFollowerIndex( pFollower );

-}

-

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

-// Purpose: The strider ignores certain entities this way

-// Input  : *pEntity - Entity in question

-// Output : Returns true if we should collide with the entity

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

-bool CNPC_Strider::ShouldProbeCollideAgainstEntity( CBaseEntity *pEntity )

-{

-	if ( pEntity->m_iClassname == m_iszStriderBusterName )

-		return false;

-

-	return BaseClass::ShouldProbeCollideAgainstEntity( pEntity );

-}

-

-

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

-// Purpose: Lets us keep track of attached Strider busters

-// Input  : *pAttached - strider buster that is attached

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

-#ifdef HL2_EPISODIC

-void CNPC_Strider::StriderBusterAttached( CBaseEntity *pAttached )

-{

-	// Add another to the list

-	m_hAttachedBusters.AddToTail( pAttached );

-	m_PlayerFreePass.Revoke();

-

-	variant_t target;

-	target.SetString( AllocPooledString( "!player" ) );

-	g_EventQueue.AddEvent( this, "UpdateEnemyMemory", target, 1.0, this, this );

-}

-

-

-void CNPC_Strider::StriderBusterDetached( CBaseEntity *pAttached )

-{

-	int elem = m_hAttachedBusters.Find(pAttached);

-	if (elem >= 0)

-	{

-		m_hAttachedBusters.FastRemove(elem);

-	}

-}

-

-#endif // HL2_EPISODIC

-

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

-//

-// Strider Minigun

-//

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

-

-BEGIN_DATADESC_NO_BASE( CStriderMinigun )

-

-	DEFINE_FIELD( m_enable,				FIELD_BOOLEAN ),

-	DEFINE_FIELD( m_minigunState,		FIELD_INTEGER ),

-	DEFINE_FIELD( m_nextBulletTime,		FIELD_TIME ),

-	DEFINE_FIELD( m_burstTime,			FIELD_TIME ),

-	DEFINE_FIELD( m_nextTwitchTime,		FIELD_TIME ),

-	DEFINE_FIELD( m_randomState,		FIELD_INTEGER ),

-	DEFINE_FIELD( m_hTarget,			FIELD_EHANDLE ),

-	DEFINE_FIELD( m_bWarnedAI,			FIELD_BOOLEAN ),

-	DEFINE_FIELD( m_shootDuration,		FIELD_TIME ),

-	DEFINE_FIELD( m_vecAnchor,			FIELD_VECTOR ),

-	DEFINE_FIELD( m_bOverrideEnemy,		FIELD_BOOLEAN ),

-	DEFINE_FIELD( m_vecLastTargetPos,	FIELD_VECTOR ),

-	DEFINE_FIELD( m_iOnTargetShots,		FIELD_INTEGER ),

-

-	// Silence, Classcheck!

-	// DEFINE_FIELD( m_yaw, StriderMinigunAnimController_t ),

-	// DEFINE_FIELD( m_pitch, StriderMinigunAnimController_t ),

-	

-	DEFINE_FIELD( m_yaw.current,		FIELD_FLOAT ),

-	DEFINE_FIELD( m_yaw.target,			FIELD_FLOAT ),

-	DEFINE_FIELD( m_yaw.rate,			FIELD_FLOAT ),

-	DEFINE_FIELD( m_pitch.current,		FIELD_FLOAT ),

-	DEFINE_FIELD( m_pitch.target,		FIELD_FLOAT ),

-	DEFINE_FIELD( m_pitch.rate,			FIELD_FLOAT ),

-

-

-END_DATADESC()

-

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

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

-void CStriderMinigun::Init()

-{

-	m_enable = true;

-	m_nextTwitchTime = gpGlobals->curtime;

-	m_randomState = 0;

-	m_yaw.current = m_yaw.target = 0;

-	m_pitch.current = m_pitch.target = 0;

-	m_yaw.rate = 360;

-	m_pitch.rate = 180;

-

-	SetState( MINIGUN_OFF );

-	m_burstTime = gpGlobals->curtime;

-	m_nextBulletTime = FLT_MAX;

-	m_vecAnchor = vec3_invalid;

-	m_shootDuration = STRIDER_DEFAULT_SHOOT_DURATION;

-	m_bOverrideEnemy = false;

-}

-

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

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

-bool CStriderMinigun::ShouldFindTarget( IMinigunHost *pHost )

-{

-	ASSERT( pHost != NULL );

-

-	if( !GetTarget() )

-	{

-		// No target. Find one.

-		return true;

-	}

-

-	if( m_bOverrideEnemy )

-	{

-		return false;

-	}

-

-	if( pHost->GetEntity()->GetEnemy() )

-	{

-		return GetTarget() != pHost->GetEntity()->GetEnemy();

-	}

-

-	return true;

-}

-

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

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

-float CStriderMinigun::GetAimError()

-{

-	return fabs(m_yaw.target-m_yaw.current) + fabs(m_pitch.target-m_pitch.current);

-}

-

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

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

-void CStriderMinigun::AimAtPoint( IStriderMinigunHost *pHost, const Vector &vecPoint, bool bSnap )

-{

-	matrix3x4_t gunMatrix;

-	CAI_BaseNPC *pOwner = pHost->GetEntity();

-

-	int mingunAttachment = pOwner->LookupAttachment( "minigunbase" );

-	pOwner->GetAttachment( mingunAttachment, gunMatrix );

-

-	Vector forward, pos;

-	MatrixGetColumn( gunMatrix, 0, forward );

-	MatrixGetColumn( gunMatrix, 3, pos );

-

-	// transform the point into gun space

-	Vector localPointPosition;

-	VectorITransform( vecPoint, gunMatrix, localPointPosition );

-	

-	// do a look at in gun space (essentially a delta-lookat)

-	QAngle localPointAngles;

-	VectorAngles( localPointPosition, localPointAngles );

-

-	// convert to +/- 180 degrees

-	float pdiff, ydiff;

-	pdiff = UTIL_AngleDiff( localPointAngles.x, 0 );

-	ydiff = UTIL_AngleDiff( localPointAngles.y, 0 );

-

-	m_pitch.target += 0.5 * pdiff;

-	m_yaw.target -= 0.5 * ydiff;

-

-	m_pitch.target = MAX( MINIGUN_MIN_PITCH, m_pitch.target );

-	m_pitch.target = MIN( MINIGUN_MAX_PITCH, m_pitch.target );

-	m_yaw.target = MAX( MINIGUN_MIN_YAW, m_yaw.target );

-	m_yaw.target = MIN( MINIGUN_MAX_YAW, m_yaw.target );

-}

-

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

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

-void CStriderMinigun::AimAtTarget( IStriderMinigunHost *pHost, CBaseEntity *pTarget, bool bSnap )

-{

-	if ( pTarget && !(CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI) )

-	{

-		Vector vecTargetPos = pTarget->BodyTarget( pHost->GetEntity()->EyePosition() );

-		AimAtPoint( pHost, vecTargetPos, bSnap );

-	}

-}

-

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

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

-void CStriderMinigun::ShootAtTarget( IStriderMinigunHost *pHost, CBaseEntity *pTarget, float shootTime )

-{

-	if ( !pTarget && !(CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI) )

-		return;

-

-	variant_t emptyVariant;

-	pTarget->AcceptInput( "InputTargeted", pHost->GetEntity(), pHost->GetEntity(), emptyVariant, 0 );

-	Enable( NULL, true );

-	if ( shootTime <= 0 )

-	{

-		shootTime = random->RandomFloat( 4, 8 );

-	}

-	SetTarget( pHost, pTarget, true );

-

-	StartShooting( pHost, pTarget, shootTime );

-}

-

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

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

-void CStriderMinigun::StartShooting( IStriderMinigunHost *pHost, CBaseEntity *pTarget, float duration )

-{

-	bool bHasSetAnchor = false;

-

-	SetState( MINIGUN_SHOOTING );

-	

-	m_nextBulletTime = gpGlobals->curtime;

-	m_burstTime = gpGlobals->curtime + duration;

-

-	m_shootDuration = duration;

-

-	// don't twitch while shooting

-	m_nextTwitchTime = FLT_MAX;

-

-	if( pTarget->IsPlayer() )

-	{

-		// Don't shoot a player in the back if they aren't looking. 

-		// Give them a chance to see they're being fired at.

-		CBasePlayer *pPlayer = dynamic_cast<CBasePlayer*>(pTarget);

-

-		if( !pPlayer->FInViewCone( pHost->GetEntity() ) )

-		{

-			// Player doesn't see me. Try to start shooting so that they can see

-			// the bullet impacts.

-			m_vecAnchor = pPlayer->EyePosition();

-

-			Vector vecPlayerLook;

-			Vector vecToPlayer;

-

-			// Check in 2D.

-			vecPlayerLook = pPlayer->EyeDirection3D();

-			vecPlayerLook.z = 0.0;

-			VectorNormalize( vecPlayerLook );

-

-			vecToPlayer = pPlayer->EyePosition() - pHost->GetEntity()->EyePosition();

-			vecToPlayer.z = 0.0;

-			VectorNormalize( vecToPlayer );

-

-			float flDot = DotProduct( vecToPlayer, vecPlayerLook );

-

-			if( flDot < 0.95 )

-			{

-				// If the player is looking sufficiently to a side, start 30 feet out in that direction.

-				m_vecAnchor += pPlayer->EyeDirection3D() * 320;

-				bHasSetAnchor = true;

-			}

-			else

-			{

-				// Start over their head, cause firing the direction they are looking will drill them.

-				// in the back!

-				m_vecAnchor += Vector( 0, 0, random->RandomFloat( 160, 240 ) );

-

-				// Move it to one side of the other randomly, just to get it off center.

-				Vector right;

-				pPlayer->GetVectors( NULL, &right, NULL );

-				m_vecAnchor += right * random->RandomFloat( -100, 100 );

-				bHasSetAnchor = true;

-			}

-		}

-	}

-

-	if( !bHasSetAnchor )

-	{

-		m_vecAnchor = pTarget->WorldSpaceCenter();

-

-		Vector right;

-		pTarget->GetVectors( NULL, &right, NULL );

-

-		// Start 5 or 10 feet off target.

-		Vector offset = right * random->RandomFloat( 60, 120 );

-		

-		// Flip a coin to decide left or right.

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

-		{

-			offset *= -1;

-		}

-

-		m_vecAnchor += offset;

-

-		// Start below them, too.

-		m_vecAnchor.z -= random->RandomFloat( 80, 200 );

-	}

-

-	pHost->OnMinigunStartShooting( pTarget );

-}

-

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

-// Fixes up the math for stitching.

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

-void CStriderMinigun::ExtendShooting( float timeExtend )

-{

-	m_burstTime = gpGlobals->curtime + timeExtend;

-	m_shootDuration = timeExtend;

-	m_bWarnedAI = false;

-}

-

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

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

-void CStriderMinigun::SetShootDuration( float duration )

-{

-}

-

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

-// Is the gun turned as far as it can go?

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

-bool CStriderMinigun::IsPegged( int dir )

-{

-	bool up, down, left, right, any;

-

-	up = down = left = right = any = false;

-

-	if( m_yaw.current >= 89.0 )

-		any = right = true;

-

-	if( m_yaw.current <= -89.0 )

-		any = left = true;

-

-	if( m_pitch.current >= 44.0 )

-		any = down = true;

-

-	if( m_pitch.current <= -44.0 )

-		any = up = true;

-

-	switch( dir )

-	{

-	case MINIGUN_PEGGED_UP:

-		return up;

-

-	case MINIGUN_PEGGED_DOWN:

-		return down;

-

-	case MINIGUN_PEGGED_LEFT:

-		return left;

-

-	case MINIGUN_PEGGED_RIGHT:

-		return right;

-

-	default:

-		return (any && !up);

-	}

-}

-

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

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

-void CStriderMinigun::StopShootingForSeconds( IStriderMinigunHost *pHost, CBaseEntity *pTarget, float duration )

-{

-	if ( IsShooting() )

-	{

-		SetState( MINIGUN_OFF );

-	}

-

-	m_burstTime = gpGlobals->curtime + duration;

-	m_nextBulletTime = FLT_MAX;

-

-	ClearOnTarget();

-	m_nextTwitchTime = gpGlobals->curtime + random->RandomFloat( 2.0, 4.0 );

-	pHost->OnMinigunStopShooting( pTarget );

-}

-

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

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

-void CStriderMinigun::SetState( int newState )

-{

-	m_minigunState = newState;

-}

-

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

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

-void CStriderMinigun::SetTarget( IStriderMinigunHost *pHost, CBaseEntity *pTarget, bool bOverrideEnemy )

-{

-	m_hTarget = pTarget;

-

-	if( pTarget )

-	{

-		// New target, we haven't scared this guy yet!

-		m_bWarnedAI = false;

-

-		if( m_vecAnchor == vec3_invalid )

-		{

-			Vector right;

-			pHost->GetEntity()->GetVectors( NULL, &right, NULL );

-

-			m_vecAnchor = pTarget->GetAbsOrigin() - Vector( 0, 0, 256 );

-			m_vecAnchor += right * random->RandomFloat( -60.0f, 60.0f );

-		}

-	}

-

-	ClearOnTarget();

-

-	m_bOverrideEnemy = bOverrideEnemy;

-}

-

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

-// The strider minigun can track and fire at targets in a fairly

-// large arc. It looks unnatural for a Strider to acquire a target

-// off to one side and begin firing at it, so we don't let the

-// minigun BEGIN shooting at a target unless the target is fairly

-// well in front of the Strider. Once firing, the gun is allowed

-// to track the target anywhere for the duration of that burst of

-// minigun fire. This is tuned by eye. (sjb)

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

-bool CStriderMinigun::CanStartShooting( IStriderMinigunHost *pHost, CBaseEntity *pTargetEnt )

-{

-	if ( CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI )

-		return false;

-

-	if( !pTargetEnt )

-		return false;

-	

-	if( gpGlobals->curtime < m_burstTime )

-		return false;

-

-	CNPC_Strider *pStrider = dynamic_cast<CNPC_Strider *>(pHost->GetEntity() );

-	if ( pTargetEnt->IsPlayer() && pStrider->HasPass() )

-		return false;

-

-	if( !m_bOverrideEnemy )

-	{

-		if( pTargetEnt != pHost->GetEntity()->GetEnemy() )

-		{

-			return false;

-		}

-

-		// If the strider can't see the enemy, this may be because the enemy is

-		// hiding behind something breakable. If the weapon has LOS, fire away.

-		if( !pHost->GetEntity()->HasCondition( COND_SEE_ENEMY )  )

-		{

-			Assert( pStrider != NULL );

-

-			if( !pStrider->WeaponLOSCondition( pStrider->GetAdjustedOrigin(), pTargetEnt->WorldSpaceCenter(), false ) )

-			{

-				if( pStrider->IsUsingAggressiveBehavior() && pTargetEnt->IsPlayer() && !pStrider->HasPass() )

-				{

-					// I can shoot the player's cover until he hides long enough to earn a free pass.

-					float flTimeSinceLastSeen = gpGlobals->curtime - pStrider->GetEnemies()->LastTimeSeen(pTargetEnt);

-

-					if( flTimeSinceLastSeen <= 2.0f )

-						return true;

-				}

-

-				return false;

-			}

-		}

-	}

-	

-	Vector los = ( pTargetEnt->WorldSpaceCenter() - pHost->GetEntity()->EyePosition() );

-

-	// Following code stolen from FVisible. This check done in 2d intentionally.

-	los.z = 0;

-	VectorNormalize( los );

-

-	Vector facingDir = pHost->GetEntity()->EyeDirection2D( );

-	float flDot = DotProduct( los, facingDir );

-

-	// Too far to a side.

-	if ( flDot <= .707 )

-		return false;

-

-	return true;

-}

-

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

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

-void CStriderMinigun::Enable( IMinigunHost *pHost, bool enable )

-{

-	m_enable = enable;

-	if ( !m_enable )

-	{

-		m_yaw.current = m_yaw.target = 0;

-		m_pitch.current = m_pitch.target = 0;

-		if ( pHost )

-		{

-			// KENB pHost->UpdateMinigunControls( m_yaw.current, m_pitch.current );

-		}

-	}

-}

-

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

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

-void CStriderMinigun::Think( IStriderMinigunHost *pHost, float dt )

-{

-	if ( !m_enable )

-		return;

-

-	if ( CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI )

-		return;

-

-	if( ShouldFindTarget( pHost ) )

-	{

-		CBaseEntity *pOldTarget = GetTarget();

-

-		// Take my host's enemy.

-		SetTarget( pHost, pHost->GetEntity()->GetEnemy() );

-		

-		if( IsShooting() )

-		{

-			// Changing targets hot! 

-			if( pOldTarget )

-			{

-				m_vecAnchor = pOldTarget->WorldSpaceCenter();

-			}

-

-			ExtendShooting( STRIDER_SUBSEQUENT_TARGET_DURATION + random->RandomFloat( 0, 0.5 ) );

-		}

-		

-		pHost->NewTarget();

-	}

-

-	if ( !GetTarget() && m_nextTwitchTime <= gpGlobals->curtime )

-	{

-		// invert one and randomize the other.

-		// This has the effect of making the gun cross the field of

-		// view more often - like he's looking around

-		m_randomState = !m_randomState;

-		if ( m_randomState )

-		{

-			m_yaw.Random( MINIGUN_MIN_YAW, MINIGUN_MAX_YAW, 360, 720 );

-			m_pitch.target = -m_pitch.target;

-		}

-		else

-		{

-			m_pitch.Random( MINIGUN_MIN_PITCH, MINIGUN_MAX_PITCH, 270, 360 );

-			m_yaw.target = -m_yaw.target;

-		}

-		m_nextTwitchTime = gpGlobals->curtime + random->RandomFloat( 0.3, 2 );

-	}

-

-	CBaseEntity *pTargetEnt = m_hTarget.Get();

-

-	if ( pTargetEnt )

-	{

-		pHost->GetEntity()->InvalidateBoneCache();

-		AimAtTarget( pHost, pTargetEnt );

-	}

-

-	// Update the minigun's pose parameters using approaching. 

-	m_yaw.Update( dt );

-	m_pitch.Update( dt );

-

-	pHost->UpdateMinigunControls( m_yaw.current, m_pitch.current );

-

-	// Start or stop shooting.

-	if( IsShooting() )

-	{

-		if( gpGlobals->curtime > m_burstTime || !pTargetEnt )

-		{

-			// Time to stop firing.

-			if( m_bOverrideEnemy )

-			{

-				// Get rid of this target.

-				SetTarget( pHost, NULL );

-			}

-

-			StopShootingForSeconds( pHost, pTargetEnt, pHost->GetMinigunShootDowntime() );

-		}

-	}

-	else

-	{

-		if( CanStartShooting( pHost, pTargetEnt ) )

-		{

-			StartShooting( pHost, pTargetEnt, pHost->GetMinigunShootDuration() + random->RandomFloat( 0, pHost->GetMinigunShootVariation() ) );

-		}

-	}

-

-	// Fire the next bullet!

-	if ( m_nextBulletTime <= gpGlobals->curtime && !IsPegged() )

-	{

-		if( pTargetEnt && pTargetEnt == pHost->GetEntity()->GetEnemy() )

-		{

-			// Shooting at the Strider's enemy. Strafe to target!

-			float flRemainingShootTime = m_burstTime - gpGlobals->curtime;

-

-			// Skim a little time off of the factor, leave a moment of on-target

-			// time. This guarantees that the minigun will strike the target a few times.

-			float flFactor = (flRemainingShootTime - pHost->GetMinigunOnTargetTime() ) / m_shootDuration;

-

-			flFactor = MAX( 0.0f, flFactor );

-

-			Vector vecTarget = pTargetEnt->BodyTarget( assert_cast<CNPC_Strider *>(pHost->GetEntity())->GetAdjustedOrigin());

-

-			Vector vecLine = m_vecAnchor - vecTarget;

-			

-			float flDist = VectorNormalize( vecLine );

-

-			vecTarget += vecLine * flDist * flFactor;

-

-			if( flFactor == 0.0 )

-			{

-				m_vecAnchor = vecTarget;

-				RecordShotOnTarget();

-			}

-

-			if ( GetTarget() )

-			{

-				pHost->ShootMinigun( &vecTarget, GetAimError(), vec3_origin );

-

-				if( flFactor <= 0.5 && !m_bWarnedAI )

-				{

-					m_bWarnedAI = true;

-

-					CSoundEnt::InsertSound( SOUND_DANGER | SOUND_CONTEXT_REACT_TO_SOURCE, pTargetEnt->EarPosition() + Vector( 0, 0, 1 ), 120, MAX( 1.0, flRemainingShootTime ), pHost->GetEntity() );

-				}

-			}

-		}

-		else

-		{

-			const Vector *pTargetPoint = pTargetEnt ? &pTargetEnt->GetAbsOrigin() : NULL;

-			pHost->ShootMinigun( pTargetPoint, GetAimError() );

-		}

-

-		m_nextBulletTime = gpGlobals->curtime + (1.0f / pHost->GetMinigunRateOfFire() );

-	}

-}

-

-LINK_ENTITY_TO_CLASS( sparktrail, CSparkTrail );

-

-void CSparkTrail::Precache()

-{

-	BaseClass::Precache();

-

-	PrecacheScriptSound( "DoSpark" );

-}

-

-void CSparkTrail::Spawn()

-{

-	Precache();

-

-	EmitSound( "DoSpark" );

-

-	m_iHealth = 20 + random->RandomInt( 0, 5 );

-	UTIL_SetOrigin( this, GetOwnerEntity()->EyePosition() );

-

-	Vector vecVelocity;

-

-	vecVelocity.x = random->RandomFloat( 100, 400 );

-	vecVelocity.y = random->RandomFloat( 100, 400 );

-	vecVelocity.z = random->RandomFloat( 0, 100 );

-	

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

-		vecVelocity.x *= -1;

-

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

-		vecVelocity.y *= -1;

-

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

-	SetMoveType( MOVETYPE_FLYGRAVITY );

-	SetSolid( SOLID_NONE );

-

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

-	{

-		vecVelocity *= 2.0;

-		m_iHealth /= 2;

-		SetMoveType( MOVETYPE_FLY );

-	}

-

-	SetAbsVelocity( vecVelocity );

-

-	SetThink( &CSparkTrail::SparkThink );

-	SetNextThink( gpGlobals->curtime );

-}

-

-void CSparkTrail::SparkThink()

-{

-	SetNextThink( gpGlobals->curtime + 0.05 );

-

-	g_pEffects->Sparks( GetAbsOrigin() );

-

-	if( m_iHealth-- < 1 )

-	{

-		UTIL_Remove( this );

-	}

-}

-

-BEGIN_DATADESC( CSparkTrail )

-	DEFINE_THINKFUNC( SparkThink ),

-END_DATADESC()

-

-

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

-//

-// Schedules

-//

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

-AI_BEGIN_CUSTOM_NPC( npc_strider, CNPC_Strider )

-

-	DECLARE_TASK( TASK_STRIDER_AIM )

-	DECLARE_TASK( TASK_STRIDER_DODGE )

-	DECLARE_TASK( TASK_STRIDER_STOMP )

-	DECLARE_TASK( TASK_STRIDER_BREAKDOWN )

-	DECLARE_TASK( TASK_STRIDER_START_MOVING )

-	DECLARE_TASK( TASK_STRIDER_REFRESH_HUNT_PATH )

-	DECLARE_TASK( TASK_STRIDER_GET_PATH_TO_CANNON_TARGET )

-	DECLARE_TASK( TASK_STRIDER_FACE_CANNON_TARGET )

-	DECLARE_TASK( TASK_STRIDER_SET_HEIGHT )

-	DECLARE_TASK( TASK_STRIDER_GET_PATH_TO_CANNON_LOS )

-	DECLARE_TASK( TASK_STRIDER_FIRE_CANNON )

-	DECLARE_TASK( TASK_STRIDER_SET_CANNON_HEIGHT )

-	DECLARE_TASK( TASK_STRIDER_FALL_TO_GROUND )

-

-	DECLARE_ACTIVITY( ACT_STRIDER_LOOKL )

-	DECLARE_ACTIVITY( ACT_STRIDER_LOOKR )

-	DECLARE_ACTIVITY( ACT_STRIDER_DEPLOYRA1 )

-	DECLARE_ACTIVITY( ACT_STRIDER_AIMRA1 )

-	DECLARE_ACTIVITY( ACT_STRIDER_FINISHRA1 )

-	DECLARE_ACTIVITY( ACT_STRIDER_DODGER )

-	DECLARE_ACTIVITY( ACT_STRIDER_DODGEL )

-	DECLARE_ACTIVITY( ACT_STRIDER_STOMPL )

-	DECLARE_ACTIVITY( ACT_STRIDER_STOMPR )

-	DECLARE_ACTIVITY( ACT_STRIDER_FLICKL )

-	DECLARE_ACTIVITY( ACT_STRIDER_FLICKR )

-	DECLARE_ACTIVITY( ACT_STRIDER_SLEEP )

-	DECLARE_ACTIVITY( ACT_STRIDER_CARRIED )

-	DECLARE_ACTIVITY( ACT_STRIDER_DEPLOY )

-	DECLARE_ACTIVITY( ACT_STRIDER_GESTURE_DEATH )

-

-	DECLARE_CONDITION( COND_STRIDER_DO_FLICK )

-	DECLARE_CONDITION( COND_TRACK_PATH_GO )

-	DECLARE_CONDITION( COND_STRIDER_SHOULD_CROUCH )

-	DECLARE_CONDITION( COND_STRIDER_SHOULD_STAND )

-	DECLARE_CONDITION( COND_STRIDER_MINIGUN_SHOOTING )

-	DECLARE_CONDITION( COND_STRIDER_MINIGUN_NOT_SHOOTING )

-	DECLARE_CONDITION( COND_STRIDER_HAS_CANNON_TARGET )

-	DECLARE_CONDITION( COND_STRIDER_ENEMY_UPDATED )

-	DECLARE_CONDITION( COND_STRIDER_HAS_LOS_Z )

-

-	DECLARE_INTERACTION( g_interactionPlayerLaunchedRPG )

-	

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

-	// Hunt (Basic logic for strider thinking)

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_STRIDER_HUNT,

-

-		"	Tasks"

-		"		TASK_STRIDER_REFRESH_HUNT_PATH 0"

-		"		TASK_STRIDER_START_MOVING	0"

-		"		TASK_WAIT					4"

-		"	"

-		"	Interrupts"

-		"		COND_NEW_ENEMY"

-		"		COND_CAN_MELEE_ATTACK1"

-		"		COND_CAN_RANGE_ATTACK1"

-		"		COND_CAN_RANGE_ATTACK2"

-		"		COND_STRIDER_SHOULD_CROUCH"

-		"		COND_STRIDER_HAS_CANNON_TARGET"

-		"		COND_STRIDER_ENEMY_UPDATED"

-	)

-

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

-	// Attack (Deploy/shoot/finish)

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_STRIDER_RANGE_ATTACK1,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING		0"

-		"		TASK_SET_ACTIVITY		ACTIVITY:ACT_IDLE"

-		"		TASK_FACE_ENEMY			0"

-		"		TASK_RANGE_ATTACK1		0"

-		"		TASK_WAIT				5" // let the immolator work its magic

-		"	"

-		"	Interrupts"

-	)

-

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

-	// Attack (Deploy/shoot/finish)

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_STRIDER_RANGE_ATTACK2,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING					0"

-		"		TASK_STRIDER_FACE_CANNON_TARGET		0"

-		"		TASK_SET_ACTIVITY					ACTIVITY:ACT_IDLE"

-		"		TASK_WAIT							1"

-		"		TASK_STRIDER_AIM					1.25"

-		"		TASK_STRIDER_FIRE_CANNON			0"

-		"		TASK_WAIT							1"

-		"	"

-		"	Interrupts"

-	)

-

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

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_STRIDER_CROUCH,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING		0"

-		"		TASK_PLAY_SEQUENCE		ACTIVITY:ACT_CROUCH"

-		"	"

-		"	Interrupts"

-	)

-

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

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_STRIDER_STAND,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING		0"

-		"		TASK_PLAY_SEQUENCE		ACTIVITY:ACT_STAND"

-		"		TASK_SET_ACTIVITY		ACTIVITY:ACT_IDLE"

-		"		TASK_STRIDER_SET_HEIGHT	500"

-		"	"

-		"	Interrupts"

-	)

-

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

-	// Dodge Incoming missile

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_STRIDER_DODGE,

-

-		"	Tasks"

-		"		TASK_STRIDER_DODGE		0"

-		"	"

-		"	Interrupts"

-	)

-

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

-	// Break down and die

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_STRIDER_DIE,

-

-		"	Tasks"

-		"		TASK_STRIDER_BREAKDOWN		0"

-		"	"

-		"	Interrupts"

-	)

-	

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

-	// Stomp on an enemy

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_STRIDER_STOMPL,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING		0"

-		"		TASK_STRIDER_STOMP		0"

-		"	"

-		"	Interrupts"

-	);		

-

-	// Stomp on an enemy

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

-	DEFINE_SCHEDULE

-	(

-		SCHED_STRIDER_STOMPR,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING		0"

-		"		TASK_STRIDER_STOMP		1"

-		"	"

-		"	Interrupts"

-	)

-

-	DEFINE_SCHEDULE

-	(

-		SCHED_STRIDER_FLICKL,

-

-		"	Tasks"

-		"		TASK_PLAY_SEQUENCE		ACTIVITY:ACT_STRIDER_FLICKL"

-		"	"

-		"	Interrupts"

-	)

-	DEFINE_SCHEDULE

-	(

-		SCHED_STRIDER_FLICKR,

-

-		"	Tasks"

-		"		TASK_PLAY_SEQUENCE		ACTIVITY:ACT_STRIDER_FLICKR"

-		"	"

-		"	Interrupts"

-	)

-	DEFINE_SCHEDULE

-	(

-		SCHED_STRIDER_ATTACK_CANNON_TARGET,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING							0"

-		"		TASK_STRIDER_GET_PATH_TO_CANNON_TARGET		0"

-		"		TASK_WALK_PATH								0"

-		"		TASK_WAIT_FOR_MOVEMENT						0"

-		"	"

-		"	Interrupts"

-		"		COND_CAN_RANGE_ATTACK2"

-		"		COND_STRIDER_SHOULD_CROUCH"

-	)

-

-	DEFINE_SCHEDULE

-	(

-		SCHED_STRIDER_CHASE_ENEMY,

-

-		"	Tasks"

-		"		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_MELEE_ATTACK1"

-		"		COND_CAN_RANGE_ATTACK2"

-		"		COND_CAN_MELEE_ATTACK2"

-		"		COND_TOO_CLOSE_TO_ATTACK"

-		"		COND_LOST_ENEMY"

-		"		COND_STRIDER_HAS_CANNON_TARGET"

-	)

-

-	DEFINE_SCHEDULE

-	(

-		SCHED_STRIDER_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"

-		"		COND_STRIDER_HAS_CANNON_TARGET"

-	)

-

-	DEFINE_SCHEDULE

-	(

-		SCHED_STRIDER_AGGRESSIVE_COMBAT_STAND,

-

-		"	Tasks"

-		"		TASK_STOP_MOVING			0"

-		"		TASK_SET_ACTIVITY			ACTIVITY:ACT_IDLE"

-		"		TASK_WAIT					1"

-		""

-		"	Interrupts"

-		"		COND_NEW_ENEMY"

-		"		COND_ENEMY_DEAD"

-		"		COND_LIGHT_DAMAGE"

-		"		COND_HEAVY_DAMAGE"

-		"		COND_SEE_ENEMY"

-		"		COND_CAN_RANGE_ATTACK1"

-		"		COND_CAN_RANGE_ATTACK2"

-		"		COND_CAN_MELEE_ATTACK1"

-		"		COND_CAN_MELEE_ATTACK2"

-		"		COND_IDLE_INTERRUPT"

-	)

-

-	DEFINE_SCHEDULE

-	(

-		SCHED_STRIDER_ESTABLISH_LINE_OF_FIRE_CANNON,

-

-		"	Tasks "

-		"		TASK_STRIDER_GET_PATH_TO_CANNON_LOS		0"

-		"		TASK_RUN_PATH							0"

-		"		TASK_WAIT_FOR_MOVEMENT					0"

-		"		TASK_STRIDER_FACE_CANNON_TARGET			0"

-		""

-		"	Interrupts "

-		"		COND_CAN_RANGE_ATTACK2"

-		"		COND_STRIDER_SHOULD_CROUCH"

-		"		COND_STRIDER_SHOULD_STAND"

-	)

-

-	DEFINE_SCHEDULE

-	(

-		SCHED_STRIDER_FALL_TO_GROUND,

-

-		"	Tasks "

-		"		TASK_STRIDER_FALL_TO_GROUND		0"

-		""

-		"	Interrupts "

-	)

-

-

-AI_END_CUSTOM_NPC()

-

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

+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Giant walking strider thing!
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+
+#include "npc_strider.h"
+
+#include "ai_senses.h"
+#include "ai_task.h"
+#include "ai_default.h"
+#include "ai_schedule.h"
+#include "ai_hull.h"
+#include "ai_basenpc.h"
+#include "ai_pathfinder.h"
+#include "ai_waypoint.h"
+#include "ai_link.h"
+#include "ai_hint.h"
+#include "ai_tacticalservices.h"
+#include "ai_behavior_follow.h"
+#include "simtimer.h"
+#include "trains.h"
+#include "npcevent.h"
+#include "te_particlesystem.h"
+#include "shake.h"
+#include "soundent.h"
+#include "IEffects.h"
+#include "engine/IEngineSound.h"
+#include "bone_setup.h"
+#include "vcollide_parse.h"
+#include "studio.h"
+#include "physics_bone_follower.h"
+#include "ai_navigator.h"
+#include "ai_route.h"
+#include "ammodef.h"
+#include "npc_bullseye.h"
+#include "rope.h"
+#include "ai_memory.h"
+#include "player_pickup.h"
+#include "collisionutils.h"
+#include "in_buttons.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 "filters.h"
+#include "saverestore_utlvector.h"
+#include "eventqueue.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+int g_interactionPlayerLaunchedRPG = 0;
+
+// Changing this classname avoids bugs where ai_relationship entities that change the
+// strider's relationship with bullseyes would affect its relationship with the focus
+LINK_ENTITY_TO_CLASS( bullseye_strider_focus, CNPC_Bullseye );
+
+
+//-----------------------------------------------------------------------------
+
+ConVar strider_immolate( "strider_immolate", "0" );
+ConVar sk_strider_health( "sk_strider_health", "350" );
+ConVar npc_strider_height_adj("npc_strider_height_adj", "0" );
+ConVar strider_eyepositions( "strider_eyepositions", "0" );
+ConVar strider_show_focus( "strider_show_focus", "0" );
+ConVar strider_distributed_fire( "strider_distributed_fire", "1" );
+ConVar strider_show_cannonlos( "strider_show_cannonlos", "0" );
+ConVar strider_show_weapon_los_z( "strider_show_weapon_los_z", "0" );
+ConVar strider_show_weapon_los_condition( "strider_show_weapon_los_condition", "0" );
+ConVar strider_idle_test( "strider_idle_test", "0" );
+ConVar strider_always_use_procedural_height( "strider_always_use_procedural_height", "0" );
+ConVar strider_test_height( "strider_test_height", "0" );
+ConVar strider_pct_height_no_crouch_move( "strider_pct_height_no_crouch_move", "90" );
+
+ConVar strider_peek_time( "strider_peek_time", "0.75" );
+ConVar strider_peek_time_after_damage( "strider_peek_time_after_damage", "4.0" );
+ConVar strider_peek_eye_dist( "strider_peek_eye_dist", "1.75" );
+ConVar strider_peek_eye_dist_z( "strider_peek_eye_dist_z", "4.0" );
+ConVar strider_free_pass_start_time( "strider_free_pass_start_time", "3" );
+ConVar strider_free_pass_cover_dist( "strider_free_pass_cover_dist", "120" );
+ConVar strider_free_pass_duration( "strider_free_pass_duration", "2" );
+ConVar strider_free_pass_refill_rate( "strider_free_pass_refill_rate", "0.5" );
+ConVar strider_free_pass_move_tolerance( "strider_free_pass_move_tolerance", "320" );
+ConVar strider_free_knowledge( "strider_free_knowledge", "0.5" );
+
+ConVar strider_free_pass_after_escorts_dead( "strider_free_pass_after_escorts_dead", "2.5" );
+ConVar strider_free_pass_tolerance_after_escorts_dead( "strider_free_pass_tolerance_after_escorts_dead", "600" );
+
+ConVar npc_strider_shake_ropes_radius( "npc_strider_shake_ropes_radius", "1200" );
+ConVar npc_strider_shake_ropes_magnitude( "npc_strider_shake_ropes_magnitude", "150" );
+
+ConVar strider_ar2_altfire_dmg( "strider_ar2_altfire_dmg", "25" );
+
+// Number of RPG hits it takes to kill a strider on each skill level.
+ConVar sk_strider_num_missiles1("sk_strider_num_missiles1", "5");
+ConVar sk_strider_num_missiles2("sk_strider_num_missiles2", "7");
+ConVar sk_strider_num_missiles3("sk_strider_num_missiles3", "7");
+
+ConVar strider_missile_suppress_dist( "strider_missile_suppress_dist", "240" );
+ConVar strider_missile_suppress_time( "strider_missile_suppress_time", "3" );
+
+
+//-----------------------------------------------------------------------------
+
+float GetCurrentGravity( void );
+
+extern void CreateConcussiveBlast( const Vector &origin, const Vector &surfaceNormal, CBaseEntity *pOwner, float magnitude );
+
+//-----------------------------------------------------------------------------
+
+enum bodygroups
+{
+	STRIDER_BODYGROUP_VENT = 1,
+};
+
+//-----------------------------------------------------------------------------
+
+#define STRIDER_DEFAULT_SHOOT_DURATION			2.5 // spend this much time stitching to each target.
+#define STRIDER_SHOOT_ON_TARGET_TIME			0.5 // How much of DEFAULT_SHOOT_DURATION is spent on-target (vs. stitching up to a target)
+#define STRIDER_SHOOT_VARIATION					1.0 // up to 1 second of variance
+#define STRIDER_SHOOT_DOWNTIME					1.0 // This much downtime between bursts
+#define STRIDER_SUBSEQUENT_TARGET_DURATION		1.5 // Spend this much time stitching to targets chosen by distributed fire.
+#define STRIDER_IGNORE_TARGET_DURATION			1.0
+#define STRIDER_IGNORE_PLAYER_DURATION			1.5
+#define STRIDER_DEFAULT_RATE_OF_FIRE			5	// Rounds per second
+
+#define STRIDER_EP1_RATE_OF_FIRE			10.0f
+#define STRIDER_EP1_SHOOT_ON_TARGET_TIME	 0.3f
+#define STRIDER_EP1_SHOOT_DURATION			 1.1f
+#define STRIDER_EP1_SHOOT_DOWNTIME			 1.0f
+#define STRIDER_EP1_SHOOT_VARIATION			 0.3f
+
+//Animation events
+#define STRIDER_AE_FOOTSTEP_LEFT		1
+#define STRIDER_AE_FOOTSTEP_RIGHT		2
+#define STRIDER_AE_FOOTSTEP_BACK		3
+#define STRIDER_AE_FOOTSTEP_LEFTM		4
+#define STRIDER_AE_FOOTSTEP_RIGHTM		5
+#define STRIDER_AE_FOOTSTEP_BACKM		6
+#define STRIDER_AE_FOOTSTEP_LEFTL		7
+#define STRIDER_AE_FOOTSTEP_RIGHTL		8
+#define STRIDER_AE_FOOTSTEP_BACKL		9
+#define STRIDER_AE_WHOOSH_LEFT			11
+#define STRIDER_AE_WHOOSH_RIGHT			12
+#define STRIDER_AE_WHOOSH_BACK			13
+#define STRIDER_AE_CREAK_LEFT			21
+#define STRIDER_AE_CREAK_RIGHT			22
+#define STRIDER_AE_CREAK_BACK			23
+#define STRIDER_AE_SHOOTCANNON			100
+#define STRIDER_AE_CANNONHIT			101
+#define STRIDER_AE_SHOOTMINIGUN			105
+#define STRIDER_AE_STOMPHITL			110
+#define STRIDER_AE_STOMPHITR			111
+#define STRIDER_AE_FLICKL				112
+#define STRIDER_AE_FLICKR				113
+#define STRIDER_AE_WINDUPCANNON			114
+
+#define STRIDER_AE_DIE					999
+
+// UNDONE: Share properly with the client code!!!
+#define STRIDER_MSG_BIG_SHOT			1
+#define STRIDER_MSG_STREAKS				2
+#define STRIDER_MSG_DEAD				3
+#define STOMP_IK_SLOT					11
+
+// can hit anything within this range
+#define STRIDER_STOMP_RANGE				260
+
+// Crouch down if trying to shoot an enemy that's this close
+#define STRIDER_CROUCH_RANGE			4000.0f
+
+// Stand up again if crouched and engaging an enemy at this distance
+#define STRIDER_STAND_RANGE				6000.0f
+
+#define STRIDER_NO_TRACK_NAME			"null"
+
+// Time after which if you haven't seen your enemy you stop facing him
+#define STRIDER_TIME_STOP_FACING_ENEMY 3.0 
+
+// Spawnflags
+enum
+{
+	SF_CAN_STOMP_PLAYER					= 0x10000,
+	SF_TAKE_MINIMAL_DAMAGE_FROM_NPCS	= 0x20000
+};
+
+const float STRIDER_SPEED = 500;
+const float STRIDER_SPEED_CHANGE = .0067; // per think
+
+
+static void MoveToGround( Vector *position, CBaseEntity *ignore, const Vector &mins, const Vector &maxs );
+
+int s_iImpactEffectTexture = -1;
+
+//==================================================
+// Custom Activities
+//==================================================
+
+int	ACT_STRIDER_LOOKL;
+int	ACT_STRIDER_LOOKR;
+int ACT_STRIDER_DEPLOYRA1;
+int ACT_STRIDER_AIMRA1;
+int ACT_STRIDER_FINISHRA1;
+int ACT_STRIDER_DODGER;
+int ACT_STRIDER_DODGEL;
+int ACT_STRIDER_STOMPL;
+int ACT_STRIDER_STOMPR;
+int ACT_STRIDER_FLICKL;
+int ACT_STRIDER_FLICKR;
+int ACT_STRIDER_CARRIED;
+int ACT_STRIDER_DEPLOY;
+int	ACT_STRIDER_GESTURE_DEATH;
+
+// UNDONE: Split sleep into 3 activities (start, loop, end)
+int ACT_STRIDER_SLEEP;
+
+// These bones have physics shadows
+// It allows a one-way interaction between the strider and
+// the physics world
+static const char *pFollowerBoneNames[] =
+{
+	// Head
+	"Combine_Strider.Body_Bone",
+#ifdef HL2_EPISODIC
+	"Combine_Strider.Neck_Bone",
+	"Combine_Strider.Gun_Bone1",
+	"Combine_Strider.Gun_Bone2",
+#endif //HL2_EPISODIC
+
+	// lower legs
+	"Combine_Strider.Leg_Left_Bone1",
+	"Combine_Strider.Leg_Right_Bone1",
+	"Combine_Strider.Leg_Hind_Bone1",
+	
+	// upper legs
+	"Combine_Strider.Leg_Left_Bone",
+	"Combine_Strider.Leg_Right_Bone",
+	"Combine_Strider.Leg_Hind_Bone",
+};
+
+// NOTE: These indices must directly correlate with the above list!
+enum
+{
+	STRIDER_BODY_FOLLOWER_INDEX = 0,
+#ifdef HL2_EPISODIC
+	STRIDER_NECK_FOLLOWER_INDEX,
+	STRIDER_GUN1_FOLLOWER_INDEX,
+	STRIDER_GUN2_FOLLOWER_INDEX,
+#endif //HL2_EPISODIC
+	
+	STRIDER_LEFT_LEG_FOLLOWER_INDEX,
+	STRIDER_RIGHT_LEG_FOLLOWER_INDEX,
+	STRIDER_BACK_LEG_FOLLOWER_INDEX,
+
+	STRIDER_LEFT_UPPERLEG_FOLLOWER_INDEX,
+	STRIDER_RIGHT_UPPERLEG_FOLLOWER_INDEX,
+	STRIDER_BACK_UPPERLEG_FOLLOWER_INDEX,
+};
+
+#define MINIGUN_MAX_YAW		90.0f
+#define MINIGUN_MIN_YAW		-90.0f
+#define MINIGUN_MAX_PITCH	45.0f
+#define MINIGUN_MIN_PITCH	-45.0f
+
+//-----------------------------------------------------------------------------
+//
+// CNPC_Strider
+//
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_SERVERCLASS_ST(CNPC_Strider, DT_NPC_Strider)
+	SendPropVector(SENDINFO(m_vecHitPos), -1, SPROP_COORD),
+	SendPropVector( SENDINFO_NETWORKARRAYELEM( m_vecIKTarget, 0 ), -1, SPROP_COORD ),
+	SendPropVector( SENDINFO_NETWORKARRAYELEM( m_vecIKTarget, 1 ), -1, SPROP_COORD ),
+	SendPropVector( SENDINFO_NETWORKARRAYELEM( m_vecIKTarget, 2 ), -1, SPROP_COORD ),
+	SendPropVector( SENDINFO_NETWORKARRAYELEM( m_vecIKTarget, 3 ), -1, SPROP_COORD ),
+	SendPropVector( SENDINFO_NETWORKARRAYELEM( m_vecIKTarget, 4 ), -1, SPROP_COORD ),
+	SendPropVector( SENDINFO_NETWORKARRAYELEM( m_vecIKTarget, 5 ), -1, SPROP_COORD ),
+END_SEND_TABLE()
+
+//-------------------------------------
+
+LINK_ENTITY_TO_CLASS( npc_strider, CNPC_Strider );
+
+//-------------------------------------
+
+BEGIN_DATADESC( CNPC_Strider )
+
+#ifdef HL2_EPISODIC
+	DEFINE_UTLVECTOR( m_hAttachedBusters,	FIELD_EHANDLE ),
+#endif // HL2_EPISODIC
+
+	DEFINE_EMBEDDED( m_EnemyUpdatedTimer ),
+	DEFINE_EMBEDDEDBYREF( m_pMinigun ),
+	DEFINE_FIELD( m_miniGunAmmo,			FIELD_INTEGER ),
+	DEFINE_FIELD( m_miniGunDirectAmmo,		FIELD_INTEGER ),
+	DEFINE_FIELD( m_nextStompTime,		FIELD_TIME ),
+	DEFINE_FIELD( m_nextShootTime,		FIELD_TIME ),
+	DEFINE_FIELD( m_ragdollTime,			FIELD_TIME ),
+	DEFINE_FIELD( m_miniGunShootDuration, FIELD_FLOAT ),
+	DEFINE_FIELD( m_aimYaw,				FIELD_FLOAT ),
+	DEFINE_FIELD( m_aimPitch,				FIELD_FLOAT ),
+	DEFINE_FIELD( m_blastHit,				FIELD_VECTOR ),
+	DEFINE_FIELD( m_blastNormal,			FIELD_VECTOR ),
+	DEFINE_FIELD( m_vecHitPos,				FIELD_POSITION_VECTOR ),
+	DEFINE_AUTO_ARRAY( m_vecIKTarget, FIELD_POSITION_VECTOR ),
+
+	DEFINE_EMBEDDED( m_PlayerFreePass ), 
+	
+	DEFINE_EMBEDDED( m_PostureAnimationTimer ),
+
+	DEFINE_EMBEDDED( m_BoneFollowerManager ),
+
+	// m_iszStriderBusterName - recreated at load time
+	// m_iszMagnadeClassname - recreated at load time
+	// m_iszHunterClassname - recreated at load time
+
+	DEFINE_FIELD( m_hRagdoll,				FIELD_EHANDLE ),
+	DEFINE_FIELD( m_hCannonTarget,		FIELD_EHANDLE ),
+	DEFINE_EMBEDDED( m_AttemptCannonLOSTimer ),
+
+	DEFINE_FIELD( m_flSpeedScale, FIELD_FLOAT ),
+	DEFINE_FIELD( m_flTargetSpeedScale, FIELD_FLOAT ),
+
+	DEFINE_EMBEDDED( m_LowZCorrectionTimer ),
+	DEFINE_FIELD( m_BodyTargetBone,		FIELD_INTEGER ),
+
+	DEFINE_FIELD( m_iVisibleEnemies, FIELD_INTEGER ),
+	DEFINE_FIELD( m_flTargetAcquiredTime, FIELD_FLOAT ),
+	DEFINE_FIELD( m_bCrouchLocked, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_bNoCrouchWalk, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_bDontCrouch, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_bNoMoveToLOS, FIELD_BOOLEAN ),
+	DEFINE_KEYFIELD( m_bDisableBoneFollowers, FIELD_BOOLEAN, "disablephysics" ),
+
+	DEFINE_FIELD( m_idealHeight, FIELD_FLOAT ),
+	DEFINE_FIELD( m_HeightVelocity, FIELD_FLOAT ),
+
+	DEFINE_FIELD( m_prevYaw, FIELD_FLOAT ),
+	DEFINE_FIELD( m_doTurn, FIELD_FLOAT ),
+	DEFINE_FIELD( m_doLeft, FIELD_FLOAT ),
+	DEFINE_FIELD( m_doRight, FIELD_FLOAT ),
+	DEFINE_FIELD( m_flNextTurnAct, FIELD_TIME ),
+
+	DEFINE_FIELD( m_strTrackName, FIELD_STRING ),
+	DEFINE_FIELD( m_hFocus, FIELD_EHANDLE ),
+	DEFINE_FIELD( m_hSmoke,	FIELD_EHANDLE ),
+
+	DEFINE_FIELD( m_flTimeLastAlertSound, FIELD_TIME ),
+	DEFINE_FIELD( m_flTimeNextHuntSound, FIELD_TIME ),
+	DEFINE_FIELD( m_flTimePlayerMissileDetected, FIELD_TIME ),
+	DEFINE_FIELD( m_hPlayersMissile, FIELD_EHANDLE ),
+	DEFINE_FIELD( m_bMinigunUseDirectFire, FIELD_BOOLEAN ),
+
+	DEFINE_FIELD( m_bUseAggressiveBehavior, FIELD_BOOLEAN ),
+
+	DEFINE_FIELD( m_bFastCrouch, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_bMinigunEnabled, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_bExploding, FIELD_BOOLEAN ),
+
+	// inputs
+	DEFINE_INPUTFUNC( FIELD_FLOAT, "SetMinigunTime", InputSetMinigunTime ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "SetMinigunTarget", InputSetMinigunTarget ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "SetCannonTarget", InputSetCannonTarget ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "FlickRagdoll", InputFlickRagdoll ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "Crouch", InputCrouch ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "CrouchInstantly", InputCrouchInstantly ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "Stand", InputStand ),
+	DEFINE_INPUTFUNC( FIELD_FLOAT, "SetHeight", InputSetHeight ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "SetTargetPath", InputSetTargetPath ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "ClearTargetPath", InputClearTargetPath ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "DisableCrouchWalk", InputDisableCrouchWalk ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "EnableCrouchWalk", InputEnableCrouchWalk ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "EnableAggressiveBehavior", InputEnableAggressiveBehavior ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "DisableAggressiveBehavior", InputDisableAggressiveBehavior ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "DisableMinigun", InputDisableMinigun ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "EnableMinigun", InputEnableMinigun ),
+	DEFINE_INPUTFUNC( FIELD_FLOAT, "StopShootingMinigunForSeconds", InputStopShootingMinigunForSeconds ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "DisableCrouch", InputDisableCrouch ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "DisableMoveToLOS", InputDisableMoveToLOS ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "DisableCollisionWith", InputDisableCollisionWith ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "EnableCollisionWith", InputEnableCollisionWith ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "Explode", InputExplode ),
+	DEFINE_INPUTFUNC( FIELD_FLOAT, "ScaleGroundSpeed", InputScaleGroundSpeed ),
+
+	// Function Pointers
+//	DEFINE_FUNCTION( JumpTouch ),
+	DEFINE_THINKFUNC( CarriedThink ),
+	DEFINE_THINKFUNC( CannonHitThink ),
+
+END_DATADESC()
+
+//---------------------------------------------------------
+
+float CNPC_Strider::gm_strideLength;
+
+int CNPC_Strider::gm_BodyHeightPoseParam;
+int CNPC_Strider::gm_YawControl;
+int CNPC_Strider::gm_PitchControl;
+int CNPC_Strider::gm_CannonAttachment;
+
+float CNPC_Strider::gm_zCannonDist;
+float CNPC_Strider::gm_zMinigunDist;
+Vector CNPC_Strider::gm_vLocalRelativePositionCannon;
+Vector CNPC_Strider::gm_vLocalRelativePositionMinigun;
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+CNPC_Strider::CNPC_Strider()
+{
+	m_strTrackName = MAKE_STRING( STRIDER_NO_TRACK_NAME );
+	m_hFocus = NULL;
+	m_pMinigun = new CStriderMinigun;
+	m_hSmoke = NULL;
+	m_PlayerFreePass.SetOuter( this );
+	m_bExploding = false;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+CNPC_Strider::~CNPC_Strider()
+{
+	delete m_pMinigun;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::Precache()
+{
+	if ( !GetModelName() )
+	{
+		SetModelName( MAKE_STRING( "models/combine_strider.mdl" ) );
+	}
+
+	PrecacheModel( STRING( GetModelName() ) );
+
+	PropBreakablePrecacheAll( GetModelName() );
+
+	PrecacheScriptSound( "NPC_Strider.StriderBusterExplode" );
+	PrecacheScriptSound( "explode_5" );
+	PrecacheScriptSound( "NPC_Strider.Charge" );
+	PrecacheScriptSound( "NPC_Strider.RagdollDetach" );
+	PrecacheScriptSound( "NPC_Strider.Whoosh" );
+	PrecacheScriptSound( "NPC_Strider.Creak" );
+	PrecacheScriptSound( "NPC_Strider.Alert" );
+	PrecacheScriptSound( "NPC_Strider.Pain" );
+	PrecacheScriptSound( "NPC_Strider.Death" );
+	PrecacheScriptSound( "NPC_Strider.FireMinigun" );
+	PrecacheScriptSound( "NPC_Strider.Shoot" );
+	PrecacheScriptSound( "NPC_Strider.OpenHatch" );
+	PrecacheScriptSound( "NPC_Strider.Footstep" );
+	PrecacheScriptSound( "NPC_Strider.Skewer" );
+	PrecacheScriptSound( "NPC_Strider.Hunt" );
+	PrecacheMaterial( "effects/water_highlight" );
+	s_iImpactEffectTexture = PrecacheModel( "sprites/physbeam.vmt" );
+	PrecacheMaterial( "sprites/bluelaser1" );
+	PrecacheMaterial( "effects/blueblacklargebeam" );
+	PrecacheMaterial( "effects/strider_pinch_dudv" );
+	PrecacheMaterial( "effects/blueblackflash" );
+	PrecacheMaterial( "effects/strider_bulge_dudv" );
+	PrecacheMaterial( "effects/strider_muzzle" );
+
+	PrecacheModel( "models/chefhat.mdl" );
+
+	UTIL_PrecacheOther( "sparktrail" );
+
+	BaseClass::Precache();
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::Spawn()
+{
+	Precache();
+
+	m_miniGunAmmo = GetAmmoDef()->Index("StriderMinigun"); 
+	m_miniGunDirectAmmo = GetAmmoDef()->Index("StriderMinigunDirect");
+	m_pMinigun->Init();
+
+	EnableServerIK();
+	
+	SetModel( STRING( GetModelName() ) );
+
+	BaseClass::Spawn();
+
+	//m_debugOverlays |= OVERLAY_NPC_ROUTE_BIT | OVERLAY_BBOX_BIT;
+	SetHullType( HULL_LARGE_CENTERED );
+	SetHullSizeNormal();
+	SetDefaultEyeOffset();
+	
+	SetNavType( NAV_FLY );
+	m_flGroundSpeed	= STRIDER_SPEED;
+	m_flSpeedScale = m_flTargetSpeedScale = 1.0;
+	m_NPCState = NPC_STATE_NONE;
+	m_bloodColor = DONT_BLEED;
+	
+	m_iHealth = sk_strider_health.GetFloat();
+	m_iMaxHealth = 500;
+
+	m_flFieldOfView = 0.0; // 180 degrees
+
+	AddFlag( FL_FLY );
+	SetCollisionGroup( HL2COLLISION_GROUP_STRIDER );
+	SetSolid( SOLID_BBOX );
+	AddSolidFlags( FSOLID_NOT_STANDABLE );
+	SetMoveType( MOVETYPE_STEP );
+	AddEFlags( EFL_NO_DISSOLVE | EFL_NO_MEGAPHYSCANNON_RAGDOLL );
+
+	// Cached for quick comparisons
+	m_iszStriderBusterName = AllocPooledString( "weapon_striderbuster" );
+	m_iszMagnadeClassname  = AllocPooledString( "npc_grenade_magna" );
+	m_iszHunterClassname   = AllocPooledString( "npc_hunter" );
+
+	// BMCD: Force collision hooks
+	AddSolidFlags( FSOLID_CUSTOMRAYTEST | FSOLID_CUSTOMBOXTEST );
+	SetupGlobalModelData();
+	
+	CapabilitiesAdd( bits_CAP_MOVE_FLY | bits_CAP_INNATE_RANGE_ATTACK2 | bits_CAP_INNATE_MELEE_ATTACK1 | bits_CAP_INNATE_MELEE_ATTACK2 | bits_CAP_SQUAD );
+
+	// Don't allow us to skip animation setup because our attachments are critical to us!
+	SetBoneCacheFlags( BCF_NO_ANIMATION_SKIP );
+
+	// find the ground, move up to strider stand height
+	Vector mins(-16,-16,-16), maxs(16,16,16);
+	Vector origin = GetLocalOrigin();
+
+	MoveToGround( &origin, this, mins, maxs );
+	origin.z += GetMaxHeight();//(GetAbsOrigin().z - vecSurroundMins.z) + mins.z;
+
+	SetLocalOrigin( origin );
+
+	NPCInit();
+
+	// Strider doesn't care about missiles for now.
+	AddClassRelationship( CLASS_MISSILE, D_NU, 0 );
+
+	m_bCrouchLocked = false;
+	m_bMinigunEnabled = true;
+
+	m_PostureAnimationTimer.Set( 8, 16 );
+
+	m_BodyTargetBone = -1;
+
+	CreateFocus();
+
+	m_EnemyUpdatedTimer.Set( 0 );
+
+	// Don't minigun things farther than 500 feet away. 
+	m_flDistTooFar = 500.0f * 12.0f;
+
+	GetEnemies()->SetFreeKnowledgeDuration( strider_free_knowledge.GetFloat() );
+
+	m_hPlayersMissile.Set( NULL );
+	m_flTimeNextHuntSound = gpGlobals->curtime - 1.0f;
+}
+
+void CNPC_Strider::SetupGlobalModelData()
+{
+	gm_BodyHeightPoseParam = LookupPoseParameter( "body_height" );
+	gm_YawControl = LookupPoseParameter( "yaw" );
+	gm_PitchControl = LookupPoseParameter( "pitch" );
+	gm_CannonAttachment = LookupAttachment( "BigGun" );
+
+	// BMCD: Get the conservative boxes from sequences
+	Vector mins, maxs;
+	ExtractBbox( SelectHeaviestSequence( ACT_WALK ), mins, maxs );
+	CNPC_Strider::gm_strideLength = (maxs.x - mins.x) * 0.5;
+
+	// UNDONE: use crouch when crouched
+	CollisionProp()->SetSurroundingBoundsType( USE_HITBOXES );
+}
+
+void CNPC_Strider::OnRestore()
+{
+	BaseClass::OnRestore();
+	SetupGlobalModelData();
+	CreateVPhysics();
+
+	// Cached for quick comparisons
+	m_iszStriderBusterName = FindPooledString( "weapon_striderbuster" );
+	m_iszMagnadeClassname  = FindPooledString( "npc_grenade_magna" );
+}
+
+bool CNPC_Strider::m_sbStaticPoseParamsLoaded = false;
+int CNPC_Strider::m_poseMiniGunYaw = 0;
+int CNPC_Strider::m_poseMiniGunPitch = 0;
+//-----------------------------------------------------------------------------
+// Purpose: Cache whatever pose parameters we intend to use
+//-----------------------------------------------------------------------------
+void CNPC_Strider::PopulatePoseParameters( void )
+{
+	if (!m_sbStaticPoseParamsLoaded)
+	{
+		m_poseMiniGunYaw		= LookupPoseParameter( "miniGunYaw");
+		m_poseMiniGunPitch		= LookupPoseParameter( "miniGunPitch" );
+
+		m_sbStaticPoseParamsLoaded = true;
+	}
+
+	BaseClass::PopulatePoseParameters();
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::CreateVPhysics()
+{
+	// The strider has bone followers for every solid part of its body, 
+	// so there's no reason for the bounding box to be solid.
+	//BaseClass::CreateVPhysics();
+
+	if ( !m_bDisableBoneFollowers )
+	{
+		InitBoneFollowers();
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CNPC_Strider::InitBoneFollowers( void )
+{
+	// Don't do this if we're already loaded
+	if ( m_BoneFollowerManager.GetNumBoneFollowers() != 0 )
+		return;
+
+	// Init our followers
+	m_BoneFollowerManager.InitBoneFollowers( this, ARRAYSIZE(pFollowerBoneNames), pFollowerBoneNames );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::PostNPCInit()
+{
+	BaseClass::PostNPCInit();
+
+	if( CarriedByDropship() )
+	{
+		SetMoveType( MOVETYPE_NONE );
+		SetActivity( (Activity)ACT_STRIDER_CARRIED );
+		SetThink( &CNPC_Strider::CarriedThink );
+		RemoveFlag( FL_FLY );
+	}
+
+	m_PlayerFreePass.SetPassTarget( UTIL_PlayerByIndex(1) );
+	
+	AI_FreePassParams_t freePassParams = 
+	{
+		strider_free_pass_start_time.GetFloat(),		// timeToTrigger
+		strider_free_pass_duration.GetFloat(), 			// duration
+		strider_free_pass_move_tolerance.GetFloat(), 	// moveTolerance
+		strider_free_pass_refill_rate.GetFloat(), 		// refillRate
+		strider_free_pass_cover_dist.GetFloat(), 		// coverDist
+		strider_peek_time.GetFloat(), 					// peekTime
+		strider_peek_time_after_damage.GetFloat(), 		// peekTimeAfterDamage
+		strider_peek_eye_dist.GetFloat(), 				// peekEyeDist
+		strider_peek_eye_dist_z.GetFloat(), 			// peekEyeDistZ
+	};
+	
+	m_PlayerFreePass.SetParams( freePassParams );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::Activate()
+{
+	BaseClass::Activate();
+
+	const char *pszBodyTargetBone = "combine_strider.neck_bone";
+
+	m_BodyTargetBone = LookupBone( pszBodyTargetBone );
+
+	if ( m_BodyTargetBone == -1 )
+	{
+		DevMsg( "Couldn't find npc_strider bone %s, which is used as target for others\n", pszBodyTargetBone );
+	}
+
+	gm_BodyHeightPoseParam = LookupPoseParameter( "body_height" );
+	gm_YawControl = LookupPoseParameter( "yaw" );
+	gm_PitchControl = LookupPoseParameter( "pitch" );
+	gm_CannonAttachment = LookupAttachment( "BigGun" );
+
+	if ( gm_zCannonDist == 0 )
+	{
+		// Have to create a virgin strider to ensure proper pose
+		CNPC_Strider *pStrider = (CNPC_Strider *)CreateEntityByName( "npc_strider" );
+		Assert(pStrider);
+		pStrider->m_bDisableBoneFollowers = true; // don't create these since we're just going to destroy him
+		DispatchSpawn( pStrider );
+
+		pStrider->SetActivity( ACT_DIERAGDOLL );
+		pStrider->InvalidateBoneCache();
+		gm_zCannonDist = pStrider->CannonPosition().z - pStrider->GetAbsOrigin().z;
+
+		// Currently just using the gun for the vertical component!
+		Vector defEyePos;
+		pStrider->GetAttachment( "minigunbase", defEyePos );
+		gm_zMinigunDist = defEyePos.z - pStrider->GetAbsOrigin().z;
+
+		Vector position;
+		pStrider->GetAttachment( "biggun", position );
+		VectorITransform( position, pStrider->EntityToWorldTransform(), gm_vLocalRelativePositionCannon );
+
+		pStrider->GetAttachment( "minigun", position );
+		VectorITransform( position, pStrider->EntityToWorldTransform(), gm_vLocalRelativePositionMinigun );
+		UTIL_Remove( pStrider );
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::UpdateOnRemove()
+{
+	m_BoneFollowerManager.DestroyBoneFollowers();
+
+#ifdef HL2_EPISODIC
+	m_hAttachedBusters.Purge();
+#endif // HL2_EPISODIC
+
+	BaseClass::UpdateOnRemove();
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InitBoneControllers()
+{
+	BaseClass::InitBoneControllers( );
+	
+	SetHeight( GetMaxHeight() );
+	SetIdealHeight( GetMaxHeight() );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+Class_T CNPC_Strider::Classify()
+{
+	if( CarriedByDropship() )
+		return CLASS_NONE;
+
+	return CLASS_COMBINE;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::ShouldAttractAutoAim( CBaseEntity *pAimingEnt )
+{
+#ifdef HL2_EPISODIC
+	if( m_hAttachedBusters.Count() > 0 )
+		return false;
+#endif//HL2_EPISODIC
+
+	return BaseClass::ShouldAttractAutoAim( pAimingEnt );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+int	CNPC_Strider::DrawDebugTextOverlays()
+{
+	int text_offset = BaseClass::DrawDebugTextOverlays();
+
+	if (m_debugOverlays & OVERLAY_TEXT_BIT)
+	{
+		EntityText(text_offset,CFmtStr("Ideal Height: %.1f; Height: %.1f", GetIdealHeight(), GetHeight()),0);
+		text_offset++;
+		if ( m_PlayerFreePass.HasPass() )
+		{
+			EntityText(text_offset,CFmtStr("Free pass: %.1f", m_PlayerFreePass.GetTimeRemaining()),0);
+			text_offset++;
+		}
+
+		CBaseEntity *pPlayer = UTIL_PlayerByIndex(1);
+		if ( pPlayer )
+		{
+			if ( GetSenses()->ShouldSeeEntity( pPlayer ) && GetSenses()->CanSeeEntity( pPlayer ) )
+			{
+				EntityText(text_offset,"See player",0);
+				text_offset++;
+			}
+			else
+			{
+				float temp = m_PlayerFreePass.GetTimeRemaining();
+				m_PlayerFreePass.SetTimeRemaining( 0 );
+
+				if ( BaseClass::FVisible( pPlayer ) && !FVisible( pPlayer ) )
+				{
+					EntityText(text_offset,"Player peeking",0);
+					text_offset++;
+				}
+				m_PlayerFreePass.SetTimeRemaining( temp );
+			}
+		}
+
+		if ( m_flTargetSpeedScale != 1.0 )
+		{
+			EntityText(text_offset,CFmtStr( "Speed scaled to %.1f", m_flGroundSpeed ),0);
+			text_offset++;
+		}
+	}
+
+	return text_offset;
+}
+
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+Vector CNPC_Strider::EyePosition()
+{
+	Vector eyePosition = GetAdjustedOrigin();
+	eyePosition.z += gm_zMinigunDist;
+	return eyePosition;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+const Vector &CNPC_Strider::GetViewOffset()
+{
+	Vector vOffset;
+
+	vOffset.x = 0;
+	vOffset.y = 0;
+	vOffset.z = ( GetHeight() - GetMaxHeightModel() ) + gm_zMinigunDist;
+
+	Assert( VectorsAreEqual( GetAbsOrigin() + vOffset, EyePosition(), 0.1 ));
+
+	SetViewOffset( vOffset );
+
+	return BaseClass::GetViewOffset();
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::CalculateIKLocks( float currentTime )
+{
+	BaseClass::CalculateIKLocks( currentTime );
+	if ( m_pIk && m_pIk->m_target.Count() )
+	{
+		Assert(m_pIk->m_target.Count() > STOMP_IK_SLOT);
+		// HACKHACK: Hardcoded 11???  Not a cleaner way to do this
+		CIKTarget &target = m_pIk->m_target[STOMP_IK_SLOT];
+		target.SetPos( m_vecHitPos.Get() );
+		for ( int i = 0; i < NUM_STRIDER_IK_TARGETS; i++ )
+		{
+			target = m_pIk->m_target[i];
+
+			if (!target.IsActive())
+				continue;
+
+			m_vecIKTarget.Set( i, target.est.pos );
+
+#if 0
+		// yellow box at target pos - helps debugging
+		//if (i == 0)
+			NDebugOverlay::Line( GetAbsOrigin(), m_vecIKTarget[i], 255, 255, 0, 0, 0.1 );
+			NDebugOverlay::Box( m_vecIKTarget[i], Vector(-8,-8,-8), Vector(8,8,8), 255, 255, 0, 0, 4.0 );
+#endif
+		}
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::NPCThink(void)
+{
+	if ( m_hRagdoll.Get() )
+	{
+		m_nextStompTime = gpGlobals->curtime + 5;
+	}
+
+	if ( m_flTargetSpeedScale > 0.01 )
+	{
+		float deltaSpeedScale = m_flSpeedScale - m_flTargetSpeedScale;
+		if ( fabsf( deltaSpeedScale ) > .01 )
+		{
+			if ( deltaSpeedScale < 0 )
+			{
+				m_flSpeedScale += STRIDER_SPEED_CHANGE;
+				if ( m_flSpeedScale > m_flTargetSpeedScale )
+				{
+					m_flSpeedScale = m_flTargetSpeedScale;
+				}
+			}
+			else
+			{
+				m_flSpeedScale -= STRIDER_SPEED_CHANGE;
+				if ( m_flSpeedScale < m_flTargetSpeedScale )
+				{
+					m_flSpeedScale = m_flTargetSpeedScale;
+				}
+			}
+		}
+		else
+		{
+			m_flSpeedScale = m_flTargetSpeedScale;
+		}
+	}
+	else
+	{
+		m_flTargetSpeedScale = 1.0;
+	}
+
+	BaseClass::NPCThink();
+	
+	m_pMinigun->Think( this, 0.1 );
+
+	// update follower bones
+	m_BoneFollowerManager.UpdateBoneFollowers(this);
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::PrescheduleThink()
+{
+	if( IsUsingAggressiveBehavior() && GetEnemy() && GetEnemy()->IsPlayer() )
+	{
+		AddFacingTarget( GetEnemy(), GetEnemies()->LastKnownPosition( GetEnemy() ) , 1.0, 2.0 );
+	}
+
+	// Next missile will kill me!
+	if( GetHealth() <= 50 && random->RandomInt( 0, 20 ) == 0 )
+	{
+		CBaseEntity *pTrail = CreateEntityByName( "sparktrail" );
+		pTrail->SetOwnerEntity( this );
+		pTrail->Spawn();
+	}
+
+#if 0
+	NDebugOverlay::Cross3D( GetAdjustedOrigin(), 16, 128, 128, 128, false, .1 );
+	Vector vIdealOrigin = GetAbsOrigin();
+	vIdealOrigin.z -= GetMaxHeightModel() - GetIdealHeight();
+	NDebugOverlay::Cross3D( vIdealOrigin, 16, 255, 255, 255, false, .1 );
+#endif
+
+	if( strider_eyepositions.GetBool() )
+	{
+		NDebugOverlay::Cross3D( EyePosition(), 16, 0, 255, 0, false, 0.1 );
+		NDebugOverlay::Cross3D( EyePositionCrouched(), 16, 255, 255, 0, false, 0.1 );
+	}
+
+	if( strider_show_focus.GetBool() )
+	{
+		QAngle angles;
+
+		angles.x = gpGlobals->curtime * 20.0f;
+		angles.y = angles.x * 0.5f;
+		angles.z = 0.0f;
+
+		NDebugOverlay::Cross3DOriented( GetFocus()->GetAbsOrigin(), angles, 24, 255, 255, 0, false, 0.1 );
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::GatherConditions()
+{
+	if ( AIGetNumFollowers( this, m_iszHunterClassname ) == 0 )	
+	{
+		// This works with old data because need to do before base class so as to not choose as enemy
+		if ( m_PlayerFreePass.HasPass() || ( !m_pMinigun->IsShooting() || GetEnemy() != m_PlayerFreePass.GetPassTarget() ) ) // no free pass when in midst of shooting at target
+			m_PlayerFreePass.Update();
+	}
+	else
+	{
+		m_PlayerFreePass.Reset( strider_free_pass_after_escorts_dead.GetFloat(), strider_free_pass_tolerance_after_escorts_dead.GetFloat() );
+	}
+
+	if( IsUsingAggressiveBehavior() )
+	{
+		if( m_PlayerFreePass.HasPass() && !m_pMinigun->IsShooting() )
+		{
+			// Make the minigun stitch
+			m_bMinigunUseDirectFire = false;
+		}
+	}
+
+	//---------------------------------
+
+	BaseClass::GatherConditions();
+
+	if( IsUsingAggressiveBehavior() )
+	{
+		if( GetEnemy() )
+		{
+			if( HasCondition( COND_SEE_ENEMY ) )
+			{
+				// Keep setting up to play my hunt sound at some random time after losing sight of my enemy.
+				m_flTimeNextHuntSound = gpGlobals->curtime + 1.0f;
+			}
+			else
+			{
+				if( gpGlobals->curtime >= m_flTimeNextHuntSound && !m_pMinigun->IsShooting() )
+				{
+					HuntSound();
+				}
+			}
+		}
+
+		if( m_hPlayersMissile )
+		{
+			if( !m_pMinigun->IsShooting() && GetEnemy() && GetEnemy()->IsPlayer() )
+			{
+				// If the missile is closer to the player than I am, stay suppressed. This is essentially
+				// allowing the missile to strike me if it was fired off before I started shooting. 
+				// If the missile passes me or goes way off course, I can shoot.
+				float flPlayerMissileDist;
+				float flPlayerStriderDist;
+
+				flPlayerMissileDist = GetEnemy()->GetAbsOrigin().DistTo( m_hPlayersMissile->GetAbsOrigin() );
+				flPlayerStriderDist = GetEnemy()->GetAbsOrigin().DistTo( EyePosition() );
+				float flDiff = flPlayerMissileDist - flPlayerStriderDist;
+
+				// Figure out how long it's been since I've fired my cannon because of a player's missile.
+				float flTimeSuppressed = gpGlobals->curtime - m_flTimePlayerMissileDetected;
+
+				if( flDiff < strider_missile_suppress_dist.GetFloat() && flTimeSuppressed < strider_missile_suppress_time.GetFloat() )
+				{
+					// Defer the minigun until/unless the missile has passed me by 10 feet
+					m_pMinigun->StopShootingForSeconds( this, GetEnemy(), 0.5f );
+				}
+			}
+		}
+	}
+
+	// This pair of conditions is nice to have around...
+	if( m_pMinigun->IsShooting() )
+	{
+		SetCondition( COND_STRIDER_MINIGUN_SHOOTING );
+	}
+	else
+	{
+		SetCondition( COND_STRIDER_MINIGUN_NOT_SHOOTING );
+	}
+
+	if( GetCannonTarget() )
+	{
+		SetCondition( COND_STRIDER_HAS_CANNON_TARGET );
+
+		if( strider_show_cannonlos.GetBool() )
+		{
+			trace_t tr;
+			UTIL_TraceLine( CannonPosition(), GetCannonTarget()->WorldSpaceCenter(), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
+			NDebugOverlay::Line( tr.startpos, tr.endpos, 0, 255, 0, false, 0.1 );
+
+			if( tr.fraction != 1.0 )
+				NDebugOverlay::Line( tr.endpos, GetCannonTarget()->WorldSpaceCenter(), 255, 0, 0, false, 0.1 );
+		}
+	}
+	else
+	{
+		ClearCondition( COND_STRIDER_HAS_CANNON_TARGET );
+	}
+
+	ClearCondition( COND_CAN_RANGE_ATTACK2 );
+	ClearCondition( COND_STRIDER_HAS_LOS_Z );
+
+	// If not locked into a crouch, look into adjusting height to attack targets.
+	if( !m_bCrouchLocked && !m_bDontCrouch )
+	{
+		if( m_hCannonTarget != NULL )
+		{	
+			if( !IsStriderCrouching() && !IsStriderStanding() )
+			{
+				if ( WeaponLOSCondition( GetAdjustedOrigin(), m_hCannonTarget->GetAbsOrigin(), false ) )
+				{
+					SetCondition( COND_CAN_RANGE_ATTACK2 );
+				}
+				else
+				{
+					GatherHeightConditions( GetAdjustedOrigin(), m_hCannonTarget );
+				}
+			}
+		}
+		else if( GetEnemy() )
+		{
+			if ( strider_distributed_fire.GetBool() && !IsUsingAggressiveBehavior() )
+			{
+				m_iVisibleEnemies = 0;
+				AIEnemiesIter_t iter;
+
+				for( AI_EnemyInfo_t *pEMemory = GetEnemies()->GetFirst(&iter); pEMemory != NULL; pEMemory = GetEnemies()->GetNext(&iter) )
+				{
+					if( IRelationType( pEMemory->hEnemy ) != D_NU && IRelationType( pEMemory->hEnemy ) != D_LI )
+					{
+						if( pEMemory->timeLastSeen == gpGlobals->curtime )
+						{
+							m_iVisibleEnemies++;
+						}
+					}
+				}
+
+				// If I'm on target and see more targets than just this one, move on to another target for a bit!
+				// Because the Mingun's state will stay "on target" until the minigun gets a chance to think,
+				// and this function may be called several times per strider think, don't call this code anymore in the same
+				// think when a new enemy is chosen.
+				//
+				// Don't switch targets if shooting at a bullseye! Level designers depend on bullseyes.
+				if( GetEnemy() && m_pMinigun->IsShooting() && GetTimeEnemyAcquired() != gpGlobals->curtime )
+				{
+					if( m_pMinigun->IsOnTarget( 3 ) && !FClassnameIs( GetEnemy(), "npc_bullseye" ) )
+					{
+						if( m_iVisibleEnemies > 1 )
+						{
+							// Time to ignore this guy for a little while and switch targets.
+							GetEnemies()->SetTimeValidEnemy( GetEnemy(), gpGlobals->curtime + ( STRIDER_IGNORE_TARGET_DURATION * m_iVisibleEnemies ) );
+							SetEnemy( NULL, false );
+							ChooseEnemy();
+						}
+						else if( GetEnemy()->IsPlayer() && GetEnemy() == m_pMinigun->GetTarget() )
+						{
+							// Give the poor target a break.
+							m_pMinigun->StopShootingForSeconds( this, GetEnemy(), GetMinigunShootDowntime() );
+						}
+					}
+				}
+			}
+
+			if ( GetEnemy() ) // Can go null above
+			{
+				if ( !IsStriderCrouching() && !IsStriderStanding() &&
+					 ( !HasCondition( COND_SEE_ENEMY ) || 
+					   !WeaponLOSCondition( GetAdjustedOrigin(), GetEnemy()->BodyTarget( GetAdjustedOrigin() ), false ) ) )
+				{
+#if 0
+					if ( !HasCondition( COND_STRIDER_SHOULD_CROUCH ) && !HasCondition( COND_STRIDER_SHOULD_CROUCH ) )
+						SetIdealHeight( MIN( GetMaxHeight(), GetHeight() + 75.0 * 0.1 ) ); // default to rising up
+#endif
+					GatherHeightConditions( GetAdjustedOrigin(), GetEnemy() );
+				}
+			}
+		}
+		else
+			SetIdealHeight( GetMaxHeight() );
+	}
+	else
+	{
+		if( m_hCannonTarget != NULL && CurrentWeaponLOSCondition( m_hCannonTarget->GetAbsOrigin(), false ) )
+			SetCondition( COND_CAN_RANGE_ATTACK2 );
+	}
+
+	if( m_bDontCrouch )
+	{
+		if( HasCondition( COND_STRIDER_SHOULD_CROUCH ) )
+		{
+			Msg("TELL WEDGE I'M TRYING TO CROUCH!\n");
+		}
+
+		ClearCondition( COND_STRIDER_SHOULD_CROUCH );
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::GatherHeightConditions( const Vector &vTestPos, CBaseEntity *pEntity )
+{
+	if ( HasCondition( COND_STRIDER_SHOULD_CROUCH ) && HasCondition( COND_STRIDER_SHOULD_CROUCH ) )
+		return;
+
+	float maxZ = (GetAbsOrigin().z - (GetMaxHeightModel() - GetMaxHeight()));
+	float minZ = (maxZ - ( GetMaxHeight() - GetMinHeight()));;
+	float newHeight = FLT_MAX;
+
+	if( FInViewCone( pEntity ) && GetWeaponLosZ( vTestPos, minZ, maxZ, GetHeightRange() * .1, pEntity, &newHeight ) )
+	{
+		bool bDoProceduralHeightChange = true;
+		newHeight = GetMaxHeightModel() - ( GetAbsOrigin().z - newHeight);
+
+		if ( m_LowZCorrectionTimer.Expired() )
+		{
+			// Hack to handle discrepency between ideal gun pos and actual pos due to strider head tilt in crouch pos
+			if ( pEntity && fabs( newHeight - GetHeight() ) < 12 && newHeight < GetMinHeight() + GetHeightRange() * .33 )
+			{
+				Vector muzzlePos;
+				Vector targetPos = pEntity->BodyTarget( GetAdjustedOrigin() );
+
+				GetAttachment( "minigun", muzzlePos );
+				
+				trace_t tr;
+				AI_TraceLine( muzzlePos, targetPos, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);
+
+				if ( ( tr.m_pEnt != pEntity) && tr.fraction != 1.0 && !CanShootThrough( tr, targetPos ) )
+				{
+					if ( !GetWeaponLosZ( vTestPos, minZ + GetHeightRange() * .33, maxZ, GetHeightRange() * .1, pEntity, &newHeight ) )
+					{
+						return;
+					}
+					newHeight = GetMaxHeightModel() - ( GetAbsOrigin().z - newHeight);
+				}
+				else
+				{
+					m_LowZCorrectionTimer.Set( 5.0 );
+				}
+			}
+		}
+
+		if ( !strider_always_use_procedural_height.GetBool() )
+		{
+			// If going from max to min, or min to max, use animations 60% of the time
+			if ( fabsf(GetMaxHeight() - GetHeight()) < 0.1 && fabsf(GetMinHeight() - newHeight) < 0.1 )
+			{
+				if ( random->RandomInt(1, 10 ) <= 6 )
+				{
+					SetCondition( COND_STRIDER_SHOULD_CROUCH );
+					bDoProceduralHeightChange = false;
+				}
+			}
+			else if ( fabsf(GetMinHeight() - GetHeight()) < 0.1 && fabsf(GetMaxHeight() - newHeight) < 0.1 )
+			{
+				if ( random->RandomInt(1, 10 ) <= 6 )
+				{
+					SetCondition( COND_STRIDER_SHOULD_STAND );
+					bDoProceduralHeightChange = false;
+				}
+			}
+
+			// Otherwise, if going from near max or near min to the other, use animations based on time
+			if ( bDoProceduralHeightChange && m_PostureAnimationTimer.Expired() )
+			{
+				if ( GetHeight() - GetMinHeight() > GetHeightRange() * .85 && newHeight - GetMinHeight() < GetHeightRange() * .15 )
+				{
+					m_PostureAnimationTimer.Reset();
+					SetCondition( COND_STRIDER_SHOULD_CROUCH );
+					bDoProceduralHeightChange = false;
+				}
+				else if ( newHeight - GetMinHeight() > GetHeightRange() * .85 && GetHeight() - GetMinHeight() < GetHeightRange() * .15 )
+				{
+					m_PostureAnimationTimer.Reset();
+					SetCondition( COND_STRIDER_SHOULD_STAND );
+					bDoProceduralHeightChange = false;
+				}
+			}
+		}
+
+		if ( bDoProceduralHeightChange )
+		{
+			SetCondition( COND_STRIDER_HAS_LOS_Z );
+			SetIdealHeight( newHeight );
+			if ( strider_test_height.GetFloat() > .1 )
+				SetIdealHeight( strider_test_height.GetFloat() );
+		}
+		else
+			SetIdealHeight( GetHeight() );
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::OnStateChange( NPC_STATE oldState, NPC_STATE newState )
+{
+	if ( oldState == NPC_STATE_SCRIPT )
+	{
+		m_pMinigun->Enable( this, m_bMinigunEnabled );
+	}
+	else if ( newState == NPC_STATE_SCRIPT )
+	{
+		m_pMinigun->Enable( this, false );
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::BuildScheduleTestBits()
+{
+	BaseClass::BuildScheduleTestBits();
+	if (m_NPCState != NPC_STATE_SCRIPT)
+	{
+		SetCustomInterruptCondition( COND_STRIDER_DO_FLICK );
+	}
+
+	if( IsCurSchedule( SCHED_ESTABLISH_LINE_OF_FIRE_FALLBACK, false ) || IsCurSchedule( SCHED_ESTABLISH_LINE_OF_FIRE, false ) )
+	{
+		SetCustomInterruptCondition( COND_STRIDER_MINIGUN_SHOOTING );
+	}
+
+	if( IsCurSchedule( SCHED_IDLE_STAND ) )
+	{
+		SetCustomInterruptCondition( COND_STRIDER_HAS_CANNON_TARGET );
+	}
+
+	// If our base-class schedule breaks on CAN_RANGE_ATTACK1, then also break
+	// on HAS_CANNON_TARGET.
+	if( GetCurSchedule()->HasInterrupt( COND_CAN_RANGE_ATTACK1 ) && HasCondition( COND_STRIDER_HAS_CANNON_TARGET ) )
+	{
+		SetCustomInterruptCondition( COND_STRIDER_HAS_CANNON_TARGET );
+	}
+
+	if( IsCurSchedule( SCHED_IDLE_WALK ) || ( IsCurSchedule( SCHED_IDLE_STAND ) && hl2_episodic.GetBool() ) )
+	{
+		SetCustomInterruptCondition(COND_STRIDER_SHOULD_CROUCH);
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+int CNPC_Strider::SelectSchedule()
+{
+/*
+	if( GetMoveType() != MOVETYPE_FLY )
+	{
+		// Dropship just released me.
+		SetMoveType( MOVETYPE_FLY );
+		return SCHED_STRIDER_FALL_TO_GROUND;
+	}
+*/
+	if ( strider_idle_test.GetBool() )
+	{
+		m_pMinigun->Enable( this, false );
+		return SCHED_IDLE_STAND;
+	}
+	else
+	{
+		m_pMinigun->Enable( this, m_bMinigunEnabled );
+	}
+
+	if( m_NPCState == NPC_STATE_SCRIPT )
+		return BaseClass::SelectSchedule();
+
+	// If we're starting to die, then just wait for this to happen
+	if ( m_lifeState == LIFE_DYING )
+		return SCHED_IDLE_STAND;
+
+	if( m_NPCState == NPC_STATE_DEAD )
+		return SCHED_STRIDER_DIE;
+
+	if( HasPendingTargetPath() )
+	{
+#if 0
+		if( IsInCrouchedPosture() && !m_bCrouchLocked )
+		{
+			// Make the strider stand!
+			return SCHED_STRIDER_STAND;
+		}
+		else
+		{
+			SetTargetPath();
+		}
+#else
+		SetTargetPath();
+#endif
+	}
+
+	//---------------------------------
+
+	if( HasCondition( COND_STRIDER_SHOULD_CROUCH ) && GetHeight() - GetMinHeight() > GetHeightRange() * .5 )
+	{
+		return SCHED_STRIDER_CROUCH;
+	}
+	if( HasCondition( COND_STRIDER_SHOULD_STAND ) && !m_bCrouchLocked  && GetHeight() - GetMinHeight() < GetHeightRange() * .5 )
+	{
+		return SCHED_STRIDER_STAND;
+	}
+
+	if( HasCondition( COND_CAN_RANGE_ATTACK2 ) )
+	{
+		return SCHED_STRIDER_RANGE_ATTACK2;
+	}
+	else if( m_AttemptCannonLOSTimer.Expired() && HasCondition( COND_STRIDER_HAS_CANNON_TARGET ) )
+	{
+		m_AttemptCannonLOSTimer.Set( 5 );
+		return SCHED_STRIDER_ESTABLISH_LINE_OF_FIRE_CANNON;
+	}
+
+	//---------------------------------
+
+	if( m_NPCState == NPC_STATE_COMBAT )
+	{
+		if ( !HasCondition( COND_NEW_ENEMY ) )
+		{
+			if ( m_hRagdoll.Get() && (gpGlobals->curtime > m_ragdollTime  || HasCondition( COND_STRIDER_DO_FLICK ) ) )
+			{
+				return SCHED_STRIDER_FLICKL;
+			}
+		}
+
+		if ( HasCondition( COND_STRIDER_SHOULD_CROUCH ) )
+		{
+			return SCHED_STRIDER_CROUCH;
+		}
+
+		if ( HasCondition( COND_STRIDER_SHOULD_STAND ) )
+		{
+			return SCHED_STRIDER_STAND;
+		}
+		
+		if ( HasCondition( COND_CAN_MELEE_ATTACK1 ) )
+		{
+			return SCHED_MELEE_ATTACK1;
+		}
+		if ( HasCondition( COND_CAN_RANGE_ATTACK1 ) )
+		{
+			return SCHED_STRIDER_RANGE_ATTACK1;
+		}
+
+		ClearCondition( COND_STRIDER_ENEMY_UPDATED );
+		if ( !m_EnemyUpdatedTimer.Expired() )
+		{
+			int baseResult = BaseClass::SelectSchedule();
+			if ( baseResult != SCHED_COMBAT_FACE || !GetGoalEnt() )
+				return baseResult;
+		}
+
+		if ( !GetGoalEnt() )
+			return BaseClass::SelectSchedule();
+
+		return SCHED_STRIDER_HUNT;
+	}
+
+	//---------------------------------
+
+	if ( !GetGoalEnt() )
+		return SCHED_IDLE_STAND;
+
+	return SCHED_STRIDER_HUNT;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+
+#define TIME_CARE_ENEMY 7.0
+
+int CNPC_Strider::TranslateSchedule( int scheduleType )
+{
+	switch( scheduleType )
+	{
+	case SCHED_RANGE_ATTACK1:
+		return SCHED_STRIDER_RANGE_ATTACK1;
+	case SCHED_RANGE_ATTACK2:
+		return SCHED_STRIDER_RANGE_ATTACK2;
+	case SCHED_MELEE_ATTACK1:
+		return SCHED_STRIDER_STOMPL;
+	case SCHED_MELEE_ATTACK2:
+		return SCHED_STRIDER_STOMPR;
+	case SCHED_CHASE_ENEMY:
+		{
+			if( HasCondition( COND_SEE_ENEMY ) )
+			{
+				return SCHED_STRIDER_COMBAT_FACE;
+			}
+
+			return SCHED_STRIDER_CHASE_ENEMY;
+		}
+
+	case SCHED_ESTABLISH_LINE_OF_FIRE:
+	case SCHED_ESTABLISH_LINE_OF_FIRE_FALLBACK:
+		if ( m_bNoMoveToLOS )
+		{
+			return SCHED_COMBAT_FACE;
+		}
+
+		if ( !m_bCrouchLocked )
+		{
+			if( IsInCrouchedPosture() )
+			{
+				if( m_pMinigun->IsShooting() )
+				{
+					// Don't stand yet.
+					return SCHED_STRIDER_COMBAT_FACE;
+				}
+			}
+			else if ( HasCondition( COND_STRIDER_HAS_LOS_Z ) && HasCondition( COND_SEE_ENEMY ) )
+			{
+				return SCHED_STRIDER_COMBAT_FACE;
+			}
+		}
+		if ( scheduleType == SCHED_ESTABLISH_LINE_OF_FIRE_FALLBACK )
+		{
+			if ( gpGlobals->curtime - GetEnemyLastTimeSeen() < TIME_CARE_ENEMY )
+				return SCHED_STRIDER_COMBAT_FACE;
+			else if ( GetGoalEnt() )
+				return SCHED_STRIDER_HUNT;
+			else
+			{
+				if( IsUsingAggressiveBehavior() )
+				{
+					return SCHED_STRIDER_AGGRESSIVE_COMBAT_STAND;
+				}
+
+				return SCHED_COMBAT_PATROL;
+			}
+		}
+
+		break;
+
+	case SCHED_COMBAT_FACE:
+		return SCHED_STRIDER_COMBAT_FACE;
+		break;
+	}
+
+	return BaseClass::TranslateSchedule( scheduleType );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::StartTask( const Task_t *pTask )
+{
+	switch ( pTask->iTask )
+	{
+	case TASK_GET_PATH_TO_ENEMY_LOS:
+		ChainStartTask( TASK_GET_PATH_TO_ENEMY_LKP_LOS, pTask->flTaskData );
+		break;
+
+	case TASK_STRIDER_FALL_TO_GROUND:
+		break;
+
+	case TASK_STRIDER_FIRE_CANNON:
+		FireCannon();
+		TaskComplete();
+		break;
+
+	case TASK_STRIDER_SET_CANNON_HEIGHT:
+		{
+			if ( m_hCannonTarget )
+				SetAbsIdealHeight( m_hCannonTarget->WorldSpaceCenter().z );
+			TaskComplete();
+		}
+		break;
+
+	case TASK_STRIDER_AIM:
+		{
+			// Stop the minigun for a bit, the big gun's about to shoot!
+			m_pMinigun->StopShootingForSeconds( this, m_pMinigun->GetTarget(), 5 );
+
+			//SetIdealActivity( (Activity)ACT_STRIDER_AIMRA1 );
+			SetWait( pTask->flTaskData );
+			m_aimYaw = 0;
+			m_aimPitch = 0;
+			// clear out the previous shooting
+			SetPoseParameter( gm_YawControl, m_aimYaw );
+			SetPoseParameter( gm_PitchControl, m_aimPitch );
+			Vector vecShootPos;
+			GetAttachment( gm_CannonAttachment, vecShootPos );
+		
+			// tell the client side effect to complete
+			EntityMessageBegin( this, true );
+				WRITE_BYTE( STRIDER_MSG_STREAKS );
+				WRITE_VEC3COORD( vecShootPos );
+			MessageEnd();
+			CPASAttenuationFilter filter2( this, "NPC_Strider.Charge" );
+			EmitSound( filter2, entindex(), "NPC_Strider.Charge" );
+
+			//	CPVSFilter filter( vecShootPos );
+			//te->StreakSphere( filter, 0, 0, 150, 100, entindex(), gm_CannonAttachment );
+		}
+		break;
+
+	case TASK_STRIDER_DODGE:
+		break;
+
+	case TASK_STRIDER_STOMP:
+		{
+			m_nextStompTime = gpGlobals->curtime + 5;
+			Activity stompAct = (Activity) ( pTask->flTaskData > 0 ? ACT_STRIDER_STOMPR : ACT_STRIDER_STOMPL );
+			ResetIdealActivity( stompAct );
+		}
+		break;
+
+	case TASK_RANGE_ATTACK1:
+		CBaseCombatWeapon *pWeapon;
+		pWeapon = GetActiveWeapon();
+
+		if( pWeapon )
+		{
+			pWeapon->PrimaryAttack();
+		}
+		else
+		{
+			TaskFail("no primary weapon");
+		}
+
+		TaskComplete();
+		break;
+
+	case TASK_STRIDER_BREAKDOWN:
+		SetIdealActivity( (Activity)ACT_STRIDER_SLEEP );
+		break;
+
+	case TASK_STRIDER_REFRESH_HUNT_PATH:
+		Assert( GetGoalEnt() );
+		if ( GetGoalEnt() )
+		{
+			AI_NavGoal_t goal(GOALTYPE_PATHCORNER, GetGoalEnt()->GetLocalOrigin(), ACT_WALK, AIN_DEF_TOLERANCE, AIN_YAW_TO_DEST);
+
+			TranslateNavGoal( GetGoalEnt(), goal.dest );
+
+			if ( ( m_debugOverlays & OVERLAY_NPC_SELECTED_BIT ) && ( m_debugOverlays & OVERLAY_NPC_ROUTE_BIT ) )
+			{
+				NDebugOverlay::Line( GetAbsOrigin() + Vector( 0, 0, 4), goal.dest, 255, 0, 255, true, 3 );
+			}
+
+			if ( GetNavigator()->SetGoal( goal ) )
+			{
+				TaskComplete();
+				break;
+			}
+			TaskFail( FAIL_NO_ROUTE );
+		}
+		break;
+
+	case TASK_STRIDER_START_MOVING:
+		TaskComplete();
+		break;
+
+	case TASK_STRIDER_GET_PATH_TO_CANNON_LOS:
+		{
+			if ( GetCannonTarget() == NULL )
+			{
+				TaskFail("No Cannon Target");
+				return;
+			}
+		
+			AI_PROFILE_SCOPE(CAI_BaseNPC_FindLosToEnemy);
+			Vector vecEnemy 	= GetCannonTarget()->WorldSpaceCenter();
+
+			float flMaxRange = 4096;
+			float flMinRange = 0;
+			
+			Vector posLos;
+			bool found = false;
+
+			if ( GetTacticalServices()->FindLateralLos( vecEnemy, &posLos ) )
+			{
+				found = true;
+			}
+
+			if ( !found && GetTacticalServices()->FindLos( vecEnemy, vecEnemy, flMinRange, flMaxRange, 1.0, &posLos ) )
+			{
+				found = true;
+			}
+
+			if ( found )
+			{
+				AI_NavGoal_t goal( posLos, ACT_RUN, AIN_HULL_TOLERANCE );
+
+				GetNavigator()->SetGoal( goal, AIN_CLEAR_TARGET );
+				GetNavigator()->SetArrivalDirection( vecEnemy - goal.dest );
+
+				// Add the cannon target as a high priority facing entity.
+				AddFacingTarget( GetCannonTarget(), GetCannonTarget()->WorldSpaceCenter(), 5.0, 5.0 );
+			}
+			else
+			{
+				TaskFail( "Can't get LOS to Cannon Target" );
+			}
+		}
+		break;
+
+	case TASK_STRIDER_GET_PATH_TO_CANNON_TARGET:
+		{
+			if( !m_hCannonTarget )
+			{
+				TaskFail( "No cannon target!\n" );
+				return;
+			}
+
+			AI_NavGoal_t goal( m_hCannonTarget->GetAbsOrigin() );
+
+			TranslateNavGoal( m_hCannonTarget, goal.dest );
+
+			if ( GetNavigator()->SetGoal( goal, AIN_CLEAR_TARGET ) )
+			{
+				TaskComplete();
+			}
+			else
+			{
+				DevWarning( 2, "GetPathToCannonTarget failed!!\n" );
+				TaskFail(FAIL_NO_ROUTE);
+			}
+		}
+		break;
+
+	case TASK_STRIDER_FACE_CANNON_TARGET:
+		if ( m_hCannonTarget != NULL )
+		{
+			GetMotor()->SetIdealYawToTarget( m_hCannonTarget->WorldSpaceCenter() );
+			SetTurnActivity(); 
+		}
+		else
+		{
+			TaskFail(FAIL_NO_TARGET);
+		}
+		break;
+		
+	case TASK_STRIDER_SET_HEIGHT:
+		SetIdealHeight( pTask->flTaskData );
+		TaskComplete();
+		break;
+
+	default:
+		BaseClass::StartTask( pTask );
+		break;
+	}
+}
+
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::RunTask( const Task_t *pTask )
+{
+	switch ( pTask->iTask )
+	{
+	case TASK_GET_PATH_TO_ENEMY_LOS:
+		ChainRunTask( TASK_GET_PATH_TO_ENEMY_LKP_LOS, pTask->flTaskData );
+		break;
+
+	case TASK_STRIDER_FALL_TO_GROUND:
+		{
+			// This doesn't work right now. (sjb)
+			Vector vecVelocity = GetAbsVelocity();
+
+			vecVelocity.z -= (GetCurrentGravity() * 0.1);
+
+			SetAbsVelocity( vecVelocity );
+
+			Vector pos = GetAbsOrigin();
+			TranslateNavGoal( NULL, pos );
+
+			if( GetAbsOrigin().z - pos.z <= 0.0f )
+			{
+				SetAbsVelocity( vec3_origin );
+				TaskComplete();
+			}
+		}
+		break;
+	
+	case TASK_STRIDER_AIM:
+		{
+			// BUGBUG: Need the real flInterval here, not just 0.1
+			AimCannonAt( GetCannonTarget(), 0.1 );
+			if ( IsWaitFinished() )
+			{
+				TaskComplete();
+			}
+		}
+		break;
+
+	case TASK_STRIDER_DODGE:
+		TaskComplete();
+		break;
+
+	case TASK_STRIDER_STOMP:
+		if ( IsActivityFinished() )
+		{
+			TaskComplete();
+		}
+		if ( GetEnemy() )
+		{
+			m_vecHitPos = CalculateStompHitPosition( GetEnemy() );
+		}
+		break;
+
+	case TASK_STRIDER_BREAKDOWN:
+		if ( IsActivityFinished() )
+		{
+			// UNDONE: Fix this bug!
+			//Assert(!IsMarkedForDeletion());
+			if ( !IsMarkedForDeletion() )
+			{
+				CTakeDamageInfo info;
+				CreateServerRagdoll( this, 0, info, COLLISION_GROUP_NONE );
+				TaskComplete();
+				UTIL_Remove(this);
+			}
+		}
+		break;
+
+	case TASK_STRIDER_FACE_CANNON_TARGET:
+   		GetMotor()->UpdateYaw();
+   		if ( FacingIdeal() )
+   		{
+   			TaskComplete();
+   		}
+   		break;
+
+	case TASK_PLAY_SEQUENCE:
+		if( m_bFastCrouch && pTask->flTaskData == ACT_CROUCH )
+		{
+			SetPlaybackRate( 10.0f );
+			if( IsSequenceFinished() )
+			{
+				m_bFastCrouch = false;
+			}
+		}
+
+		// Hack to make sure client doesn't pop after stand/crouch is done
+		if ( GetCycle() > 0.5 )
+		{
+			if ( IsStriderStanding() && GetHeight() != GetMaxHeight() )
+				SetHeight( GetMaxHeight() );
+			else if ( IsStriderCrouching() && GetHeight() != GetMinHeight() )
+				SetHeight( GetMinHeight() );
+			SetIdealHeight( GetHeight() );
+		}
+		BaseClass::RunTask( pTask );
+		break;
+
+	default:
+		BaseClass::RunTask( pTask );
+		break;		
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CNPC_Strider::Explode( void )
+{
+	Vector			velocity = vec3_origin;
+	AngularImpulse	angVelocity = RandomAngularImpulse( -150, 150 );
+
+	// Break into pieces
+	breakablepropparams_t params( EyePosition(), GetAbsAngles(), velocity, angVelocity );
+	params.impactEnergyScale = 1.0f;
+	params.defBurstScale = 600.0f;
+	params.defCollisionGroup = COLLISION_GROUP_NPC;
+	PropBreakableCreateAll( GetModelIndex(), NULL, params, this, -1, true, true );
+
+	// Go away
+	m_lifeState = LIFE_DEAD;
+
+	SetThink( &CNPC_Strider::SUB_Remove );
+	SetNextThink( gpGlobals->curtime + 0.1f );
+
+	AddEffects( EF_NODRAW );
+	
+	StopSmoking();
+
+	m_BoneFollowerManager.DestroyBoneFollowers();
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CNPC_Strider::HandleInteraction( int interactionType, void *data, CBaseCombatCharacter* sourceEnt )
+{
+	if ( interactionType == g_interactionPlayerLaunchedRPG )
+	{
+		m_flTimePlayerMissileDetected = gpGlobals->curtime;
+		m_hPlayersMissile = sourceEnt;
+		return true;
+	}
+
+	return BaseClass::HandleInteraction( interactionType, data, sourceEnt );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::HandleAnimEvent( animevent_t *pEvent )
+{
+	Vector footPosition;
+
+	switch( pEvent->event )
+	{
+	case STRIDER_AE_DIE:
+		{
+			Explode();
+		}
+		break;
+	case STRIDER_AE_SHOOTCANNON:
+		{
+			FireCannon();
+		}
+		break;
+	case STRIDER_AE_WINDUPCANNON:
+		{
+			AimCannonAt( GetCannonTarget(), 0.1 );
+
+			// Stop the minigun for a bit, the big gun's about to shoot!
+			m_pMinigun->StopShootingForSeconds( this, m_pMinigun->GetTarget(), 5 );
+
+			m_aimYaw = 0;
+			m_aimPitch = 0;
+
+			// clear out the previous shooting
+			SetPoseParameter( gm_YawControl, m_aimYaw );
+			SetPoseParameter( gm_PitchControl, m_aimPitch );
+			Vector vecShootPos;
+			GetAttachment( gm_CannonAttachment, vecShootPos );
+		
+			// tell the client side effect to start
+			EntityMessageBegin( this, true );
+				WRITE_BYTE( STRIDER_MSG_STREAKS );
+				WRITE_VEC3COORD( vecShootPos );
+			MessageEnd();
+			CPASAttenuationFilter filter2( this, "NPC_Strider.Charge" );
+			EmitSound( filter2, entindex(), "NPC_Strider.Charge" );
+		}
+		break;
+	case STRIDER_AE_CANNONHIT:
+		CreateConcussiveBlast( m_blastHit, m_blastNormal, this, 2.5 );
+		break;
+
+	case STRIDER_AE_SHOOTMINIGUN:
+	{
+		CBaseEntity *pTarget = gEntList.FindEntityGeneric( NULL, pEvent->options, this, this );
+		if ( pTarget )
+		{
+			Vector vecTarget = pTarget->CollisionProp()->WorldSpaceCenter();
+			ShootMinigun( &vecTarget, 0 );
+		}
+		break;
+	}
+
+	case STRIDER_AE_STOMPHITL:
+		StompHit( STRIDER_LEFT_LEG_FOLLOWER_INDEX );
+		break;
+	case STRIDER_AE_STOMPHITR:
+		StompHit( STRIDER_RIGHT_LEG_FOLLOWER_INDEX );
+		break;
+	case STRIDER_AE_FLICKL:
+	case STRIDER_AE_FLICKR:
+		{
+			CBaseEntity *pRagdoll = m_hRagdoll;
+			if ( pRagdoll )
+			{
+				CPASAttenuationFilter filter( pRagdoll, "NPC_Strider.RagdollDetach" );
+				EmitSound( filter, pRagdoll->entindex(), "NPC_Strider.RagdollDetach" );
+				DetachAttachedRagdoll( pRagdoll );
+			}
+			m_hRagdoll = NULL;
+		}
+		break;
+
+	case STRIDER_AE_FOOTSTEP_LEFT:
+	case STRIDER_AE_FOOTSTEP_LEFTM:
+	case STRIDER_AE_FOOTSTEP_LEFTL:
+		LeftFootHit( pEvent->eventtime );
+		break;
+	case STRIDER_AE_FOOTSTEP_RIGHT:
+	case STRIDER_AE_FOOTSTEP_RIGHTM:
+	case STRIDER_AE_FOOTSTEP_RIGHTL:
+		RightFootHit( pEvent->eventtime );
+		break;
+	case STRIDER_AE_FOOTSTEP_BACK:
+	case STRIDER_AE_FOOTSTEP_BACKM:
+	case STRIDER_AE_FOOTSTEP_BACKL:
+		BackFootHit( pEvent->eventtime );
+		break;
+	case STRIDER_AE_WHOOSH_LEFT:
+		{
+			GetAttachment( "left foot", footPosition );
+
+			CPASAttenuationFilter filter( this, "NPC_Strider.Whoosh" );
+			EmitSound( filter, 0, "NPC_Strider.Whoosh", &footPosition );
+		}
+		break;
+	case STRIDER_AE_WHOOSH_RIGHT:
+		{
+			GetAttachment( "right foot", footPosition );
+
+			CPASAttenuationFilter filter( this, "NPC_Strider.Whoosh" );
+			EmitSound( filter, 0, "NPC_Strider.Whoosh", &footPosition );
+		}
+		break;
+	case STRIDER_AE_WHOOSH_BACK:
+		{
+			GetAttachment( "back foot", footPosition );
+
+			CPASAttenuationFilter filter( this, "NPC_Strider.Whoosh" );
+			EmitSound( filter, 0, "NPC_Strider.Whoosh", &footPosition );
+		}
+		break;
+	case STRIDER_AE_CREAK_LEFT:
+	case STRIDER_AE_CREAK_BACK:
+	case STRIDER_AE_CREAK_RIGHT:
+		{
+			EmitSound( "NPC_Strider.Creak" );
+		}
+		break;
+	default:
+		BaseClass::HandleAnimEvent( pEvent );
+		break;
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+Disposition_t CNPC_Strider::IRelationType( CBaseEntity *pTarget )
+{
+	if ( IsCannonTarget( pTarget ) )
+		return D_HT;
+
+	return BaseClass::IRelationType( pTarget );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::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_Strider::ScheduledMoveToGoalEntity( int scheduleType, CBaseEntity *pGoalEntity, Activity movementActivity )
+{
+	if ( IsCurSchedule( SCHED_STRIDER_RANGE_ATTACK2, false ) )
+	{
+		SetGoalEnt( pGoalEntity );
+		return true;
+	}
+	return BaseClass::ScheduledMoveToGoalEntity( scheduleType, pGoalEntity, movementActivity );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::ScheduledFollowPath( int scheduleType, CBaseEntity *pPathStart, Activity movementActivity )
+{
+	m_strTrackName = pPathStart->GetEntityName();
+	if ( IsCurSchedule( SCHED_STRIDER_RANGE_ATTACK2, false ) )
+	{
+		SetGoalEnt( pPathStart );
+		return true;
+	}
+	return BaseClass::ScheduledFollowPath( scheduleType, pPathStart, movementActivity );
+}
+
+
+//---------------------------------------------------------
+// Disables the minigun until EnableMinigun input is received.
+//---------------------------------------------------------
+void CNPC_Strider::InputDisableMinigun( inputdata_t &inputdata )
+{
+	m_bMinigunEnabled = false;
+	m_pMinigun->Enable( this, false );
+}
+
+
+//---------------------------------------------------------
+// Enables the minigun.
+//---------------------------------------------------------
+void CNPC_Strider::InputEnableMinigun( inputdata_t &inputdata )
+{
+	m_bMinigunEnabled = true;
+	m_pMinigun->Enable( this, true );
+}
+
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputSetMinigunTime( inputdata_t &inputdata )
+{
+	m_miniGunShootDuration = inputdata.value.Float();
+	m_pMinigun->SetShootDuration( m_miniGunShootDuration );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputSetMinigunTarget( inputdata_t &inputdata )
+{
+	CBaseEntity *pTargetEntity = gEntList.FindEntityByName( NULL, inputdata.value.String(), NULL, inputdata.pActivator, inputdata.pCaller );
+
+	m_pMinigun->StopShootingForSeconds( this, m_pMinigun->GetTarget(), 0 );
+	m_pMinigun->ShootAtTarget( this, pTargetEntity, m_miniGunShootDuration );
+	m_miniGunShootDuration = 0;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputSetCannonTarget( inputdata_t &inputdata )
+{
+	CBaseEntity *pTarget = gEntList.FindEntityByName( NULL, inputdata.value.String(), NULL, inputdata.pActivator, inputdata.pCaller );
+
+	if ( pTarget )
+	{
+		if ( m_hCannonTarget == pTarget )
+			return;
+			
+		CAI_BaseNPC **ppAIs = g_AI_Manager.AccessAIs();
+		CNPC_Strider *pStrider;
+		for ( int i = 0; i < g_AI_Manager.NumAIs(); i++ )
+		{
+			if ( ppAIs[i] != this && ppAIs[i]->ClassMatches( GetClassname() ) )
+			{
+				pStrider = (CNPC_Strider *)(ppAIs[i]);
+				if ( pStrider->GetCannonTarget() == pTarget )
+					return; // Already accounted for
+			}
+		}
+
+		if( pTarget->MyCombatCharacterPointer() && pTarget->IsAlive() )
+		{
+			m_hCannonTarget = pTarget;
+			m_AttemptCannonLOSTimer.Force();
+			return;
+		}
+	}
+
+	m_hCannonTarget = NULL;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputFlickRagdoll( inputdata_t &inputdata )
+{
+	if ( m_hRagdoll.Get() )
+	{
+		SetCondition( COND_STRIDER_DO_FLICK );
+	}
+}
+
+
+/*
+		IPhysicsObject *pPhysics0 = FindPhysicsObjectByName( STRING(m_nameAttach1), this );
+		IPhysicsObject *pPhysics1 = FindPhysicsObjectByName( STRING(m_nameAttach2), this );
+
+		if ( !pPhysics0 )
+		{
+			pPhysics0 = g_PhysWorldObject;
+		}
+		if ( !pPhysics1 )
+		{
+			pPhysics1 = g_PhysWorldObject;
+		}
+
+		if ( pPhysics0 != pPhysics1 )
+		{
+			m_disabled = !bEnable;
+			m_succeeded = true;
+			if ( bEnable )
+			{
+				PhysEnableEntityCollisions( pPhysics0, pPhysics1 );
+			}
+			else
+			{
+				PhysDisableEntityCollisions( pPhysics0, pPhysics1 );
+			}
+		}
+		else
+		{
+			m_succeeded = false;
+		}
+*/
+/*
+#pragma warning(push)
+#pragma warning(disable : 4706) // I know what I'm doing
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputDisableCollisionWith( inputdata_t &inputdata )
+{
+	IPhysicsObject *pIgnorePhys  = FindPhysicsObjectByName( inputdata.value.String(), this );
+	if ( !pIgnorePhys )
+		return;
+
+	int idx;
+	CBoneFollower *pFol;
+
+	for (idx = 0 ; pFol = GetBoneFollowerByIndex(idx) ; ++idx) // stop when the function starts returning null (idx is no longer good)
+	{
+		IPhysicsObject *pFollowPhys = pFol->VPhysicsGetObject();
+		Assert(pFollowPhys);
+		PhysDisableEntityCollisions( pIgnorePhys, pFollowPhys );
+	}
+}
+#pragma warning(pop)
+*/
+
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputDisableCollisionWith( inputdata_t &inputdata )
+{
+	IPhysicsObject *pIgnorePhys  = FindPhysicsObjectByName( inputdata.value.String(), this );
+	if ( !pIgnorePhys )
+		return;
+
+	
+	// CBoneFollower *pFol;
+
+	for (int idx = m_BoneFollowerManager.GetNumBoneFollowers() - 1 ; idx >= 0 ; --idx) // stop when the function starts returning null (idx is no longer good)
+	{
+		IPhysicsObject *pFollowPhys = GetBoneFollowerByIndex(idx)->VPhysicsGetObject();
+		Assert(pFollowPhys);
+		PhysDisableEntityCollisions( pIgnorePhys, pFollowPhys );
+	}
+}
+
+
+ 
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputEnableCollisionWith( inputdata_t &inputdata )
+{
+	IPhysicsObject *pIgnorePhys  = FindPhysicsObjectByName( inputdata.value.String(), this );
+	if ( !pIgnorePhys )
+		return;
+
+	int idx;
+	// CBoneFollower *pFol;
+
+	for (idx = m_BoneFollowerManager.GetNumBoneFollowers() - 1 ; idx >= 0 ; --idx) // stop when the function starts returning null (idx is no longer good)
+	{
+		/*
+		pFol = GetBoneFollowerByIndex(idx);
+		Assert(pFol);
+		IPhysicsObject *pFollowPhys = pFol->VPhysicsGetObject();
+		Assert(pFollowPhys);
+		*/
+		IPhysicsObject *pFollowPhys = GetBoneFollowerByIndex(idx)->VPhysicsGetObject();
+		PhysEnableEntityCollisions( pIgnorePhys, pFollowPhys );
+	}
+} 
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputCrouch( inputdata_t &inputdata )
+{
+	if ( !IsCurSchedule( SCHED_STRIDER_CROUCH ) && !IsInCrouchedPosture() )
+		SetCondition( COND_STRIDER_SHOULD_CROUCH );
+	m_bCrouchLocked = true;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputCrouchInstantly( inputdata_t &inputdata )
+{
+	if ( !IsCurSchedule( SCHED_STRIDER_CROUCH ) && !IsInCrouchedPosture() )
+	{
+		m_bFastCrouch = true;
+		SetCondition( COND_STRIDER_SHOULD_CROUCH );
+	}
+	m_bCrouchLocked = true;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputStand( inputdata_t &inputdata )
+{
+	if ( !IsCurSchedule( SCHED_STRIDER_STAND ) && !IsInStandingPosture() )
+		SetCondition( COND_STRIDER_SHOULD_STAND );
+	m_bCrouchLocked = false;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputSetHeight( inputdata_t &inputdata )
+{
+	SetIdealHeight( inputdata.value.Float() );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputSetTargetPath( inputdata_t &inputdata )
+{
+	m_strTrackName = MAKE_STRING( inputdata.value.String() );
+	SetGoalEnt( NULL );
+
+	if( !IsStriderCrouching() && !IsStriderStanding() && !IsInCrouchedPosture() )
+	{
+		SetTargetPath();
+	}
+
+	// Otherwise, we just leave the track name set and the AI will
+	// get to it as soon as possible (as soon as the strider can be
+	// made to stand).
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputClearTargetPath( inputdata_t &inputdata )
+{
+	if (GetNavigator()->IsGoalActive() && GetNavigator()->GetGoalType() == GOALTYPE_PATHCORNER )
+	{
+		GetNavigator()->ClearGoal();
+		ClearSchedule( "Target path cleared via input" );
+	}
+	m_strTrackName = MAKE_STRING( STRIDER_NO_TRACK_NAME );
+	SetGoalEnt(NULL);
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputDisableCrouchWalk( inputdata_t &inputdata )
+{
+	m_bNoCrouchWalk = true;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputEnableCrouchWalk( inputdata_t &inputdata )
+{
+	m_bNoCrouchWalk = false;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputEnableAggressiveBehavior( inputdata_t &inputdata )
+{
+	m_bUseAggressiveBehavior = true;
+	GetEnemies()->SetEnemyDiscardTime( 601.0f );	// Make the assert in SetFreeKnowledgeDuration() happy.
+	GetEnemies()->SetFreeKnowledgeDuration( 600.0f );
+
+	AI_FreePassParams_t params = m_PlayerFreePass.GetParams();
+	params.duration = 0.8f;
+	params.coverDist = 1200.0f;
+	m_PlayerFreePass.SetParams( params );
+
+	GetTacticalServices()->AllowFindLateralLos( false );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputDisableAggressiveBehavior( inputdata_t &inputdata )
+{
+	m_bUseAggressiveBehavior = false;
+	GetEnemies()->SetFreeKnowledgeDuration( strider_free_knowledge.GetFloat() );
+	GetEnemies()->SetEnemyDiscardTime( AI_DEF_ENEMY_DISCARD_TIME );
+
+	AI_FreePassParams_t params = m_PlayerFreePass.GetParams();
+	params.duration = strider_free_pass_duration.GetFloat();
+	params.coverDist = strider_free_pass_cover_dist.GetFloat();
+	m_PlayerFreePass.SetParams( params );
+
+	GetTacticalServices()->AllowFindLateralLos( true );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputStopShootingMinigunForSeconds( inputdata_t &inputdata )
+{
+	m_pMinigun->StopShootingForSeconds( this, NULL, inputdata.value.Float() );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputDisableCrouch( inputdata_t &inputdata )
+{
+	m_bDontCrouch = true;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputDisableMoveToLOS( inputdata_t &inputdata )
+{
+	m_bNoMoveToLOS = true;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputExplode( inputdata_t &inputdata )
+{
+	CTakeDamageInfo killInfo;
+	killInfo.SetAttacker( this );
+	killInfo.SetInflictor( this );
+	killInfo.SetDamage( GetHealth() );
+	TakeDamage( killInfo );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::InputScaleGroundSpeed( inputdata_t &inputdata )
+{
+	m_flTargetSpeedScale = inputdata.value.Float();
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::FVisible( CBaseEntity *pEntity, int traceMask, CBaseEntity **ppBlocker )
+{
+	bool bIsVisible = BaseClass::FVisible( pEntity, traceMask, ppBlocker );
+	
+	if ( bIsVisible && pEntity == m_PlayerFreePass.GetPassTarget() )
+	{
+		bIsVisible = m_PlayerFreePass.ShouldAllowFVisible( bIsVisible );
+
+		if( !bIsVisible && IsUsingAggressiveBehavior() && FInViewCone(pEntity) )
+		{
+			AlertSound();
+		}
+	}
+
+	return bIsVisible;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+Vector CNPC_Strider::BodyTarget( const Vector &posSrc, bool bNoisy )
+{
+	if ( m_BodyTargetBone != -1 )
+	{
+		Vector position;
+		QAngle angles;
+		GetBonePosition( m_BodyTargetBone, position, angles );
+		return position;
+	}
+	return BaseClass::BodyTarget( posSrc, bNoisy );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::IsValidEnemy( CBaseEntity *pTarget )
+{
+	if ( HasCannonTarget() )
+	{
+		return IsCannonTarget(pTarget);
+	}
+
+	if ( pTarget->IsPlayer() )
+	{
+		if ( AIGetNumFollowers( this, m_iszHunterClassname ) > 0 )
+			return false;
+	}
+
+	CBaseCombatCharacter *pEnemy = ToBaseCombatCharacter( pTarget );
+	if ( pEnemy )
+	{
+		// Test our enemy filter
+		if ( m_hEnemyFilter.Get()!= NULL && m_hEnemyFilter->PassesFilter( this, pEnemy ) == false )
+			return false;
+
+		return true;
+	}
+
+	return BaseClass::IsValidEnemy( pTarget );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::UpdateEnemyMemory( CBaseEntity *pEnemy, const Vector &position, CBaseEntity *pInformer )
+{
+	if( pInformer && FClassnameIs( pInformer, "npc_cscanner" ) )
+	{
+		EmitSound( "NPC_Strider.Alert" );
+		// Move Strider's focus to this location and make strider mad at it
+		// (but less mad than at any other potential entities in the scene).
+#if 1
+		GetFocus()->SetAbsOrigin( position + Vector( 0, 0, 32 ) );
+#else
+		trace_t tr;
+		AI_TraceLine( EyePosition(), position + Vector( 0, 0, 32 ), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
+		GetFocus()->SetAbsOrigin( tr.endpos );
+#endif
+
+		SetCondition( COND_STRIDER_ENEMY_UPDATED );
+
+		m_EnemyUpdatedTimer.Set( 20 );
+
+		AddEntityRelationship( GetFocus(), D_HT, -1 );
+
+		if( pEnemy->IsPlayer() )
+		{
+			m_PlayerFreePass.Revoke();
+		}
+		
+		BaseClass::UpdateEnemyMemory( GetFocus(), GetFocus()->GetAbsOrigin(), pInformer );
+
+		// Change the informer to myself so that information provided by a scanner is 
+		// as good as firsthand knowledge insofar as enemy memory is concerned.
+		pInformer = this;
+	}
+
+	return BaseClass::UpdateEnemyMemory( pEnemy, position, pInformer );
+}
+
+//---------------------------------------------------------
+// HACKHACK: The base class looks at distance from the head of the strider
+// But when stomping, we need distance from the feet.  Recompute it here.
+// UNDONE: make enemy distance aware of strider
+//---------------------------------------------------------
+float CNPC_Strider::StriderEnemyDistance( CBaseEntity *pEnemy )
+{
+	Vector enemyDelta = pEnemy->WorldSpaceCenter() - WorldSpaceCenter();
+	
+	// NOTE: We ignore rotation for computing height.  Assume it isn't an effect
+	// we care about, so we simply use OBBSize().z for height.  
+	// Otherwise you'd do this:
+	// float enemyHeight = enemyMaxs.z - enemyMins.z;
+
+	float enemyHeight = pEnemy->CollisionProp()->OBBSize().z;
+	Vector striderSurroundMins, striderSurroundMaxs;
+	CollisionProp()->WorldSpaceSurroundingBounds( &striderSurroundMins, &striderSurroundMaxs );
+	float myHeight = striderSurroundMaxs.z - striderSurroundMins.z;
+	
+	// max distance our centers can be apart with the boxes still overlapping
+	float flMaxZDist = ( enemyHeight + myHeight ) * 0.5f;
+
+	// see if the enemy is closer to my head, feet or in between
+	if ( enemyDelta.z > flMaxZDist )
+	{
+		// enemy feet above my head, compute distance from my head to his feet
+		enemyDelta.z -= flMaxZDist;
+	}
+	else if ( enemyDelta.z < -flMaxZDist )
+	{
+		// enemy head below my feet, return distance between my feet and his head
+		enemyDelta.z += flMaxZDist;
+	}
+	else
+	{
+		// boxes overlap in Z, no delta
+		enemyDelta.z = 0;
+	}
+
+	return enemyDelta.Length();
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::FCanCheckAttacks()
+{
+	// Strider has direct and indirect attacks, so he's always checking
+	// as long as the enemy is in front of him.
+	if( FInViewCone( GetEnemy() ) )
+	{
+		return true;
+	}
+
+	return false;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+int CNPC_Strider::RangeAttack2Conditions( float flDot, float flDist )
+{
+	// All of this code has moved to GatherConditions(), since the 
+	// strider uses the cannon on things that aren't the enemy!
+	return COND_NONE;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+int CNPC_Strider::MeleeAttack1Conditions( float flDot, float flDist )
+{
+	if ( m_bDisableBoneFollowers )
+	{
+		return COND_NONE;
+	}
+
+	if (gpGlobals->curtime < m_nextStompTime)
+	{
+		return COND_NONE;
+	}
+
+	if ( IsInCrouchedPosture() )
+	{
+		return COND_NONE;
+	}
+
+	CBaseEntity *pEnemy = GetEnemy();
+	if ( !pEnemy )
+		return COND_NONE;
+
+	// No more stabbing players.
+	if ( pEnemy->IsPlayer() && !HasSpawnFlags(SF_CAN_STOMP_PLAYER) )
+		return COND_NONE;
+
+	if( !HasCondition( COND_SEE_ENEMY ) )
+	{
+		return COND_NONE;
+	}
+
+	// recompute this because the base class function does not work for the strider
+	flDist = StriderEnemyDistance( pEnemy );
+	
+	if ( flDist > STRIDER_STOMP_RANGE )
+	{
+		return COND_NONE;
+	}
+
+	// strider will cross his feet, but only 6ft over
+	Vector right;
+	GetVectors( NULL, &right, NULL );
+	if ( DotProduct( pEnemy->GetAbsOrigin() - GetAbsOrigin(), right ) > 72 )
+	{
+		return COND_NONE;
+	}
+
+	// Don't skewer if crouched too low.
+	if( GetHeight() < GetMaxHeight() - ( (GetMaxHeight()-GetMinHeight()) / 2 ) )
+	{
+		return COND_NONE;
+	}
+
+	// Don't skewer if target is too high above or below ground.
+	Vector vecGround = GetAbsOrigin();
+	MoveToGround( &vecGround, this, Vector( -16, -16, -16 ), Vector( 16, 16, 16 ) );
+	if( fabs( vecGround.z - GetEnemy()->GetAbsOrigin().z ) > 64.0f )
+	{
+		return COND_NONE;
+	}
+
+	// too far, but don't change schedules/movement
+	return COND_CAN_MELEE_ATTACK1;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+int CNPC_Strider::MeleeAttack2Conditions( float flDot, float flDist )
+{
+	// HACKHACK: Disabled until we get a good right-leg animation
+	return COND_NONE;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::WeaponLOSCondition(const Vector &ownerPos, const Vector &targetPos, bool bSetConditions)
+{
+	CBaseEntity *pTargetEnt;
+	Vector vRootOffset;
+	Vector vBarrelOffset;
+
+	vRootOffset.x = vRootOffset.y = 0;
+	if ( GetCannonTarget() )
+	{
+		//Assert( targetPos == GetCannonTarget()->GetAbsOrigin() );
+		pTargetEnt = GetCannonTarget();
+		vRootOffset.z = gm_zCannonDist;
+		vBarrelOffset = gm_vLocalRelativePositionCannon;
+	}
+	else
+	{
+		pTargetEnt = GetEnemy();
+		vRootOffset.z = gm_zMinigunDist;
+		vBarrelOffset = gm_vLocalRelativePositionMinigun;
+	}
+
+	trace_t tr;
+	AI_TraceLine( ownerPos + vRootOffset, targetPos, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);
+
+	// Hit the enemy, or hit nothing (traced all the way to a nonsolid enemy like a bullseye)
+	if ( ( pTargetEnt && tr.m_pEnt == pTargetEnt) || tr.fraction == 1.0 || CanShootThrough( tr, targetPos ) )
+	{
+		Vector vBarrelPos;
+		matrix3x4_t losTestToWorld;
+
+		Vector xaxis;
+		VectorSubtract( targetPos, ownerPos, xaxis );
+
+		// @TODO (toml 03-07-04): Add an angle test
+		//float flAngle = acos( xaxis.z / xaxis.Length() );
+
+		xaxis.z = 0.0f;
+		float flLength = VectorNormalize( xaxis );
+		if ( flLength < 1e-3 )
+			return false;
+
+		Vector yaxis( -xaxis.y, xaxis.x, 0.0f );
+
+		MatrixInitialize( losTestToWorld, ownerPos, xaxis, yaxis, Vector(0,0,1) );
+
+		VectorTransform( vBarrelOffset, losTestToWorld, vBarrelPos );
+
+		AI_TraceLine( vBarrelPos, targetPos, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);
+		if ( ( pTargetEnt && tr.m_pEnt == pTargetEnt) || tr.fraction == 1.0 || CanShootThrough( tr, targetPos ) )
+		{
+			if ( strider_show_weapon_los_condition.GetBool() )
+			{
+				NDebugOverlay::Line( ownerPos + vRootOffset, targetPos, 255, 0, 255, false, 0.1 );
+				NDebugOverlay::Line( vBarrelPos, targetPos, 128, 0, 128, false, 0.1 );
+			}
+			return true;
+		}
+		else
+		{
+			if ( strider_show_weapon_los_condition.GetBool() )
+			{
+				NDebugOverlay::Line( ownerPos + vRootOffset, targetPos, 255, 0, 255, false, 0.1 );
+				NDebugOverlay::Line( vBarrelPos, tr.endpos, 128, 0, 0, false, 0.1 );
+			}
+		}
+	}
+	else
+	{
+		if ( strider_show_weapon_los_condition.GetBool() )
+		{
+			NDebugOverlay::Line( ownerPos + vRootOffset, tr.endpos, 255, 0, 0, false, 0.1 );
+		}
+	}
+
+	return false;
+}
+
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::CurrentWeaponLOSCondition(const Vector &targetPos, bool bSetConditions)
+{
+	return WeaponLOSCondition( GetAdjustedOrigin(), targetPos, bSetConditions );
+}
+
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::IsValidShootPosition( const Vector &vecCoverLocation, CAI_Node *pNode, CAI_Hint const *pHint )
+{
+	if ( ( pNode && !pHint ) || ( pHint && pHint->HintType() != HINT_STRIDER_NODE ) )
+		return false;
+	return BaseClass::IsValidShootPosition( vecCoverLocation, pNode, pHint );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::TestShootPosition(const Vector &vecShootPos, const Vector &targetPos )	
+{ 
+	if ( BaseClass::TestShootPosition( vecShootPos, targetPos ) )
+	{
+		return true;
+	}
+
+	// What if I crouched?
+	float zDelta = ( ( vecShootPos.z - targetPos.z ) + gm_vLocalRelativePositionMinigun.z ) - 12;
+	if ( zDelta > 0 )
+	{
+		if ( zDelta > GetHeightRange() )
+			zDelta = GetHeightRange();
+
+		Vector vecTestPos = vecShootPos;
+		vecTestPos.z -= zDelta;
+
+		if ( BaseClass::TestShootPosition( vecTestPos, targetPos ) )
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+Vector CNPC_Strider::Weapon_ShootPosition( )
+{
+	Vector vecShootPos;
+	GetAttachment( gm_CannonAttachment, vecShootPos );
+
+	return vecShootPos;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType )
+{
+	float flTracerDist;
+	Vector vecDir;
+	Vector vecEndPos;
+
+	vecDir = tr.endpos - vecTracerSrc;
+
+	flTracerDist = VectorNormalize( vecDir );
+
+	UTIL_Tracer( vecTracerSrc, tr.endpos, 0, TRACER_DONT_USE_ATTACHMENT, 5000, true, "StriderTracer" );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::DoImpactEffect( trace_t &tr, int nDamageType )
+{
+	BaseClass::DoImpactEffect( tr, nDamageType );
+
+	// Add a halo
+	CBroadcastRecipientFilter filter;
+	te->BeamRingPoint( filter, 0.0, 
+		tr.endpos,							//origin
+		0,									//start radius
+		64,									//end radius
+		s_iImpactEffectTexture,				//texture
+		0,									//halo index
+		0,									//start frame
+		0,									//framerate
+		0.2,								//life
+		10,									//width
+		0,									//spread
+		0,									//amplitude
+		255,								//r
+		255,								//g
+		255,								//b
+		50,									//a
+		0,									//speed
+		FBEAM_FADEOUT
+		);
+
+	g_pEffects->EnergySplash( tr.endpos, tr.plane.normal );
+	
+	// Punch the effect through?
+	if( tr.m_pEnt && !tr.m_pEnt->MyNPCPointer() )
+	{
+		Vector vecDir = tr.endpos - tr.startpos;
+		VectorNormalize( vecDir );
+
+		trace_t retrace;
+
+		Vector vecReTrace = tr.endpos + vecDir * 12;
+
+		if( UTIL_PointContents( vecReTrace ) == CONTENTS_EMPTY )
+		{
+			AI_TraceLine( vecReTrace, vecReTrace - vecDir * 24, MASK_SHOT, NULL, COLLISION_GROUP_NONE, &retrace );
+
+			BaseClass::DoImpactEffect( retrace, nDamageType );
+		}
+	}
+}
+
+//---------------------------------------------------------
+// Trace didn't hit the intended target, but should the strider
+// shoot anyway? We use this to get the strider to destroy 
+// breakables that are between him and his target.
+//---------------------------------------------------------
+bool CNPC_Strider::CanShootThrough( const trace_t &tr, const Vector &vecTarget )
+{
+	if( GetCannonTarget() )
+	{
+		// Cannon does not have this behavior.
+		return false;
+	}
+
+	if( !tr.m_pEnt )
+	{
+		return false;
+	}
+
+	if( !tr.m_pEnt->GetHealth() )
+	{
+		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;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::CreateFocus()
+{
+	m_hFocus = CreateEntityByName( "bullseye_strider_focus" );
+
+	ASSERT( m_hFocus != NULL );
+	m_hFocus->AddSpawnFlags( SF_BULLSEYE_NONSOLID | SF_BULLSEYE_NODAMAGE );
+	m_hFocus->SetAbsOrigin( GetAbsOrigin() );
+	m_hFocus->Spawn();
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+CNPC_Bullseye *CNPC_Strider::GetFocus()
+{
+	ASSERT( m_hFocus != NULL );
+
+	CNPC_Bullseye *pBull = dynamic_cast<CNPC_Bullseye*>(m_hFocus.Get());
+
+	return pBull;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::GetWeaponLosZ( const Vector &vOrigin, float minZ, float maxZ, float increment, CBaseEntity *pTarget, float *pResult )
+{
+	Vector vTestPos;
+	Vector vTargetPos = pTarget->BodyTarget(vOrigin, false);
+	Vector vIncrement( 0, 0, increment );
+
+	// Try right where am
+	if ( vOrigin.z >= minZ && vOrigin.z <= maxZ )
+	{
+		vTestPos = vOrigin;
+		if ( WeaponLOSCondition( vTestPos, vTargetPos, false ) )
+		{
+			if ( strider_show_weapon_los_z.GetBool() )
+				NDebugOverlay::Line( vTestPos, vTargetPos, 0, 255, 0, false, 0.1 );
+			*pResult = vTestPos.z;
+			return true;
+		}
+	}
+
+	// Try at adjusted height of target
+	vTestPos.z = ( vTargetPos.z - gm_vLocalRelativePositionMinigun.z ) + 12;
+
+	if ( vTestPos.z >= minZ && vTestPos.z <= maxZ )
+	{
+		if ( WeaponLOSCondition( vTestPos, vTargetPos, false ) )
+		{
+			if ( strider_show_weapon_los_z.GetBool() )
+				NDebugOverlay::Line( vTestPos, vTargetPos, 0, 255, 0, false, 0.1 );
+			*pResult = vTestPos.z;
+			return true;
+		}
+	}
+	
+
+	// Try at max height
+	vTestPos.z = maxZ;
+	if ( WeaponLOSCondition( vTestPos, vTargetPos, false ) )
+	{
+		if ( strider_show_weapon_los_z.GetBool() )
+			NDebugOverlay::Line( vOrigin, vTargetPos, 0, 255, 0, false, 0.1 );
+		*pResult = vTestPos.z;
+		return true;
+	}
+
+	// Try min height
+	vTestPos.z = minZ;
+	if ( WeaponLOSCondition( vTestPos, vTargetPos, false ) )
+	{
+		if ( strider_show_weapon_los_z.GetBool() )
+			NDebugOverlay::Line( vTestPos, vTargetPos, 0, 255, 0, false, 0.1 );
+		*pResult = vTestPos.z;
+		return true;
+	}
+	
+	// Test up from min
+	vTestPos = vOrigin + vIncrement;
+	while ( vTestPos.z <= maxZ && !WeaponLOSCondition( vTestPos, vTargetPos, false ) )
+	{
+		vTestPos += vIncrement;
+	}
+	
+	if ( vTestPos.z <= maxZ )
+	{
+		if ( strider_show_weapon_los_z.GetBool() )
+			NDebugOverlay::Line( vTestPos, vTargetPos, 0, 255, 0, false, 0.1 );
+		*pResult = vTestPos.z;
+		return true;
+	}
+
+	// Test down
+	vTestPos = vOrigin - vIncrement;
+	while ( vTestPos.z >= minZ && !WeaponLOSCondition( vTestPos, vTargetPos, false ) )
+	{
+		vTestPos -= vIncrement;
+	}
+	
+	if ( vTestPos.z >= minZ )
+	{
+		if ( strider_show_weapon_los_z.GetBool() )
+			NDebugOverlay::Line( vTestPos, vTargetPos, 0, 255, 0, false, 0.1 );
+		*pResult = vTestPos.z;
+		return true;
+	}
+		
+	return false;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::AlertSound()
+{
+	if( ( gpGlobals->curtime - m_flTimeLastAlertSound ) > 2.0f )
+	{
+		EmitSound( "NPC_Strider.Alert" );
+		m_flTimeLastAlertSound = gpGlobals->curtime;
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::PainSound( const CTakeDamageInfo &info )
+{
+	// This means that we've exploded into pieces and have no way to whimper
+	if ( ShouldExplodeFromDamage( info ) )
+		return;
+
+	EmitSound( "NPC_Strider.Pain" );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::DeathSound( const CTakeDamageInfo &info )
+{
+	// This means that we've exploded into pieces and have no way to whimper
+	if ( m_bExploding )
+	{
+		EmitSound( "NPC_Strider.StriderBusterExplode" );
+		EmitSound( "explode_5" );
+		return;
+	}
+
+	EmitSound( "NPC_Strider.Death" );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::HuntSound()
+{
+	if( m_PlayerFreePass.HasPass() )
+	{
+		EmitSound( "NPC_Strider.Hunt" );
+		m_flTimeNextHuntSound = gpGlobals->curtime + random->RandomFloat( 8.0f, 12.0f );
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::TraceAttack( const CTakeDamageInfo &inputInfo, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
+{
+	CTakeDamageInfo info = inputInfo;
+
+	bool ricochetBullets = true;
+
+	if ( info.GetAttacker()->IsPlayer() )
+	{
+		if ( !HasMemory( bits_MEMORY_PROVOKED ) )
+		{
+			GetEnemies()->ClearMemory( info.GetAttacker() );
+			Remember( bits_MEMORY_PROVOKED );
+			SetCondition( COND_LIGHT_DAMAGE );
+		}
+	}
+
+#ifdef HL2_EPISODIC
+
+	// Attempt to hit strider busters in the area
+	float flDistSqr;
+	for ( int i = 0; i < m_hAttachedBusters.Count(); i++ )
+	{
+		if ( m_hAttachedBusters[i] == NULL )
+			continue;
+
+		flDistSqr = ( m_hAttachedBusters[i]->WorldSpaceCenter() - inputInfo.GetDamagePosition() ).LengthSqr();
+		if ( flDistSqr < Square( 50.0f ) )
+		{
+			// Kill the buster and stop the trace going through
+			CTakeDamageInfo killInfo = inputInfo;
+			killInfo.SetDamage( 100 );
+
+			m_hAttachedBusters[i]->TakeDamage( killInfo );
+			return;
+		}
+	}
+
+#endif	//HL2_EPISODIC
+
+	if ( (info.GetDamageType() & DMG_BULLET) && ricochetBullets )
+	{
+		g_pEffects->Ricochet(ptr->endpos,ptr->plane.normal);
+		if ( ptr->hitgroup != HITGROUP_HEAD )
+		{
+			info.SetDamage( 0.01 );
+		}
+	}
+
+	BaseClass::TraceAttack( info, vecDir, ptr, pAccumulator );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+int CNPC_Strider::OnTakeDamage_Alive( const CTakeDamageInfo &info )
+{
+	// don't take damage from my own weapons!!!
+	if ( info.GetInflictor() && info.GetInflictor()->GetOwnerEntity() == this )
+		return 0;
+
+	// special interaction with combine balls
+	if ( UTIL_IsCombineBall( info.GetInflictor() ) )
+		return TakeDamageFromCombineBall( info );
+
+	if ( info.GetDamageType() == DMG_GENERIC )
+		return BaseClass::OnTakeDamage_Alive( info );
+
+	if( IsUsingAggressiveBehavior() )
+	{
+		// Any damage the player inflicts gets my attention, even if it doesn't actually harm me.
+		if ( info.GetAttacker()->IsPlayer() )
+		{
+			UpdateEnemyMemory( info.GetAttacker(), info.GetAttacker()->GetAbsOrigin() );
+		}
+	}
+
+	//int healthIncrement = 5 - ( m_iHealth / ( m_iMaxHealth / 5 ) );
+	if ( (info.GetDamageType() & DMG_BLAST) && info.GetMaxDamage() > 50 )
+	{
+		Vector headPos = BodyTarget( info.GetDamagePosition(), false );
+		
+		float dist = CalcDistanceToAABB( WorldAlignMins(), WorldAlignMaxs(), info.GetDamagePosition() - headPos );
+		// close enough to do damage?
+		if ( dist < 200 )
+		{
+			bool bPlayer = info.GetAttacker()->IsPlayer();
+			if ( bPlayer )
+			{
+				m_PlayerFreePass.Revoke();
+				AddFacingTarget( info.GetAttacker(), info.GetAttacker()->GetAbsOrigin(), 1.0, 2.0 );
+
+				UpdateEnemyMemory( info.GetAttacker(), info.GetAttacker()->GetAbsOrigin() );
+			}
+			else
+				AddFacingTarget( info.GetAttacker(), info.GetAttacker()->GetAbsOrigin(), 0.5, 2.0 );
+
+			// Default to NPC damage value
+			int damage = 20;
+
+			if( HasSpawnFlags(SF_TAKE_MINIMAL_DAMAGE_FROM_NPCS) )
+				damage = 1;
+
+			if( bPlayer )
+			{
+				if( g_pGameRules->IsSkillLevel(SKILL_EASY) )
+				{
+					damage = GetMaxHealth() / sk_strider_num_missiles1.GetFloat();
+				}
+				else if( g_pGameRules->IsSkillLevel(SKILL_HARD) )
+				{
+					damage = GetMaxHealth() / sk_strider_num_missiles3.GetFloat();
+				}
+				else // Medium, or unspecified
+				{
+					damage = GetMaxHealth() / sk_strider_num_missiles2.GetFloat();
+				}
+			}
+
+			m_iHealth -= damage;
+
+			m_OnDamaged.FireOutput( info.GetAttacker(), this);
+
+			if( info.GetAttacker()->IsPlayer() )
+			{
+				m_OnDamagedByPlayer.FireOutput( info.GetAttacker(), this );
+
+				// This also counts as being harmed by player's squad.
+				m_OnDamagedByPlayerSquad.FireOutput( info.GetAttacker(), this );
+			}
+			else
+			{
+				// See if the person that injured me is an NPC.
+				CAI_BaseNPC *pAttacker = dynamic_cast<CAI_BaseNPC *>( info.GetAttacker() );
+				CBasePlayer *pPlayer = AI_GetSinglePlayer();
+
+				if( pAttacker && pAttacker->IsAlive() && pPlayer )
+				{
+					if( pAttacker->GetSquad() != NULL && pAttacker->IsInPlayerSquad() )
+					{
+						m_OnDamagedByPlayerSquad.FireOutput( info.GetAttacker(), this );
+					}
+				}
+			}
+
+			if ( m_iHealth <= ( m_iMaxHealth / 2 ) )
+			{
+				m_OnHalfHealth.FireOutput(this, this);
+			}
+
+			RestartGesture( ACT_GESTURE_SMALL_FLINCH );
+			PainSound( info );
+
+			// Interrupt our gun during the flinch
+			m_pMinigun->StopShootingForSeconds( this, m_pMinigun->GetTarget(), 1.1f );
+
+			GetEnemies()->OnTookDamageFrom( info.GetAttacker() );
+
+			if( !IsSmoking() && m_iHealth <= sk_strider_health.GetInt() / 2 )
+			{
+				StartSmoking();
+			}
+			return damage;
+		}
+
+// NOTE: Currently radius damage doesn't even call this because it uses the origin, not the box for distance
+#if 0
+		NDebugOverlay::Box( headPos, WorldAlignMins(), WorldAlignMaxs(), 255, 0, 0, 0, 5.0 );
+		NDebugOverlay::Cross3D( inf
+			o.GetDamagePosition(), 24, 0, 255, 0, false, 5.0 );
+		// too far from head, apply damage to nearest leg?
+#endif
+	}
+
+#if 0
+	if ( (info.GetDamageType() & DMG_BULLET) && info.GetDamage() > 1  && m_iHealth > 1 )
+	{
+		m_iHealth -= 1;
+		return 1;
+	}
+#endif
+
+	return 0;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+int CNPC_Strider::TakeDamageFromCombineBall( const CTakeDamageInfo &info )
+{
+	float damage = info.GetDamage();
+
+	// If it's only an AR2 alt-fire, we don't take much damage
+	if ( UTIL_IsAR2CombineBall( info.GetInflictor() ) )
+	{
+		damage = strider_ar2_altfire_dmg.GetFloat();
+	}
+	else
+	{
+		// Always start smoking when we're struck by a normal combine ball
+		StartSmoking();
+	}
+
+	if( info.GetAttacker() && info.GetAttacker()->IsPlayer() )
+	{
+		// Route combine ball damage through the regular skill level code.
+		damage = g_pGameRules->AdjustPlayerDamageInflicted(damage);
+	}
+
+	AddFacingTarget( info.GetInflictor(), info.GetInflictor()->GetAbsOrigin(), 0.5, 2.0 );
+	if ( !UTIL_IsAR2CombineBall( info.GetInflictor() ) )
+		RestartGesture( ACT_GESTURE_BIG_FLINCH );
+	else
+		RestartGesture( ACT_GESTURE_SMALL_FLINCH );
+	
+	PainSound( info );
+
+	m_iHealth -= damage;
+
+	return damage;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::Event_Killed( const CTakeDamageInfo &info )
+{
+	// Do a special death if we're killed by a combine ball in the Citadel
+	if ( info.GetInflictor() && UTIL_IsCombineBall( info.GetInflictor() ) )
+	{
+		if ( m_lifeState == LIFE_DYING )
+			return;
+
+		// Tracker 23610:  Strider playing death sounds twice (AI_BaseNPC calls it in Event_Killed, too)
+		// DeathSound( info );
+		m_lifeState = LIFE_DYING;
+
+		// Start dying
+		RestartGesture( (Activity) ACT_STRIDER_GESTURE_DEATH );
+
+		// Stop our mini-cannon
+		m_pMinigun->StopShootingForSeconds( this, m_pMinigun->GetTarget(), 100.0f );
+	}
+	else
+	{
+		StopSmoking();
+
+		m_BoneFollowerManager.DestroyBoneFollowers();
+	
+	}
+
+	if( IsUsingAggressiveBehavior() )
+	{
+		// Lifted this code from the gunship.
+		Vector vecExplode;
+		GetAttachment( "minigun", vecExplode );
+		ExplosionCreate( vecExplode, QAngle(0,0,1), this, 100, 128, false );
+	}
+
+	// Determine if we're going to explode into pieces
+	m_bExploding = ShouldExplodeFromDamage( info );
+
+	BaseClass::Event_Killed( info );
+
+	// Stop our large cannon
+	EntityMessageBegin( this, true );
+		WRITE_BYTE( STRIDER_MSG_DEAD );
+	MessageEnd();
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::RagdollDeathEffect( CRagdollProp *pRagdoll, float flDuration )
+{
+	UTIL_ScreenShake( EyePosition(), 50, 150.0, 1.0, 1024, SHAKE_START );
+
+	int i;
+	for( i = 0 ; i < 2 ; i++ )
+	{
+		SmokeTrail *pSmoke = SmokeTrail::CreateSmokeTrail();
+		if ( pSmoke )
+		{
+			if( i == 0 )
+			{
+				pSmoke->m_SpawnRate			= 16;
+				pSmoke->m_Opacity 			= 0.25;
+				pSmoke->m_StartColor.Init( 0.45f, 0.45f, 0.45f );
+			}
+			else
+			{
+				pSmoke->m_SpawnRate			= 32;
+				pSmoke->m_Opacity 			= 0.3;
+				pSmoke->m_StartColor.Init( 0.5f, 0.5f, 0.5f );
+			}
+
+			pSmoke->m_ParticleLifetime	= 3.0;
+			pSmoke->m_StartSize			= 16;
+			pSmoke->m_EndSize			= 64;
+			pSmoke->m_SpawnRadius		= 20;
+			pSmoke->m_MinSpeed			= 8;
+			pSmoke->m_MaxSpeed			= 64;
+			pSmoke->m_EndColor.Init( 0, 0, 0 );
+
+			pSmoke->SetLifetime( flDuration );
+
+			if( i == 0 )
+			{
+				pSmoke->FollowEntity( pRagdoll, "MiniGunBase" );
+			}
+			else
+			{
+				pSmoke->FollowEntity( pRagdoll, "vehicle_driver_eyes" );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : &info - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CNPC_Strider::ShouldExplodeFromDamage( const CTakeDamageInfo &info )
+{
+	CBaseEntity *pInflictor = info.GetInflictor();
+	if ( pInflictor == NULL )
+		return false;
+
+	// Combine balls make us explode
+	if ( UTIL_IsCombineBall( info.GetInflictor() ) )
+		return true;
+
+	// Stickybombs make us explode
+	CBaseEntity *pAttacker = info.GetAttacker();
+	if ( pAttacker != NULL && (FClassnameIs( pAttacker, "weapon_striderbuster" ) ||
+								FClassnameIs( pAttacker, "npc_grenade_magna" )))
+		return true;
+
+	if ( pInflictor == this && pAttacker == this )
+		return true;
+
+	return false;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+ConVarRef mat_dxlevel( "mat_dxlevel" );
+bool CNPC_Strider::BecomeRagdoll( const CTakeDamageInfo &info, const Vector &forceVector ) 
+{ 
+	// Combine balls make us explode
+	if ( m_bExploding )
+	{
+		Explode();
+	}
+	else
+	{
+		// Otherwise just keel over
+		CRagdollProp *pRagdoll = NULL;
+		CBasePlayer *pPlayer = AI_GetSinglePlayer();
+		if ( pPlayer && mat_dxlevel.GetInt() > 0 )
+		{
+			int dxlevel = mat_dxlevel.GetInt();
+			int maxRagdolls = ( dxlevel >= 90 ) ? 2 : ( dxlevel >= 80 ) ? 1 : 0;
+
+			if ( maxRagdolls > 0 )
+			{
+				CUtlVectorFixed<CRagdollProp *, 2> striderRagdolls;
+				while ( ( pRagdoll = gEntList.NextEntByClass( pRagdoll ) ) != NULL )
+				{
+					if ( pRagdoll->GetModelName() == GetModelName() && !pRagdoll->IsFading() )
+					{
+						Assert( striderRagdolls.Count() < striderRagdolls.NumAllocated() );
+						if ( striderRagdolls.Count() < striderRagdolls.NumAllocated() )
+							striderRagdolls.AddToTail( pRagdoll );
+					}
+				}
+
+				if ( striderRagdolls.Count() >= maxRagdolls )
+				{
+					float distSqrFurthest = FLT_MAX;
+					CRagdollProp *pFurthest = NULL;
+
+					for ( int i = 0; i < striderRagdolls.Count(); i++ )
+					{
+						float distSqrCur = CalcSqrDistanceToAABB( striderRagdolls[i]->WorldAlignMins(), striderRagdolls[i]->WorldAlignMaxs(), pPlayer->GetAbsOrigin() );
+						if ( distSqrCur < distSqrFurthest )
+						{
+							distSqrFurthest = distSqrCur;
+							pFurthest = striderRagdolls[i];
+						}
+					}
+
+					if ( pFurthest )
+						pFurthest->FadeOut( 0.75, 1.5 );
+				}
+			}
+
+			pRagdoll = assert_cast<CRagdollProp *>( CreateServerRagdoll( this, m_nForceBone, info, HL2COLLISION_GROUP_STRIDER ) );
+			pRagdoll->DisableAutoFade();
+
+			if ( maxRagdolls == 0 )
+			{
+				pRagdoll->FadeOut( 6.0, .75 );
+				RagdollDeathEffect( pRagdoll, 6.0f );
+			}
+			else
+			{
+				RagdollDeathEffect( pRagdoll, 600.0f );
+			}
+		}
+		else
+		{
+			// Otherwise just keel over
+			pRagdoll = assert_cast<CRagdollProp *>( CreateServerRagdoll( this, m_nForceBone, info, HL2COLLISION_GROUP_STRIDER ) );
+			pRagdoll->DisableAutoFade();
+		}
+	}
+	
+	UTIL_Remove(this);
+
+	return true; 
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::StartSmoking( void )
+{
+	if ( m_hSmoke != NULL )
+		return;
+
+	m_hSmoke = SmokeTrail::CreateSmokeTrail();
+	
+	if ( m_hSmoke )
+	{
+		m_hSmoke->m_SpawnRate			= 32;
+		m_hSmoke->m_ParticleLifetime	= 3.0;
+		m_hSmoke->m_StartSize			= 16;
+		m_hSmoke->m_EndSize				= 64;
+		m_hSmoke->m_SpawnRadius			= 20;
+		m_hSmoke->m_MinSpeed			= 8;
+		m_hSmoke->m_MaxSpeed			= 64;
+		m_hSmoke->m_Opacity 			= 0.3;
+		
+		m_hSmoke->m_StartColor.Init( 0.25f, 0.25f, 0.25f );
+		m_hSmoke->m_EndColor.Init( 0, 0, 0 );
+		m_hSmoke->SetLifetime( 500.0f );
+		m_hSmoke->FollowEntity( this, "MiniGunBase" );
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::StopSmoking( float flDelay )
+{
+	if ( m_hSmoke )
+	{
+		m_hSmoke->SetLifetime( flDelay );
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::SetHeight( float h )
+{
+	if ( h > GetMaxHeight() )
+		h = GetMaxHeight();
+	else if ( h < GetMinHeight() )
+		h = GetMinHeight();
+
+	SetPoseParameter( gm_BodyHeightPoseParam, h );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::SetIdealHeight( float h )
+{
+	if ( h > GetMaxHeight() )
+		h = GetMaxHeight();
+	else if ( h < GetMinHeight() )
+		h = GetMinHeight();
+
+	m_idealHeight = h;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::SetAbsIdealHeight( float z )
+{
+	float h = GetMaxHeight() - ( z - GetAbsOrigin().z );
+	
+	SetIdealHeight( h );
+}
+
+//---------------------------------------------------------
+// At this moment, am I in the PROCESS of crouching? 
+// as in, and I transitioning from standing to crouch?
+//---------------------------------------------------------
+bool CNPC_Strider::IsStriderCrouching()
+{
+	if( IsCurSchedule( SCHED_STRIDER_CROUCH, false ) )
+		return true;
+
+	return false;
+}
+
+//---------------------------------------------------------
+// As IsStriderCrouching(), but for obvious differences.
+//---------------------------------------------------------
+bool CNPC_Strider::IsStriderStanding()
+{
+	if( IsCurSchedule( SCHED_STRIDER_STAND, false ) )
+		return true;
+
+	return false;
+}
+
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+
+bool CNPC_Strider::OverrideMove( float flInterval )
+{
+	if ( GetCannonTarget() )
+	{
+		AddFacingTarget( GetCannonTarget(), GetCannonTarget()->GetAbsOrigin(), 1.0, 0.5 );
+	}
+	else if ( GetEnemy() )
+	{
+		bool bPlayer = GetEnemy()->IsPlayer();
+		float timeSinceSeenEnemy = gpGlobals->curtime - GetEnemyLastTimeSeen();
+		if ( ( !bPlayer && timeSinceSeenEnemy < STRIDER_TIME_STOP_FACING_ENEMY ) ||
+			 ( bPlayer && !m_PlayerFreePass.HasPass() ) )
+		{
+			AddFacingTarget( GetEnemy(), GetEnemies()->LastKnownPosition( GetEnemy() ), 1.0, 0.5 );
+		}
+
+		if ( !m_bCrouchLocked && !m_hCannonTarget && GetIdealHeight() < GetMaxHeight() && timeSinceSeenEnemy > TIME_CARE_ENEMY )
+			SetIdealHeight( GetMaxHeight() );
+	}
+	else if ( !m_bCrouchLocked && !m_hCannonTarget )
+		SetIdealHeight( GetMaxHeight() );
+
+	if ( strider_test_height.GetFloat() > .1 )
+		SetIdealHeight( strider_test_height.GetFloat() );
+
+	// If we're not supposed to crouch walk and we're under the threshold for what we consider crouch walking, stand back up!
+	if ( !m_bCrouchLocked && m_bNoCrouchWalk && IsMoving() && ( GetIdealHeight() < ( GetMinHeight() + GetHeightRange() * ( strider_pct_height_no_crouch_move.GetFloat() / 100.0 ) ) ) )
+	{
+		SetIdealHeight( GetMinHeight() + GetHeightRange() * ( strider_pct_height_no_crouch_move.GetFloat() / 100.0 ) );
+	}
+
+	float heightMove = GetIdealHeight() - GetHeight();
+	float heightMoveSign = ( heightMove < 0 ) ? -1 : 1;
+	heightMove = fabsf( heightMove );
+	if ( heightMove > 0.01 )
+	{
+		const float maxVelocity = 300;
+		const float minVelocity = 10;
+
+		#define HEIGHTINVDECAY	0.8	// maintain X percent of velocity when slowing down
+		#define HEIGHTDECAYTIME	0.4161	// Sum( 1..cycle, HEIGHTINVDECAY^cycle ) 
+		#define HEIGHTACCEL		0.5		// accel toward maxVelocity by X percent each cycle
+
+		if (fabsf( m_HeightVelocity ) < minVelocity)
+			m_HeightVelocity = minVelocity * heightMoveSign;
+
+		if (heightMove < m_HeightVelocity * heightMoveSign * HEIGHTDECAYTIME )
+		{
+			m_HeightVelocity = m_HeightVelocity * HEIGHTINVDECAY;
+
+			if (heightMove < m_HeightVelocity * heightMoveSign * flInterval)
+			{
+				m_HeightVelocity = heightMove * heightMoveSign / flInterval;
+			}
+		}
+		else
+		{
+			m_HeightVelocity = m_HeightVelocity * (1.0f - HEIGHTACCEL) + maxVelocity * HEIGHTACCEL * heightMoveSign;
+			if (heightMove < m_HeightVelocity * heightMoveSign * HEIGHTDECAYTIME)
+			{
+				m_HeightVelocity = heightMove * heightMoveSign / HEIGHTDECAYTIME;
+			}
+		}
+
+		float newHeight = GetHeight() + m_HeightVelocity * flInterval;
+		SetHeight( newHeight );
+	}
+
+	// FIXME: where should this go?
+	MaintainTurnActivity( );
+
+	return false;
+}
+
+
+void CNPC_Strider::MaintainTurnActivity( void )
+{
+	// detect that the npc has turned
+	if (m_prevYaw != GetAbsAngles().y)
+	{
+		float diff = UTIL_AngleDiff( m_prevYaw, GetAbsAngles().y );
+		if (diff < 0.0)
+		{
+			m_doLeft += -diff;
+		}
+		else
+		{
+			m_doRight += diff;
+		}
+		m_prevYaw = GetAbsAngles().y;
+	}
+	// accumulate turn angle, delay response for short turns
+	m_doTurn += m_doRight + m_doLeft;
+	if (!IsMoving() && m_doTurn > 180.0f && m_flNextTurnAct < gpGlobals->curtime )
+	{
+		int iSeq = ACT_INVALID;
+		if (m_doLeft > m_doRight)
+		{
+			iSeq = SelectWeightedSequence( ACT_GESTURE_TURN_LEFT );
+		}
+		else
+		{
+			iSeq = SelectWeightedSequence( ACT_GESTURE_TURN_RIGHT );
+		}
+		if (iSeq != ACT_INVALID)
+		{
+			int iLayer = AddGestureSequence( iSeq );
+			if (iLayer != -1)
+			{
+				SetLayerPriority( iLayer, 100 );
+				// increase speed if we're getting behind or they're turning quickly
+				if (m_doTurn > 360.0)
+				{
+					SetLayerPlaybackRate( iLayer, 1.5 );
+				}
+				m_flNextTurnAct = gpGlobals->curtime + GetLayerDuration( iLayer );
+			}
+			else
+			{
+				// too busy, try again in half a second
+				m_flNextTurnAct = gpGlobals->curtime + 0.5;
+			}
+		}
+		m_doTurn = m_doLeft = m_doRight = 0.0;
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::IsUnusableNode(int iNodeID, CAI_Hint *pHint)
+{
+	if ( !BaseClass::IsUnusableNode(iNodeID, pHint) )
+	{
+		if ( pHint && pHint->HintType() == HINT_STRIDER_NODE )
+			return false;
+	}
+	return true;
+}
+
+//---------------------------------------------------------
+// Purpose: Compute the nav position for the strider's origin relative to this enemy.
+//---------------------------------------------------------
+void CNPC_Strider::TranslateNavGoal( CBaseEntity *pEnemy, Vector &chasePosition )
+{
+	if ( pEnemy )
+	{
+		if ( ! (pEnemy->GetFlags() & FL_ONGROUND) )
+		{
+			MoveToGround( &chasePosition, pEnemy, pEnemy->WorldAlignMins(), pEnemy->WorldAlignMaxs() );
+		}
+
+		// move down to enemy's feet for enemy origin at chasePosition
+		chasePosition.z += pEnemy->WorldAlignMins().z;
+
+	}
+	else
+	{
+		MoveToGround( &chasePosition, NULL, Vector( -16, -16, 0 ), Vector( 16, 16, 32 ) );
+	}
+
+	// move up to strider stand height
+	chasePosition.z += GetMaxHeight() + npc_strider_height_adj.GetFloat();
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::HasPendingTargetPath()
+{
+	bool bReturn = ( !FStrEq( STRING(m_strTrackName), STRIDER_NO_TRACK_NAME ) && !GetGoalEnt() );
+
+	return bReturn;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::SetTargetPath()
+{
+	SetGoalEnt( NULL );
+	CBaseEntity *pGoalEnt = gEntList.FindEntityByName( NULL, m_strTrackName );
+	if ( pGoalEnt == NULL )
+	{
+		DevWarning( "%s: Could not find target path '%s'!\n", GetClassname(), STRING( m_strTrackName ) );
+
+		// Don't try anymore. It just hurts the AI.
+		m_strTrackName = MAKE_STRING( STRIDER_NO_TRACK_NAME );
+
+		UTIL_Remove( this );
+		return;
+	}
+
+	const Vector &absOrigin = GetAbsOrigin();
+	CBaseEntity *pClosestEnt = NULL;
+	CBaseEntity *pCurEnt = pGoalEnt;
+	float distClosestSq = FLT_MAX;
+
+	CUtlRBTree<CBaseEntity *> visits;
+	SetDefLessFunc(visits);
+
+	while ( pCurEnt && visits.Find( pCurEnt ) == visits.InvalidIndex() )
+	{
+		float distCurSq = ( pCurEnt->GetAbsOrigin() - absOrigin ).LengthSqr();
+		if ( distCurSq < distClosestSq )
+		{
+			distClosestSq = distCurSq;
+			pClosestEnt = pCurEnt;
+		}
+		visits.Insert( pCurEnt );
+		pCurEnt = GetNavigator()->GetNextPathcorner( pCurEnt );
+	}
+
+	ScheduledFollowPath( SCHED_IDLE_WALK, pClosestEnt, ACT_WALK );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+
+float CNPC_Strider::GetDefaultNavGoalTolerance()
+{
+	return 64;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::OnMovementComplete()
+{
+	if ( GetGoalEnt() && 
+		 ( IsCurSchedule( SCHED_IDLE_WALK ) ||
+		   IsCurSchedule( SCHED_ALERT_WALK ) ||
+		   IsCurSchedule( SCHED_COMBAT_WALK ) ||
+		   IsCurSchedule( SCHED_STRIDER_HUNT ) ) )
+	{
+		m_strTrackName = MAKE_STRING( STRIDER_NO_TRACK_NAME );
+		SetGoalEnt( NULL );
+	}
+	BaseClass::OnMovementComplete();
+}
+
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+float CNPC_Strider::GetSequenceGroundSpeed( CStudioHdr *pStudioHdr, int iSequence )
+{
+	return ( BaseClass::GetSequenceGroundSpeed( pStudioHdr, iSequence ) * m_flSpeedScale );
+}
+
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+float CNPC_Strider::MaxYawSpeed()
+{
+	switch( GetActivity() )
+	{
+	case ACT_90_LEFT:
+	case ACT_90_RIGHT:
+		return 10;
+
+	case ACT_TURN_LEFT:
+	case ACT_TURN_RIGHT:
+		return 10;
+
+	case ACT_WALK:
+		return 10;
+
+	default:
+		return 10;		// should be zero, but this makes it easy to see when he's turning with default AI code
+		break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CNPC_Strider::DoMuzzleFlash( void )
+{
+	BaseClass::DoMuzzleFlash();
+	
+	CEffectData data;
+
+	data.m_nAttachmentIndex = LookupAttachment( "MiniGun" );
+	data.m_nEntIndex = entindex();
+	DispatchEffect( "StriderMuzzleFlash", data );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::ShootMinigun( const Vector *pTarget, float aimError, const Vector &vecSpread )
+{
+	if ( pTarget )
+	{
+		Vector muzzlePos;
+		QAngle muzzleAng;
+
+		GetAttachment( "minigun", muzzlePos, muzzleAng );
+		
+		Vector vecShootDir = *pTarget - muzzlePos;
+		VectorNormalize( vecShootDir );
+
+		if( m_bMinigunUseDirectFire )
+		{
+			// exactly on target w/tracer
+			FireBullets( 1, muzzlePos, vecShootDir, vecSpread, 8192, m_miniGunDirectAmmo, 1 );
+		}
+		else
+		{
+			// exactly on target w/tracer
+			FireBullets( 1, muzzlePos, vecShootDir, vecSpread, 8192, m_miniGunAmmo, 1 );
+		}
+
+		//g_pEffects->MuzzleFlash( muzzlePos, muzzleAng, random->RandomFloat( 2.0f, 4.0f ) , MUZZLEFLASH_TYPE_STRIDER );
+		DoMuzzleFlash();
+
+		EmitSound( "NPC_Strider.FireMinigun" );
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::UpdateMinigunControls( float &yaw, float &pitch ) 
+{
+	SetPoseParameter( m_poseMiniGunYaw, yaw );
+	SetPoseParameter( m_poseMiniGunPitch, pitch );
+
+	yaw = GetPoseParameter( m_poseMiniGunYaw );
+	pitch = GetPoseParameter( m_poseMiniGunPitch );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::GetViewCone( StriderMinigunViewcone_t &cone )
+{
+	cone.origin = EyePosition();
+	GetVectors( &cone.axis, NULL, NULL );
+	cone.cosAngle = 0.5; // 60 degree cone
+	cone.length = 2048;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::OnMinigunStopShooting( CBaseEntity *pTarget )
+{
+	// Stop hating the focus.
+	if( GetFocus() && pTarget == GetFocus() )
+	{
+		AddEntityRelationship( GetFocus(), D_NU, 0 );
+	}
+
+	if( IsUsingAggressiveBehavior() )
+	{
+		// From now on, direct fire. 
+		m_bMinigunUseDirectFire = true;
+	}
+}
+
+//---------------------------------------------------------
+// How fast the minigun fires (rounds per second)
+//---------------------------------------------------------
+float CNPC_Strider::GetMinigunRateOfFire()
+{
+	if( IsUsingAggressiveBehavior() && m_bMinigunUseDirectFire )
+		return STRIDER_EP1_RATE_OF_FIRE;
+
+	return STRIDER_DEFAULT_RATE_OF_FIRE;
+}
+
+//---------------------------------------------------------
+// How much of shoot duration is spent firing directly at
+// the target (the balance of time is spent stitching towards)
+//---------------------------------------------------------
+float CNPC_Strider::GetMinigunOnTargetTime()
+{
+	if( IsUsingAggressiveBehavior() )
+	{
+		if( m_bMinigunUseDirectFire )
+		{
+			// On target the whole time. Just send a large number that
+			// will be clipped, since shooting duration is random and
+			// we don't know how long the burst will actually be.
+			return 100.0f;
+		}
+
+		return STRIDER_EP1_SHOOT_ON_TARGET_TIME;
+	}
+
+	return STRIDER_SHOOT_ON_TARGET_TIME;
+}
+
+//---------------------------------------------------------
+// How long (seconds) a burst of minigun fire lasts.
+//---------------------------------------------------------
+float CNPC_Strider::GetMinigunShootDuration()
+{
+	if( IsUsingAggressiveBehavior() )
+		return STRIDER_EP1_SHOOT_DURATION;
+
+	return STRIDER_DEFAULT_SHOOT_DURATION; 
+}
+
+//---------------------------------------------------------
+// How long (seconds) a strider must wait between bursts
+//---------------------------------------------------------
+float CNPC_Strider::GetMinigunShootDowntime()
+{
+	if( IsUsingAggressiveBehavior() )
+		return STRIDER_EP1_SHOOT_DOWNTIME;
+
+	return STRIDER_SHOOT_DOWNTIME;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+float CNPC_Strider::GetMinigunShootVariation()
+{
+	if( IsUsingAggressiveBehavior() )
+	{
+		if( m_bMinigunUseDirectFire )
+			return 0.0f;
+
+		return STRIDER_EP1_SHOOT_VARIATION;
+	}
+
+	return STRIDER_SHOOT_VARIATION;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+Vector CNPC_Strider::CannonPosition()
+{
+	Vector position;
+
+	// Currently just using the gun for the vertical component!
+	GetAttachment( "biggun", position );
+	position.x = GetAbsOrigin().x;
+	position.y = GetAbsOrigin().y;
+
+	return position;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+CBaseEntity *CNPC_Strider::GetCannonTarget()
+{
+	CBaseEntity *pTarget = m_hCannonTarget;
+	return pTarget;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::HasCannonTarget() const
+{
+	return ( m_hCannonTarget.Get() != NULL );
+}
+
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::IsCannonTarget( CBaseEntity *pTarget ) const
+{
+	CBaseEntity *pCannonTarget = m_hCannonTarget;
+	if ( pCannonTarget && pCannonTarget == pTarget )
+	{
+		return true;
+	}
+
+	return false;
+}
+
+//---------------------------------------------------------
+// Purpose: Aim Gun at a target
+// Output : Returns true if you hit the target, false if not there yet
+//---------------------------------------------------------
+bool CNPC_Strider::AimCannonAt( CBaseEntity *pEntity, float flInterval )
+{
+	if ( !pEntity )
+		return true;
+
+	matrix3x4_t gunMatrix;
+	GetAttachment( gm_CannonAttachment, gunMatrix );
+
+	// transform the enemy into gun space
+	m_vecHitPos = pEntity->GetAbsOrigin();
+	Vector localEnemyPosition;
+	VectorITransform( pEntity->GetAbsOrigin(), gunMatrix, localEnemyPosition );
+	
+	// do a look at in gun space (essentially a delta-lookat)
+	QAngle localEnemyAngles;
+	VectorAngles( localEnemyPosition, localEnemyAngles );
+	
+	// convert to +/- 180 degrees
+	localEnemyAngles.x = UTIL_AngleDiff( localEnemyAngles.x, 0 );	
+	localEnemyAngles.y = UTIL_AngleDiff( localEnemyAngles.y, 0 );
+
+	float targetYaw = m_aimYaw + localEnemyAngles.y;
+	float targetPitch = m_aimPitch + localEnemyAngles.x;
+	
+	Vector unitAngles = Vector( localEnemyAngles.x, localEnemyAngles.y, localEnemyAngles.z ); 
+	float angleDiff = VectorNormalize(unitAngles);
+	const float aimSpeed = 16;
+
+	// Exponentially approach the target
+	float yawSpeed = fabsf(aimSpeed*flInterval*localEnemyAngles.y);
+	float pitchSpeed = fabsf(aimSpeed*flInterval*localEnemyAngles.x);
+
+	yawSpeed = MAX(yawSpeed,5);
+	pitchSpeed = MAX(pitchSpeed,5);
+
+	m_aimYaw = UTIL_Approach( targetYaw, m_aimYaw, yawSpeed );
+	m_aimPitch = UTIL_Approach( targetPitch, m_aimPitch, pitchSpeed );
+
+	SetPoseParameter( gm_YawControl, m_aimYaw );
+	SetPoseParameter( gm_PitchControl, m_aimPitch );
+
+	// read back to avoid drift when hitting limits
+	// as long as the velocity is less than the delta between the limit and 180, this is fine.
+	m_aimPitch = GetPoseParameter( gm_PitchControl );
+	m_aimYaw = GetPoseParameter( gm_YawControl );
+
+	// UNDONE: Zero out any movement past the limit and go ahead and fire if the strider hit its 
+	// target except for clamping.  Need to clamp targets to limits and compare?
+	if ( angleDiff < 1 )
+		return true;
+
+	return false;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::FireCannon() 
+{
+	ASSERT( m_hCannonTarget != NULL );
+	if ( !m_hCannonTarget )
+	{
+		DevMsg( "Strider firing cannon at NULL target\n" );
+		
+		// Turn the cannon off
+		EntityMessageBegin( this, true );
+			WRITE_BYTE( STRIDER_MSG_DEAD );
+		MessageEnd();
+
+		return;
+	}
+
+	if ( GetNextThink( "CANNON_HIT" ) > gpGlobals->curtime )
+	{
+		DevMsg( "Strider refiring cannon?\n" );
+		return;
+	}
+
+	m_nextShootTime = gpGlobals->curtime + 5;
+	trace_t tr;
+	Vector vecShootPos;
+	GetAttachment( gm_CannonAttachment, vecShootPos );
+
+	Vector vecShootDir;
+	vecShootDir = m_hCannonTarget->WorldSpaceCenter() - vecShootPos;
+	float flDist = VectorNormalize( vecShootDir );
+
+	AI_TraceLine( vecShootPos, vecShootPos + vecShootDir * flDist, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
+	m_blastHit = tr.endpos;
+	m_blastHit += tr.plane.normal * 16;
+	m_blastNormal = tr.plane.normal;
+
+	// tell the client side effect to complete
+	EntityMessageBegin( this, true );
+		WRITE_BYTE( STRIDER_MSG_BIG_SHOT );
+		WRITE_VEC3COORD( tr.endpos );
+	MessageEnd();
+
+	CPASAttenuationFilter filter2( this, "NPC_Strider.Shoot" );
+	EmitSound( filter2, entindex(), "NPC_Strider.Shoot");
+	SetContextThink( &CNPC_Strider::CannonHitThink, gpGlobals->curtime + 0.2f, "CANNON_HIT" );
+}
+
+void CNPC_Strider::CannonHitThink()
+{
+	CBaseEntity *pCannonTarget = m_hCannonTarget;
+	if ( pCannonTarget )
+	{
+		bool fAlive = pCannonTarget->IsAlive();
+
+		CreateConcussiveBlast( m_blastHit, m_blastNormal, this, 2.5 );
+
+		// If the target was alive, check to make sure it is now dead. If not,
+		// Kill it and warn the designer.
+		if( fAlive && pCannonTarget->IsAlive() )
+		{
+			DevWarning("* * * * * * * * * * * * * * *\n");
+			DevWarning("NASTYGRAM: STRIDER failed to kill its cannon target. Killing directly...\n");
+			DevWarning("* * * * * * * * * * * * * * *\n");
+
+			CTakeDamageInfo info;
+
+			info.SetDamage( pCannonTarget->GetHealth() );
+			info.SetDamageType( DMG_GENERIC );
+			info.SetAttacker( this );
+			info.SetInflictor( this );
+
+			pCannonTarget->TakeDamage( info );
+		}
+		
+		// Clear this guy now that we've shot him
+		m_hCannonTarget = NULL;
+	}
+
+	// Allow the cannon back on.
+	m_pMinigun->StopShootingForSeconds( this, m_pMinigun->GetTarget(), 1 );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::VPhysicsShadowCollision( int index, gamevcollisionevent_t *pEvent )
+{
+	if ( !HasMemory( bits_MEMORY_PROVOKED ) )
+	{
+		// if the player threw this in the last 1 seconds
+		CBasePlayer *pPlayer = pEvent->pEntities[!index]->HasPhysicsAttacker( 1 );
+		if ( pPlayer )
+		{
+			GetEnemies()->ClearMemory( pPlayer );
+			Remember( bits_MEMORY_PROVOKED );
+			SetCondition( COND_LIGHT_DAMAGE );
+		}
+	}
+
+	int otherIndex = !index;
+	CBaseEntity *pOther = pEvent->pEntities[otherIndex];
+	if ( pOther && UTIL_IsCombineBall( pOther ) )
+	{
+		Vector damagePos;
+		pEvent->pInternalData->GetContactPoint( damagePos );
+		CTakeDamageInfo dmgInfo( pOther, pOther, vec3_origin, damagePos, (m_iMaxHealth / 3) + 1, DMG_BLAST | DMG_PREVENT_PHYSICS_FORCE );
+
+		// FIXME: is there a better way for physics objects to keep track of what root entity responsible for them moving?
+		CBasePlayer *pPlayer = pOther->HasPhysicsAttacker( 1.0 );
+		if (pPlayer)
+		{
+			dmgInfo.SetAttacker( pPlayer );
+		}
+
+		// UNDONE: Find one near damagePos?
+		m_nForceBone = 0;
+		PhysCallbackDamage( this, dmgInfo, *pEvent, index );
+		return;
+	}
+
+	BaseClass::VPhysicsShadowCollision( index, pEvent );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::TestCollision( const Ray_t &ray, unsigned int mask, trace_t& trace )
+{
+	// Let normal hitbox code handle rays
+	if ( mask & CONTENTS_HITBOX )
+	{
+		return BaseClass::TestCollision( ray, mask, trace );
+	}
+
+	if ( IntersectRayWithBox( ray, WorldAlignMins() + GetAbsOrigin(), WorldAlignMaxs() + GetAbsOrigin(), DIST_EPSILON, &trace ) )
+	{
+		trace.hitbox = 0;
+		trace.hitgroup = HITGROUP_HEAD;
+		return true;
+	}
+	return false;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::CarriedByDropship()
+{
+	if( GetOwnerEntity() && FClassnameIs( GetOwnerEntity(), "npc_combinedropship" ) )
+		return true;
+
+	return false;
+}
+
+//---------------------------------------------------------
+// Carried by a dropship
+//---------------------------------------------------------
+void CNPC_Strider::CarriedThink()
+{
+	SetNextThink( gpGlobals->curtime + 0.05 );
+	StudioFrameAdvance();
+
+	Vector vecGround = GetAbsOrigin();
+	TranslateNavGoal( NULL, vecGround );
+
+	if( !CarriedByDropship() )
+	{
+		SetSolid( SOLID_BBOX );
+		SetThink ( &CAI_BaseNPC::CallNPCThink );
+	}
+}
+
+
+
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+Vector CNPC_Strider::LeftFootHit( float eventtime )
+{
+	Vector footPosition;
+	QAngle angles;
+
+	GetAttachment( "left foot", footPosition, angles );
+
+	if ( hl2_episodic.GetBool() )
+	{
+		CPASAttenuationFilter filter( this, "NPC_Strider.FootstepEverywhere" );
+		EmitSound( filter, 0, "NPC_Strider.FootstepEverywhere", &footPosition, eventtime );
+	}
+	else
+	{
+		CPASAttenuationFilter filter( this, "NPC_Strider.Footstep" );
+		EmitSound( filter, 0, "NPC_Strider.Footstep", &footPosition, eventtime );
+	}
+
+	FootFX( footPosition );
+
+	return footPosition;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+Vector CNPC_Strider::RightFootHit( float eventtime )
+{
+	Vector footPosition;
+
+	GetAttachment( "right foot", footPosition );
+	
+	if ( hl2_episodic.GetBool() )
+	{
+		CPASAttenuationFilter filter( this, "NPC_Strider.FootstepEverywhere" );
+		EmitSound( filter, 0, "NPC_Strider.FootstepEverywhere", &footPosition, eventtime );
+	}
+	else
+	{
+		CPASAttenuationFilter filter( this, "NPC_Strider.Footstep" );
+		EmitSound( filter, 0, "NPC_Strider.Footstep", &footPosition, eventtime );
+	}
+
+	FootFX( footPosition );
+
+	return footPosition;
+}
+
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+Vector CNPC_Strider::BackFootHit( float eventtime )
+{
+	Vector footPosition;
+
+	GetAttachment( "back foot", footPosition );
+
+	if ( hl2_episodic.GetBool() )
+	{
+		CPASAttenuationFilter filter( this, "NPC_Strider.FootstepEverywhere" );
+		EmitSound( filter, 0, "NPC_Strider.FootstepEverywhere", &footPosition, eventtime );
+	}
+	else
+	{
+		CPASAttenuationFilter filter( this, "NPC_Strider.Footstep" );
+		EmitSound( filter, 0, "NPC_Strider.Footstep", &footPosition, eventtime );
+	}
+
+	FootFX( footPosition );
+
+	return footPosition;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+static Vector GetAttachmentPositionInSpaceOfBone( CStudioHdr *pStudioHdr, const char *pAttachmentName, int outputBoneIndex )
+{
+	int attachment = Studio_FindAttachment( pStudioHdr, pAttachmentName );
+
+	Vector localAttach;
+	const mstudioattachment_t &pAttachment = pStudioHdr->pAttachment(attachment);
+	int iBone = pStudioHdr->GetAttachmentBone( attachment );
+	MatrixGetColumn( pAttachment.local, 3, localAttach );
+
+	matrix3x4_t inputToOutputBone;
+	Studio_CalcBoneToBoneTransform( pStudioHdr, iBone, outputBoneIndex, inputToOutputBone );
+	
+	Vector out;
+	VectorTransform( localAttach, inputToOutputBone, out );
+
+	return out;
+}
+
+//-------------------------------------
+
+void CNPC_Strider::StompHit( int followerBoneIndex )
+{
+	CStudioHdr *pStudioHdr = GetModelPtr();
+	physfollower_t *bone = m_BoneFollowerManager.GetBoneFollower( followerBoneIndex );
+	if ( !bone )
+		return;
+
+	const char *pBoneNames[] = {"left skewer", "right skewer" };
+	int nameIndex = followerBoneIndex == STRIDER_LEFT_LEG_FOLLOWER_INDEX ? 0 : 1;
+	Vector localHit = GetAttachmentPositionInSpaceOfBone( pStudioHdr, pBoneNames[nameIndex], bone->boneIndex );
+	IPhysicsObject *pLegPhys = bone->hFollower->VPhysicsGetObject();
+
+	// now transform into the worldspace of the current position of the leg's physics
+	matrix3x4_t legToWorld;
+	pLegPhys->GetPositionMatrix( &legToWorld );
+	Vector hitPosition;
+	VectorTransform( localHit, legToWorld, hitPosition );
+
+	//NDebugOverlay::Box( hitPosition, Vector(-16,-16,-16), Vector(16,16,16), 0, 255, 0, 255, 1.0 );
+	CBaseEntity *pEnemy = GetEnemy();
+	CAI_BaseNPC *pNPC = pEnemy ? pEnemy->MyNPCPointer() : NULL;
+	bool bIsValidTarget = pNPC && pNPC->GetModelPtr();
+	if ( HasSpawnFlags( SF_CAN_STOMP_PLAYER ) )
+	{
+		bIsValidTarget = bIsValidTarget || ( pEnemy && pEnemy->IsPlayer() );
+	}
+
+	if ( !bIsValidTarget )
+		return;
+
+	Vector delta;
+	VectorSubtract( pEnemy->GetAbsOrigin(), hitPosition, delta );
+	if ( delta.LengthSqr() > (STRIDER_STOMP_RANGE * STRIDER_STOMP_RANGE) )
+		return;
+
+	// DVS E3 HACK: Assume we stab our victim midway between their eyes and their center.
+	Vector vecStabPos = ( pEnemy->WorldSpaceCenter() + pEnemy->EyePosition() ) * 0.5f;
+	hitPosition = pEnemy->GetAbsOrigin();
+
+	Vector footPosition;
+	GetAttachment( "left foot", footPosition );
+
+	CPASAttenuationFilter filter( this, "NPC_Strider.Skewer" );
+	EmitSound( filter, 0, "NPC_Strider.Skewer", &hitPosition );
+
+	CTakeDamageInfo damageInfo( this, this, 500, DMG_CRUSH );
+	Vector forward;
+	pEnemy->GetVectors( &forward, NULL, NULL );
+	damageInfo.SetDamagePosition( hitPosition );
+	damageInfo.SetDamageForce( -50 * 300 * forward );
+	pEnemy->TakeDamage( damageInfo );
+
+	if ( !pNPC || pNPC->IsAlive() )
+		return;
+
+	Vector vecBloodDelta = footPosition - vecStabPos;
+	vecBloodDelta.z = 0; // effect looks better 
+	VectorNormalize( vecBloodDelta );
+	UTIL_BloodSpray( vecStabPos + vecBloodDelta * 4, vecBloodDelta, BLOOD_COLOR_RED, 8, FX_BLOODSPRAY_ALL );
+	UTIL_BloodSpray( vecStabPos + vecBloodDelta * 4, vecBloodDelta, BLOOD_COLOR_RED, 11, FX_BLOODSPRAY_DROPS );
+	CBaseEntity *pRagdoll = CreateServerRagdollAttached( pNPC, vec3_origin, -1, COLLISION_GROUP_DEBRIS, pLegPhys, this, bone->boneIndex, vecStabPos, -1, localHit );
+	if ( pRagdoll )
+	{
+		// the strider might drag this through the world
+		pRagdoll->AddSolidFlags( FSOLID_NOT_SOLID );
+
+		m_hRagdoll = pRagdoll;
+		m_ragdollTime = gpGlobals->curtime + 10;
+		UTIL_Remove( pNPC );
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CNPC_Strider::FootFX( const Vector &origin )
+{
+	trace_t tr;
+	AI_TraceLine( origin + Vector(0, 0, 48), origin - Vector(0,0,100), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
+	float yaw = random->RandomInt(0,120);
+	
+	if ( UTIL_PointContents( tr.endpos + Vector( 0, 0, 1 ) ) & MASK_WATER )
+	{
+		float flWaterZ = UTIL_FindWaterSurface( tr.endpos, tr.endpos.z, tr.endpos.z + 100.0f );
+
+		CEffectData	data;
+		data.m_fFlags = 0;
+		data.m_vOrigin = tr.endpos;
+		data.m_vOrigin.z = flWaterZ;
+		data.m_vNormal = Vector( 0, 0, 1 );
+		data.m_flScale = random->RandomFloat( 10.0, 14.0 );
+
+		DispatchEffect( "watersplash", data );
+	}
+	else
+	{
+		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 );
+		}
+	}
+	UTIL_ScreenShake( tr.endpos, 4.0, 1.0, 0.5, 1000, SHAKE_START, false );
+	
+	if ( npc_strider_shake_ropes_radius.GetInt() )
+	{
+		CRopeKeyframe::ShakeRopes( tr.endpos, npc_strider_shake_ropes_radius.GetFloat(), npc_strider_shake_ropes_magnitude.GetFloat() );
+	}
+
+	//
+	// My feet are scary things! NOTE: We might want to make danger sounds as the feet move
+	// through the air. Then soldiers could run from the feet, which would look cool.
+	//
+	CSoundEnt::InsertSound( SOUND_DANGER|SOUND_CONTEXT_EXCLUDE_COMBINE, tr.endpos, 512, 1.0f, this );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+Vector CNPC_Strider::CalculateStompHitPosition( CBaseEntity *pEnemy )
+{
+	Vector skewerPosition, footPosition;
+	GetAttachment( "left skewer", skewerPosition );
+	GetAttachment( "left foot", footPosition );
+	Vector vecStabPos = ( pEnemy->WorldSpaceCenter() + pEnemy->EyePosition() ) * 0.5f;
+
+	return vecStabPos - skewerPosition + footPosition;
+}
+
+//-----------------------------------------------------------------------------
+// Strider Navigation
+//-----------------------------------------------------------------------------
+
+static void MoveToGround( Vector *position, CBaseEntity *ignore, const Vector &mins, const Vector &maxs )
+{
+	trace_t tr;
+	// Find point on floor where enemy would stand at chasePosition
+	Vector floor = *position;
+	floor.z -= 1024;
+	AI_TraceHull( *position, floor, mins, maxs, MASK_NPCSOLID_BRUSHONLY, ignore, COLLISION_GROUP_NONE, &tr );
+	if ( tr.fraction < 1 )
+	{
+		position->z = tr.endpos.z;
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void AdjustStriderNodePosition( CAI_Network *pNetwork, CAI_Node *pNode )
+{
+	if ( pNode->GetHint() && pNode->GetHint()->HintType() == HINT_STRIDER_NODE )
+	{
+		CNPC_Strider *pStrider = (CNPC_Strider *)gEntList.FindEntityByClassname( NULL, "npc_strider" );
+		bool bCreated = false;
+		if ( !pStrider )
+		{
+			bool allowPrecache = CBaseEntity::IsPrecacheAllowed();
+			CBaseEntity::SetAllowPrecache( true );
+			pStrider = (CNPC_Strider *)CreateEntityByName( "npc_strider" );
+			pStrider->m_bDisableBoneFollowers = true; // don't create these since we're just going to destroy him
+			DispatchSpawn( pStrider );
+			CBaseEntity::SetAllowPrecache( allowPrecache );
+			bCreated = true;
+		}
+
+		if ( pStrider )
+		{
+			pStrider->TranslateNavGoal( NULL, pNode->AccessOrigin() );
+			if ( bCreated )
+				UTIL_Remove( pStrider );
+		}
+	}
+}
+
+
+//---------------------------------------------------------
+// Implement a navigator so that the strider can get closer to the ground when he's walking on a slope
+// This gives him enough reach for his legs to IK to lower ground points
+//---------------------------------------------------------
+void LookaheadPath( const Vector &current, AI_Waypoint_t *pWaypoint, float dist, Vector &nextPos )
+{
+	if ( !pWaypoint )
+		return;
+
+	Vector dir = pWaypoint->GetPos() - current;
+	float dist2D = dir.Length2D();
+	if ( dist2D > 0.1 )
+	{
+		if ( dist <= dist2D )
+		{
+			nextPos = ((dist / dist2D) * dir) + current;
+			return;
+		}
+	}
+	nextPos = pWaypoint->GetPos();
+	dist -= dist2D;
+	dir = nextPos;
+	
+	LookaheadPath( dir, pWaypoint->GetNext(), dist, nextPos );
+}
+
+//---------------------------------------------------------
+// Find the forward slope and lower the strider height when moving downward
+//---------------------------------------------------------
+void CNPC_Strider::CNavigator::MoveCalcBaseGoal( AILocalMoveGoal_t *pMoveGoal )
+{
+	BaseClass::MoveCalcBaseGoal( pMoveGoal );
+	Vector dest = pMoveGoal->target;
+	LookaheadPath( GetAbsOrigin(), pMoveGoal->pPath->GetCurWaypoint(), CNPC_Strider::gm_strideLength, dest );
+
+	//NDebugOverlay::Box( dest, Vector(-16,-16,-16), Vector(16,16,16), 0, 255, 0, 255, 0.1 );
+	Vector unitDir = pMoveGoal->dir * CNPC_Strider::gm_strideLength;
+	unitDir.z = dest.z - GetAbsOrigin().z;
+	VectorNormalize( unitDir );
+	float heightAdj = unitDir.z * CNPC_Strider::gm_strideLength;
+	pMoveGoal->flags |= ( AILMG_NO_STEER | AILMG_NO_AVOIDANCE_PATHS );
+	if ( heightAdj < -1 )
+	{
+		heightAdj = clamp( heightAdj, -192, 0 );
+		pMoveGoal->target.z += heightAdj;
+		pMoveGoal->dir = unitDir * CNPC_Strider::gm_strideLength * 0.1;
+		pMoveGoal->dir.z += heightAdj;
+		VectorNormalize( pMoveGoal->dir );
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::CNavigator::MoveUpdateWaypoint( AIMoveResult_t *pResult )
+{
+	// Note that goal & waypoint tolerances are handled in progress blockage cases (e.g., OnObstructionPreSteer)
+
+	AI_Waypoint_t *pCurWaypoint = GetPath()->GetCurWaypoint();
+	float 		   waypointDist = (pCurWaypoint->GetPos() - GetAbsOrigin()).Length2D();
+	bool		   bIsGoal		= CurWaypointIsGoal();
+	// HACKHACK: adjust this tolerance
+	// The strider is following paths most of the time, but he needs a bunch of freedom
+	// to adjust himself to make his feet look good.
+	float		   tolerance	= 10.0;
+
+	if ( waypointDist <= tolerance )
+	{
+		if ( bIsGoal )
+		{
+			OnNavComplete();
+			*pResult = AIMR_OK;
+			
+		}
+		else
+		{
+			AdvancePath();
+			*pResult = AIMR_CHANGE_TYPE;
+		}
+		return true;
+	}
+	
+	return false;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::CNavigator::DoFindPathToPos()
+{
+	DbgNavMsg(  GetOuter(), "Strider overriding DoFindPathToPos\n");
+	if ( BaseClass::DoFindPathToPos() )
+	{
+		// Do special optimization on our first path segment
+		DbgNavMsg(  GetOuter(), "Strider base pathfind worked\n");
+		CAI_WaypointList waypoints( GetPath()->GetCurWaypoint() );
+		AI_Waypoint_t *pFirstWaypoint = waypoints.GetFirst();
+		AI_Waypoint_t *pLast = waypoints.GetLast();
+
+		if ( pFirstWaypoint->IsReducible() && 
+			 pFirstWaypoint->GetNext() && 
+			 pFirstWaypoint->GetNext()->iNodeID != NO_NODE && 
+			 pFirstWaypoint->GetNext()->NavType() == GetNavType() )
+		{
+			// Find nearest point on the line segment of our path
+			Vector vOrigin = GetOuter()->GetAbsOrigin();
+			Vector vClosest;
+			CalcClosestPointOnLineSegment( vOrigin,
+				pFirstWaypoint->GetPos(), 
+				pFirstWaypoint->GetNext()->GetPos(), 
+				vClosest );
+
+			// Find both these positions as offset from the ground
+			TranslateNavGoal( GetPath()->GetTarget(), vClosest );
+			TranslateNavGoal( GetPath()->GetTarget(), vOrigin );
+
+			// If we're seemingly beyond the waypoint and our hull is near enough to the path segment, advance to the next node
+			const float EPS = 0.1f;
+			bool bPastStartNode = ( ( pFirstWaypoint->GetPos() - vClosest ).Length() > EPS );
+			bool bNearPathSegment = ( ( vOrigin - vClosest ).Length() < GetHullWidth() * 0.5f );
+			if ( bPastStartNode && bNearPathSegment )
+			{
+				GetPath()->Advance();
+			}
+		}
+
+		if ( pLast->iNodeID == NO_NODE )
+		{
+			AI_Waypoint_t *pLastNodeWaypoint = pLast->GetPrev();
+
+			if ( pLastNodeWaypoint && pLastNodeWaypoint->iNodeID == NO_NODE )
+			{
+				// Pathfinder triangulated to goal
+				Assert( pLastNodeWaypoint->GetPrev() );
+				if ( pLastNodeWaypoint->GetPrev() )
+				{
+					pLastNodeWaypoint->GetPrev()->SetNext( pLast );
+					delete pLastNodeWaypoint;
+					pLastNodeWaypoint = pLast->GetPrev();
+				}
+			}
+
+			Assert( pLastNodeWaypoint );
+			if ( pLastNodeWaypoint )
+			{
+				Assert( pLastNodeWaypoint->iNodeID != NO_NODE );
+				if ( pLastNodeWaypoint->iNodeID != NO_NODE )
+				{
+					CAI_Node *pLastNode = GetNetwork()->GetNode( pLastNodeWaypoint->iNodeID );
+					float bestDistSq = ( pLast->vecLocation - pLastNodeWaypoint->vecLocation ).LengthSqr();
+					Vector vNewEnd = vec3_invalid;
+					int segmentDestClosest = NO_NODE;
+
+					for (int link=0; link < pLastNode->NumLinks();link++) 
+					{
+						CAI_Link *pLink = pLastNode->GetLinkByIndex(link);
+						if ( !( pLink->m_LinkInfo & bits_LINK_OFF ) && (pLink->m_iAcceptedMoveTypes[GetHullType()] & bits_CAP_MOVE_FLY) )
+						{
+							CAI_Node *pTestNode = GetNetwork()->GetNode( pLink->DestNodeID( pLastNodeWaypoint->iNodeID ) );
+							if ( pTestNode->GetHint() && pTestNode->GetHint()->HintType() == HINT_STRIDER_NODE )
+							{
+								Vector vClosest;
+								CalcClosestPointOnLineSegment( pLast->vecLocation, 
+															   pLastNodeWaypoint->vecLocation, pTestNode->GetPosition(GetHullType()), 
+															   vClosest );
+								float distTestSq = ( pLast->vecLocation - vClosest ).LengthSqr();
+								if ( distTestSq < bestDistSq )
+								{
+									bestDistSq = distTestSq;
+									vNewEnd = vClosest;
+									segmentDestClosest = pTestNode->GetId();
+								}
+							}
+						}
+					}
+					
+					if ( vNewEnd == vec3_invalid )
+					{
+						DbgNavMsg(  GetOuter(), "Strider resetting goal to last node waypoint\n");
+						pLastNodeWaypoint->SetNext( NULL );
+						pLastNodeWaypoint->ModifyFlags( bits_WP_TO_GOAL, true );
+						delete pLast;
+					}
+					else if ( !pLastNodeWaypoint->GetPrev() || pLastNodeWaypoint->GetPrev()->iNodeID != segmentDestClosest )
+					{
+						DbgNavMsg(  GetOuter(), "Strider resetting goal to nearest point on graph\n");
+						pLast->vecLocation = vNewEnd;
+					}
+					else
+					{
+						DbgNavMsg(  GetOuter(), "Strider resetting goal to nearest point on graph, on node\n");
+						pLastNodeWaypoint->vecLocation = vNewEnd;
+						pLastNodeWaypoint->SetNext( NULL );
+						pLastNodeWaypoint->ModifyFlags( bits_WP_TO_GOAL, true );
+						delete pLast;
+					}
+					GetPath()->ResetGoalPosition( GetPath()->GetGoalWaypoint()->vecLocation );
+				}
+			}
+		}
+		else
+			DbgNavMsg(  GetOuter(), "Goal ended on node\n");
+		return true;
+	}
+	else
+		DbgNavMsg(  GetOuter(), "Strider base pathfind failed\n");
+
+	return false;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::CNavigator::ShouldOptimizeInitialPathSegment( AI_Waypoint_t *pFirstWaypoint )
+{
+	// We do our own special initial path optimization DoFindPathToPos()
+	return false;
+}
+
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CNPC_Strider::CNavigator::GetStoppingPath( CAI_WaypointList *pClippedWaypoints )
+{
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns if a bone follower is a leg piece or not
+// Input  : *pFollower - Bone follower we're testing
+// Output : Returns true if the bone follower is a part of the strider's legs
+//-----------------------------------------------------------------------------
+bool CNPC_Strider::IsLegBoneFollower( CBoneFollower *pFollower )
+{
+	// Find the index of this bone follower, if we have it
+	int nFollowerIndex = GetBoneFollowerIndex( pFollower );
+	if ( nFollowerIndex	== -1 )
+		return false;
+
+	// See if we're a leg
+	if ( nFollowerIndex >= STRIDER_LEFT_LEG_FOLLOWER_INDEX &&
+		 nFollowerIndex <= STRIDER_BACK_UPPERLEG_FOLLOWER_INDEX )
+		 return true;
+
+	// We're something else
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Finds a bone follower via a supplied index
+// Input  : nIndex - index our bone follower manager will use to retrieve the follower
+// Output : NULL if not found, otherwise the bone follower we were seeking
+//-----------------------------------------------------------------------------
+CBoneFollower *CNPC_Strider::GetBoneFollowerByIndex( int nIndex )
+{
+	physfollower_t *pFollower = m_BoneFollowerManager.GetBoneFollower( nIndex );
+	if ( pFollower != NULL )
+		return pFollower->hFollower;
+	
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the index of a bone follower in our system
+// Input  : *pFollower - Follower we're looking for
+// Output : -1 if not found, otherwise the index of the follower
+//-----------------------------------------------------------------------------
+int CNPC_Strider::GetBoneFollowerIndex( CBoneFollower *pFollower )
+{
+	return m_BoneFollowerManager.GetBoneFollowerIndex( pFollower );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: The strider ignores certain entities this way
+// Input  : *pEntity - Entity in question
+// Output : Returns true if we should collide with the entity
+//-----------------------------------------------------------------------------
+bool CNPC_Strider::ShouldProbeCollideAgainstEntity( CBaseEntity *pEntity )
+{
+	if ( pEntity->m_iClassname == m_iszStriderBusterName )
+		return false;
+
+	return BaseClass::ShouldProbeCollideAgainstEntity( pEntity );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Lets us keep track of attached Strider busters
+// Input  : *pAttached - strider buster that is attached
+//-----------------------------------------------------------------------------
+#ifdef HL2_EPISODIC
+void CNPC_Strider::StriderBusterAttached( CBaseEntity *pAttached )
+{
+	// Add another to the list
+	m_hAttachedBusters.AddToTail( pAttached );
+	m_PlayerFreePass.Revoke();
+
+	variant_t target;
+	target.SetString( AllocPooledString( "!player" ) );
+	g_EventQueue.AddEvent( this, "UpdateEnemyMemory", target, 1.0, this, this );
+}
+
+
+void CNPC_Strider::StriderBusterDetached( CBaseEntity *pAttached )
+{
+	int elem = m_hAttachedBusters.Find(pAttached);
+	if (elem >= 0)
+	{
+		m_hAttachedBusters.FastRemove(elem);
+	}
+}
+
+#endif // HL2_EPISODIC
+
+//-----------------------------------------------------------------------------
+//
+// Strider Minigun
+//
+//-----------------------------------------------------------------------------
+
+BEGIN_DATADESC_NO_BASE( CStriderMinigun )
+
+	DEFINE_FIELD( m_enable,				FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_minigunState,		FIELD_INTEGER ),
+	DEFINE_FIELD( m_nextBulletTime,		FIELD_TIME ),
+	DEFINE_FIELD( m_burstTime,			FIELD_TIME ),
+	DEFINE_FIELD( m_nextTwitchTime,		FIELD_TIME ),
+	DEFINE_FIELD( m_randomState,		FIELD_INTEGER ),
+	DEFINE_FIELD( m_hTarget,			FIELD_EHANDLE ),
+	DEFINE_FIELD( m_bWarnedAI,			FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_shootDuration,		FIELD_TIME ),
+	DEFINE_FIELD( m_vecAnchor,			FIELD_VECTOR ),
+	DEFINE_FIELD( m_bOverrideEnemy,		FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_vecLastTargetPos,	FIELD_VECTOR ),
+	DEFINE_FIELD( m_iOnTargetShots,		FIELD_INTEGER ),
+
+	// Silence, Classcheck!
+	// DEFINE_FIELD( m_yaw, StriderMinigunAnimController_t ),
+	// DEFINE_FIELD( m_pitch, StriderMinigunAnimController_t ),
+	
+	DEFINE_FIELD( m_yaw.current,		FIELD_FLOAT ),
+	DEFINE_FIELD( m_yaw.target,			FIELD_FLOAT ),
+	DEFINE_FIELD( m_yaw.rate,			FIELD_FLOAT ),
+	DEFINE_FIELD( m_pitch.current,		FIELD_FLOAT ),
+	DEFINE_FIELD( m_pitch.target,		FIELD_FLOAT ),
+	DEFINE_FIELD( m_pitch.rate,			FIELD_FLOAT ),
+
+
+END_DATADESC()
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CStriderMinigun::Init()
+{
+	m_enable = true;
+	m_nextTwitchTime = gpGlobals->curtime;
+	m_randomState = 0;
+	m_yaw.current = m_yaw.target = 0;
+	m_pitch.current = m_pitch.target = 0;
+	m_yaw.rate = 360;
+	m_pitch.rate = 180;
+
+	SetState( MINIGUN_OFF );
+	m_burstTime = gpGlobals->curtime;
+	m_nextBulletTime = FLT_MAX;
+	m_vecAnchor = vec3_invalid;
+	m_shootDuration = STRIDER_DEFAULT_SHOOT_DURATION;
+	m_bOverrideEnemy = false;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+bool CStriderMinigun::ShouldFindTarget( IMinigunHost *pHost )
+{
+	ASSERT( pHost != NULL );
+
+	if( !GetTarget() )
+	{
+		// No target. Find one.
+		return true;
+	}
+
+	if( m_bOverrideEnemy )
+	{
+		return false;
+	}
+
+	if( pHost->GetEntity()->GetEnemy() )
+	{
+		return GetTarget() != pHost->GetEntity()->GetEnemy();
+	}
+
+	return true;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+float CStriderMinigun::GetAimError()
+{
+	return fabs(m_yaw.target-m_yaw.current) + fabs(m_pitch.target-m_pitch.current);
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CStriderMinigun::AimAtPoint( IStriderMinigunHost *pHost, const Vector &vecPoint, bool bSnap )
+{
+	matrix3x4_t gunMatrix;
+	CAI_BaseNPC *pOwner = pHost->GetEntity();
+
+	int mingunAttachment = pOwner->LookupAttachment( "minigunbase" );
+	pOwner->GetAttachment( mingunAttachment, gunMatrix );
+
+	Vector forward, pos;
+	MatrixGetColumn( gunMatrix, 0, forward );
+	MatrixGetColumn( gunMatrix, 3, pos );
+
+	// transform the point into gun space
+	Vector localPointPosition;
+	VectorITransform( vecPoint, gunMatrix, localPointPosition );
+	
+	// do a look at in gun space (essentially a delta-lookat)
+	QAngle localPointAngles;
+	VectorAngles( localPointPosition, localPointAngles );
+
+	// convert to +/- 180 degrees
+	float pdiff, ydiff;
+	pdiff = UTIL_AngleDiff( localPointAngles.x, 0 );
+	ydiff = UTIL_AngleDiff( localPointAngles.y, 0 );
+
+	m_pitch.target += 0.5 * pdiff;
+	m_yaw.target -= 0.5 * ydiff;
+
+	m_pitch.target = MAX( MINIGUN_MIN_PITCH, m_pitch.target );
+	m_pitch.target = MIN( MINIGUN_MAX_PITCH, m_pitch.target );
+	m_yaw.target = MAX( MINIGUN_MIN_YAW, m_yaw.target );
+	m_yaw.target = MIN( MINIGUN_MAX_YAW, m_yaw.target );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CStriderMinigun::AimAtTarget( IStriderMinigunHost *pHost, CBaseEntity *pTarget, bool bSnap )
+{
+	if ( pTarget && !(CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI) )
+	{
+		Vector vecTargetPos = pTarget->BodyTarget( pHost->GetEntity()->EyePosition() );
+		AimAtPoint( pHost, vecTargetPos, bSnap );
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CStriderMinigun::ShootAtTarget( IStriderMinigunHost *pHost, CBaseEntity *pTarget, float shootTime )
+{
+	if ( !pTarget && !(CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI) )
+		return;
+
+	variant_t emptyVariant;
+	pTarget->AcceptInput( "InputTargeted", pHost->GetEntity(), pHost->GetEntity(), emptyVariant, 0 );
+	Enable( NULL, true );
+	if ( shootTime <= 0 )
+	{
+		shootTime = random->RandomFloat( 4, 8 );
+	}
+	SetTarget( pHost, pTarget, true );
+
+	StartShooting( pHost, pTarget, shootTime );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CStriderMinigun::StartShooting( IStriderMinigunHost *pHost, CBaseEntity *pTarget, float duration )
+{
+	bool bHasSetAnchor = false;
+
+	SetState( MINIGUN_SHOOTING );
+	
+	m_nextBulletTime = gpGlobals->curtime;
+	m_burstTime = gpGlobals->curtime + duration;
+
+	m_shootDuration = duration;
+
+	// don't twitch while shooting
+	m_nextTwitchTime = FLT_MAX;
+
+	if( pTarget->IsPlayer() )
+	{
+		// Don't shoot a player in the back if they aren't looking. 
+		// Give them a chance to see they're being fired at.
+		CBasePlayer *pPlayer = dynamic_cast<CBasePlayer*>(pTarget);
+
+		if( !pPlayer->FInViewCone( pHost->GetEntity() ) )
+		{
+			// Player doesn't see me. Try to start shooting so that they can see
+			// the bullet impacts.
+			m_vecAnchor = pPlayer->EyePosition();
+
+			Vector vecPlayerLook;
+			Vector vecToPlayer;
+
+			// Check in 2D.
+			vecPlayerLook = pPlayer->EyeDirection3D();
+			vecPlayerLook.z = 0.0;
+			VectorNormalize( vecPlayerLook );
+
+			vecToPlayer = pPlayer->EyePosition() - pHost->GetEntity()->EyePosition();
+			vecToPlayer.z = 0.0;
+			VectorNormalize( vecToPlayer );
+
+			float flDot = DotProduct( vecToPlayer, vecPlayerLook );
+
+			if( flDot < 0.95 )
+			{
+				// If the player is looking sufficiently to a side, start 30 feet out in that direction.
+				m_vecAnchor += pPlayer->EyeDirection3D() * 320;
+				bHasSetAnchor = true;
+			}
+			else
+			{
+				// Start over their head, cause firing the direction they are looking will drill them.
+				// in the back!
+				m_vecAnchor += Vector( 0, 0, random->RandomFloat( 160, 240 ) );
+
+				// Move it to one side of the other randomly, just to get it off center.
+				Vector right;
+				pPlayer->GetVectors( NULL, &right, NULL );
+				m_vecAnchor += right * random->RandomFloat( -100, 100 );
+				bHasSetAnchor = true;
+			}
+		}
+	}
+
+	if( !bHasSetAnchor )
+	{
+		m_vecAnchor = pTarget->WorldSpaceCenter();
+
+		Vector right;
+		pTarget->GetVectors( NULL, &right, NULL );
+
+		// Start 5 or 10 feet off target.
+		Vector offset = right * random->RandomFloat( 60, 120 );
+		
+		// Flip a coin to decide left or right.
+		if( random->RandomInt( 0, 1 ) == 0 )
+		{
+			offset *= -1;
+		}
+
+		m_vecAnchor += offset;
+
+		// Start below them, too.
+		m_vecAnchor.z -= random->RandomFloat( 80, 200 );
+	}
+
+	pHost->OnMinigunStartShooting( pTarget );
+}
+
+//---------------------------------------------------------
+// Fixes up the math for stitching.
+//---------------------------------------------------------
+void CStriderMinigun::ExtendShooting( float timeExtend )
+{
+	m_burstTime = gpGlobals->curtime + timeExtend;
+	m_shootDuration = timeExtend;
+	m_bWarnedAI = false;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CStriderMinigun::SetShootDuration( float duration )
+{
+}
+
+//---------------------------------------------------------
+// Is the gun turned as far as it can go?
+//---------------------------------------------------------
+bool CStriderMinigun::IsPegged( int dir )
+{
+	bool up, down, left, right, any;
+
+	up = down = left = right = any = false;
+
+	if( m_yaw.current >= 89.0 )
+		any = right = true;
+
+	if( m_yaw.current <= -89.0 )
+		any = left = true;
+
+	if( m_pitch.current >= 44.0 )
+		any = down = true;
+
+	if( m_pitch.current <= -44.0 )
+		any = up = true;
+
+	switch( dir )
+	{
+	case MINIGUN_PEGGED_UP:
+		return up;
+
+	case MINIGUN_PEGGED_DOWN:
+		return down;
+
+	case MINIGUN_PEGGED_LEFT:
+		return left;
+
+	case MINIGUN_PEGGED_RIGHT:
+		return right;
+
+	default:
+		return (any && !up);
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CStriderMinigun::StopShootingForSeconds( IStriderMinigunHost *pHost, CBaseEntity *pTarget, float duration )
+{
+	if ( IsShooting() )
+	{
+		SetState( MINIGUN_OFF );
+	}
+
+	m_burstTime = gpGlobals->curtime + duration;
+	m_nextBulletTime = FLT_MAX;
+
+	ClearOnTarget();
+	m_nextTwitchTime = gpGlobals->curtime + random->RandomFloat( 2.0, 4.0 );
+	pHost->OnMinigunStopShooting( pTarget );
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CStriderMinigun::SetState( int newState )
+{
+	m_minigunState = newState;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CStriderMinigun::SetTarget( IStriderMinigunHost *pHost, CBaseEntity *pTarget, bool bOverrideEnemy )
+{
+	m_hTarget = pTarget;
+
+	if( pTarget )
+	{
+		// New target, we haven't scared this guy yet!
+		m_bWarnedAI = false;
+
+		if( m_vecAnchor == vec3_invalid )
+		{
+			Vector right;
+			pHost->GetEntity()->GetVectors( NULL, &right, NULL );
+
+			m_vecAnchor = pTarget->GetAbsOrigin() - Vector( 0, 0, 256 );
+			m_vecAnchor += right * random->RandomFloat( -60.0f, 60.0f );
+		}
+	}
+
+	ClearOnTarget();
+
+	m_bOverrideEnemy = bOverrideEnemy;
+}
+
+//---------------------------------------------------------
+// The strider minigun can track and fire at targets in a fairly
+// large arc. It looks unnatural for a Strider to acquire a target
+// off to one side and begin firing at it, so we don't let the
+// minigun BEGIN shooting at a target unless the target is fairly
+// well in front of the Strider. Once firing, the gun is allowed
+// to track the target anywhere for the duration of that burst of
+// minigun fire. This is tuned by eye. (sjb)
+//---------------------------------------------------------
+bool CStriderMinigun::CanStartShooting( IStriderMinigunHost *pHost, CBaseEntity *pTargetEnt )
+{
+	if ( CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI )
+		return false;
+
+	if( !pTargetEnt )
+		return false;
+	
+	if( gpGlobals->curtime < m_burstTime )
+		return false;
+
+	CNPC_Strider *pStrider = dynamic_cast<CNPC_Strider *>(pHost->GetEntity() );
+	if ( pTargetEnt->IsPlayer() && pStrider->HasPass() )
+		return false;
+
+	if( !m_bOverrideEnemy )
+	{
+		if( pTargetEnt != pHost->GetEntity()->GetEnemy() )
+		{
+			return false;
+		}
+
+		// If the strider can't see the enemy, this may be because the enemy is
+		// hiding behind something breakable. If the weapon has LOS, fire away.
+		if( !pHost->GetEntity()->HasCondition( COND_SEE_ENEMY )  )
+		{
+			Assert( pStrider != NULL );
+
+			if( !pStrider->WeaponLOSCondition( pStrider->GetAdjustedOrigin(), pTargetEnt->WorldSpaceCenter(), false ) )
+			{
+				if( pStrider->IsUsingAggressiveBehavior() && pTargetEnt->IsPlayer() && !pStrider->HasPass() )
+				{
+					// I can shoot the player's cover until he hides long enough to earn a free pass.
+					float flTimeSinceLastSeen = gpGlobals->curtime - pStrider->GetEnemies()->LastTimeSeen(pTargetEnt);
+
+					if( flTimeSinceLastSeen <= 2.0f )
+						return true;
+				}
+
+				return false;
+			}
+		}
+	}
+	
+	Vector los = ( pTargetEnt->WorldSpaceCenter() - pHost->GetEntity()->EyePosition() );
+
+	// Following code stolen from FVisible. This check done in 2d intentionally.
+	los.z = 0;
+	VectorNormalize( los );
+
+	Vector facingDir = pHost->GetEntity()->EyeDirection2D( );
+	float flDot = DotProduct( los, facingDir );
+
+	// Too far to a side.
+	if ( flDot <= .707 )
+		return false;
+
+	return true;
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CStriderMinigun::Enable( IMinigunHost *pHost, bool enable )
+{
+	m_enable = enable;
+	if ( !m_enable )
+	{
+		m_yaw.current = m_yaw.target = 0;
+		m_pitch.current = m_pitch.target = 0;
+		if ( pHost )
+		{
+			// KENB pHost->UpdateMinigunControls( m_yaw.current, m_pitch.current );
+		}
+	}
+}
+
+//---------------------------------------------------------
+//---------------------------------------------------------
+void CStriderMinigun::Think( IStriderMinigunHost *pHost, float dt )
+{
+	if ( !m_enable )
+		return;
+
+	if ( CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI )
+		return;
+
+	if( ShouldFindTarget( pHost ) )
+	{
+		CBaseEntity *pOldTarget = GetTarget();
+
+		// Take my host's enemy.
+		SetTarget( pHost, pHost->GetEntity()->GetEnemy() );
+		
+		if( IsShooting() )
+		{
+			// Changing targets hot! 
+			if( pOldTarget )
+			{
+				m_vecAnchor = pOldTarget->WorldSpaceCenter();
+			}
+
+			ExtendShooting( STRIDER_SUBSEQUENT_TARGET_DURATION + random->RandomFloat( 0, 0.5 ) );
+		}
+		
+		pHost->NewTarget();
+	}
+
+	if ( !GetTarget() && m_nextTwitchTime <= gpGlobals->curtime )
+	{
+		// invert one and randomize the other.
+		// This has the effect of making the gun cross the field of
+		// view more often - like he's looking around
+		m_randomState = !m_randomState;
+		if ( m_randomState )
+		{
+			m_yaw.Random( MINIGUN_MIN_YAW, MINIGUN_MAX_YAW, 360, 720 );
+			m_pitch.target = -m_pitch.target;
+		}
+		else
+		{
+			m_pitch.Random( MINIGUN_MIN_PITCH, MINIGUN_MAX_PITCH, 270, 360 );
+			m_yaw.target = -m_yaw.target;
+		}
+		m_nextTwitchTime = gpGlobals->curtime + random->RandomFloat( 0.3, 2 );
+	}
+
+	CBaseEntity *pTargetEnt = m_hTarget.Get();
+
+	if ( pTargetEnt )
+	{
+		pHost->GetEntity()->InvalidateBoneCache();
+		AimAtTarget( pHost, pTargetEnt );
+	}
+
+	// Update the minigun's pose parameters using approaching. 
+	m_yaw.Update( dt );
+	m_pitch.Update( dt );
+
+	pHost->UpdateMinigunControls( m_yaw.current, m_pitch.current );
+
+	// Start or stop shooting.
+	if( IsShooting() )
+	{
+		if( gpGlobals->curtime > m_burstTime || !pTargetEnt )
+		{
+			// Time to stop firing.
+			if( m_bOverrideEnemy )
+			{
+				// Get rid of this target.
+				SetTarget( pHost, NULL );
+			}
+
+			StopShootingForSeconds( pHost, pTargetEnt, pHost->GetMinigunShootDowntime() );
+		}
+	}
+	else
+	{
+		if( CanStartShooting( pHost, pTargetEnt ) )
+		{
+			StartShooting( pHost, pTargetEnt, pHost->GetMinigunShootDuration() + random->RandomFloat( 0, pHost->GetMinigunShootVariation() ) );
+		}
+	}
+
+	// Fire the next bullet!
+	if ( m_nextBulletTime <= gpGlobals->curtime && !IsPegged() )
+	{
+		if( pTargetEnt && pTargetEnt == pHost->GetEntity()->GetEnemy() )
+		{
+			// Shooting at the Strider's enemy. Strafe to target!
+			float flRemainingShootTime = m_burstTime - gpGlobals->curtime;
+
+			// Skim a little time off of the factor, leave a moment of on-target
+			// time. This guarantees that the minigun will strike the target a few times.
+			float flFactor = (flRemainingShootTime - pHost->GetMinigunOnTargetTime() ) / m_shootDuration;
+
+			flFactor = MAX( 0.0f, flFactor );
+
+			Vector vecTarget = pTargetEnt->BodyTarget( assert_cast<CNPC_Strider *>(pHost->GetEntity())->GetAdjustedOrigin());
+
+			Vector vecLine = m_vecAnchor - vecTarget;
+			
+			float flDist = VectorNormalize( vecLine );
+
+			vecTarget += vecLine * flDist * flFactor;
+
+			if( flFactor == 0.0 )
+			{
+				m_vecAnchor = vecTarget;
+				RecordShotOnTarget();
+			}
+
+			if ( GetTarget() )
+			{
+				pHost->ShootMinigun( &vecTarget, GetAimError(), vec3_origin );
+
+				if( flFactor <= 0.5 && !m_bWarnedAI )
+				{
+					m_bWarnedAI = true;
+
+					CSoundEnt::InsertSound( SOUND_DANGER | SOUND_CONTEXT_REACT_TO_SOURCE, pTargetEnt->EarPosition() + Vector( 0, 0, 1 ), 120, MAX( 1.0, flRemainingShootTime ), pHost->GetEntity() );
+				}
+			}
+		}
+		else
+		{
+			const Vector *pTargetPoint = pTargetEnt ? &pTargetEnt->GetAbsOrigin() : NULL;
+			pHost->ShootMinigun( pTargetPoint, GetAimError() );
+		}
+
+		m_nextBulletTime = gpGlobals->curtime + (1.0f / pHost->GetMinigunRateOfFire() );
+	}
+}
+
+LINK_ENTITY_TO_CLASS( sparktrail, CSparkTrail );
+
+void CSparkTrail::Precache()
+{
+	BaseClass::Precache();
+
+	PrecacheScriptSound( "DoSpark" );
+}
+
+void CSparkTrail::Spawn()
+{
+	Precache();
+
+	EmitSound( "DoSpark" );
+
+	m_iHealth = 20 + random->RandomInt( 0, 5 );
+	UTIL_SetOrigin( this, GetOwnerEntity()->EyePosition() );
+
+	Vector vecVelocity;
+
+	vecVelocity.x = random->RandomFloat( 100, 400 );
+	vecVelocity.y = random->RandomFloat( 100, 400 );
+	vecVelocity.z = random->RandomFloat( 0, 100 );
+	
+	if( random->RandomInt( 0, 1 ) == 0 )
+		vecVelocity.x *= -1;
+
+	if( random->RandomInt( 0, 1 ) == 0 )
+		vecVelocity.y *= -1;
+
+	UTIL_SetSize( this, Vector( 0, 0, 0 ), Vector( 0, 0, 0 ) );
+	SetMoveType( MOVETYPE_FLYGRAVITY );
+	SetSolid( SOLID_NONE );
+
+	if( random->RandomInt( 0, 2 ) == 0 )
+	{
+		vecVelocity *= 2.0;
+		m_iHealth /= 2;
+		SetMoveType( MOVETYPE_FLY );
+	}
+
+	SetAbsVelocity( vecVelocity );
+
+	SetThink( &CSparkTrail::SparkThink );
+	SetNextThink( gpGlobals->curtime );
+}
+
+void CSparkTrail::SparkThink()
+{
+	SetNextThink( gpGlobals->curtime + 0.05 );
+
+	g_pEffects->Sparks( GetAbsOrigin() );
+
+	if( m_iHealth-- < 1 )
+	{
+		UTIL_Remove( this );
+	}
+}
+
+BEGIN_DATADESC( CSparkTrail )
+	DEFINE_THINKFUNC( SparkThink ),
+END_DATADESC()
+
+
+//-----------------------------------------------------------------------------
+//
+// Schedules
+//
+//-----------------------------------------------------------------------------
+AI_BEGIN_CUSTOM_NPC( npc_strider, CNPC_Strider )
+
+	DECLARE_TASK( TASK_STRIDER_AIM )
+	DECLARE_TASK( TASK_STRIDER_DODGE )
+	DECLARE_TASK( TASK_STRIDER_STOMP )
+	DECLARE_TASK( TASK_STRIDER_BREAKDOWN )
+	DECLARE_TASK( TASK_STRIDER_START_MOVING )
+	DECLARE_TASK( TASK_STRIDER_REFRESH_HUNT_PATH )
+	DECLARE_TASK( TASK_STRIDER_GET_PATH_TO_CANNON_TARGET )
+	DECLARE_TASK( TASK_STRIDER_FACE_CANNON_TARGET )
+	DECLARE_TASK( TASK_STRIDER_SET_HEIGHT )
+	DECLARE_TASK( TASK_STRIDER_GET_PATH_TO_CANNON_LOS )
+	DECLARE_TASK( TASK_STRIDER_FIRE_CANNON )
+	DECLARE_TASK( TASK_STRIDER_SET_CANNON_HEIGHT )
+	DECLARE_TASK( TASK_STRIDER_FALL_TO_GROUND )
+
+	DECLARE_ACTIVITY( ACT_STRIDER_LOOKL )
+	DECLARE_ACTIVITY( ACT_STRIDER_LOOKR )
+	DECLARE_ACTIVITY( ACT_STRIDER_DEPLOYRA1 )
+	DECLARE_ACTIVITY( ACT_STRIDER_AIMRA1 )
+	DECLARE_ACTIVITY( ACT_STRIDER_FINISHRA1 )
+	DECLARE_ACTIVITY( ACT_STRIDER_DODGER )
+	DECLARE_ACTIVITY( ACT_STRIDER_DODGEL )
+	DECLARE_ACTIVITY( ACT_STRIDER_STOMPL )
+	DECLARE_ACTIVITY( ACT_STRIDER_STOMPR )
+	DECLARE_ACTIVITY( ACT_STRIDER_FLICKL )
+	DECLARE_ACTIVITY( ACT_STRIDER_FLICKR )
+	DECLARE_ACTIVITY( ACT_STRIDER_SLEEP )
+	DECLARE_ACTIVITY( ACT_STRIDER_CARRIED )
+	DECLARE_ACTIVITY( ACT_STRIDER_DEPLOY )
+	DECLARE_ACTIVITY( ACT_STRIDER_GESTURE_DEATH )
+
+	DECLARE_CONDITION( COND_STRIDER_DO_FLICK )
+	DECLARE_CONDITION( COND_TRACK_PATH_GO )
+	DECLARE_CONDITION( COND_STRIDER_SHOULD_CROUCH )
+	DECLARE_CONDITION( COND_STRIDER_SHOULD_STAND )
+	DECLARE_CONDITION( COND_STRIDER_MINIGUN_SHOOTING )
+	DECLARE_CONDITION( COND_STRIDER_MINIGUN_NOT_SHOOTING )
+	DECLARE_CONDITION( COND_STRIDER_HAS_CANNON_TARGET )
+	DECLARE_CONDITION( COND_STRIDER_ENEMY_UPDATED )
+	DECLARE_CONDITION( COND_STRIDER_HAS_LOS_Z )
+
+	DECLARE_INTERACTION( g_interactionPlayerLaunchedRPG )
+	
+	//=========================================================
+	// Hunt (Basic logic for strider thinking)
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_STRIDER_HUNT,
+
+		"	Tasks"
+		"		TASK_STRIDER_REFRESH_HUNT_PATH 0"
+		"		TASK_STRIDER_START_MOVING	0"
+		"		TASK_WAIT					4"
+		"	"
+		"	Interrupts"
+		"		COND_NEW_ENEMY"
+		"		COND_CAN_MELEE_ATTACK1"
+		"		COND_CAN_RANGE_ATTACK1"
+		"		COND_CAN_RANGE_ATTACK2"
+		"		COND_STRIDER_SHOULD_CROUCH"
+		"		COND_STRIDER_HAS_CANNON_TARGET"
+		"		COND_STRIDER_ENEMY_UPDATED"
+	)
+
+	//=========================================================
+	// Attack (Deploy/shoot/finish)
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_STRIDER_RANGE_ATTACK1,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING		0"
+		"		TASK_SET_ACTIVITY		ACTIVITY:ACT_IDLE"
+		"		TASK_FACE_ENEMY			0"
+		"		TASK_RANGE_ATTACK1		0"
+		"		TASK_WAIT				5" // let the immolator work its magic
+		"	"
+		"	Interrupts"
+	)
+
+	//=========================================================
+	// Attack (Deploy/shoot/finish)
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_STRIDER_RANGE_ATTACK2,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING					0"
+		"		TASK_STRIDER_FACE_CANNON_TARGET		0"
+		"		TASK_SET_ACTIVITY					ACTIVITY:ACT_IDLE"
+		"		TASK_WAIT							1"
+		"		TASK_STRIDER_AIM					1.25"
+		"		TASK_STRIDER_FIRE_CANNON			0"
+		"		TASK_WAIT							1"
+		"	"
+		"	Interrupts"
+	)
+
+	//=========================================================
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_STRIDER_CROUCH,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING		0"
+		"		TASK_PLAY_SEQUENCE		ACTIVITY:ACT_CROUCH"
+		"	"
+		"	Interrupts"
+	)
+
+	//=========================================================
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_STRIDER_STAND,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING		0"
+		"		TASK_PLAY_SEQUENCE		ACTIVITY:ACT_STAND"
+		"		TASK_SET_ACTIVITY		ACTIVITY:ACT_IDLE"
+		"		TASK_STRIDER_SET_HEIGHT	500"
+		"	"
+		"	Interrupts"
+	)
+
+	//=========================================================
+	// Dodge Incoming missile
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_STRIDER_DODGE,
+
+		"	Tasks"
+		"		TASK_STRIDER_DODGE		0"
+		"	"
+		"	Interrupts"
+	)
+
+	//=========================================================
+	// Break down and die
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_STRIDER_DIE,
+
+		"	Tasks"
+		"		TASK_STRIDER_BREAKDOWN		0"
+		"	"
+		"	Interrupts"
+	)
+	
+	//=========================================================
+	// Stomp on an enemy
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_STRIDER_STOMPL,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING		0"
+		"		TASK_STRIDER_STOMP		0"
+		"	"
+		"	Interrupts"
+	);		
+
+	// Stomp on an enemy
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_STRIDER_STOMPR,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING		0"
+		"		TASK_STRIDER_STOMP		1"
+		"	"
+		"	Interrupts"
+	)
+
+	DEFINE_SCHEDULE
+	(
+		SCHED_STRIDER_FLICKL,
+
+		"	Tasks"
+		"		TASK_PLAY_SEQUENCE		ACTIVITY:ACT_STRIDER_FLICKL"
+		"	"
+		"	Interrupts"
+	)
+	DEFINE_SCHEDULE
+	(
+		SCHED_STRIDER_FLICKR,
+
+		"	Tasks"
+		"		TASK_PLAY_SEQUENCE		ACTIVITY:ACT_STRIDER_FLICKR"
+		"	"
+		"	Interrupts"
+	)
+	DEFINE_SCHEDULE
+	(
+		SCHED_STRIDER_ATTACK_CANNON_TARGET,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING							0"
+		"		TASK_STRIDER_GET_PATH_TO_CANNON_TARGET		0"
+		"		TASK_WALK_PATH								0"
+		"		TASK_WAIT_FOR_MOVEMENT						0"
+		"	"
+		"	Interrupts"
+		"		COND_CAN_RANGE_ATTACK2"
+		"		COND_STRIDER_SHOULD_CROUCH"
+	)
+
+	DEFINE_SCHEDULE
+	(
+		SCHED_STRIDER_CHASE_ENEMY,
+
+		"	Tasks"
+		"		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_MELEE_ATTACK1"
+		"		COND_CAN_RANGE_ATTACK2"
+		"		COND_CAN_MELEE_ATTACK2"
+		"		COND_TOO_CLOSE_TO_ATTACK"
+		"		COND_LOST_ENEMY"
+		"		COND_STRIDER_HAS_CANNON_TARGET"
+	)
+
+	DEFINE_SCHEDULE
+	(
+		SCHED_STRIDER_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"
+		"		COND_STRIDER_HAS_CANNON_TARGET"
+	)
+
+	DEFINE_SCHEDULE
+	(
+		SCHED_STRIDER_AGGRESSIVE_COMBAT_STAND,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING			0"
+		"		TASK_SET_ACTIVITY			ACTIVITY:ACT_IDLE"
+		"		TASK_WAIT					1"
+		""
+		"	Interrupts"
+		"		COND_NEW_ENEMY"
+		"		COND_ENEMY_DEAD"
+		"		COND_LIGHT_DAMAGE"
+		"		COND_HEAVY_DAMAGE"
+		"		COND_SEE_ENEMY"
+		"		COND_CAN_RANGE_ATTACK1"
+		"		COND_CAN_RANGE_ATTACK2"
+		"		COND_CAN_MELEE_ATTACK1"
+		"		COND_CAN_MELEE_ATTACK2"
+		"		COND_IDLE_INTERRUPT"
+	)
+
+	DEFINE_SCHEDULE
+	(
+		SCHED_STRIDER_ESTABLISH_LINE_OF_FIRE_CANNON,
+
+		"	Tasks "
+		"		TASK_STRIDER_GET_PATH_TO_CANNON_LOS		0"
+		"		TASK_RUN_PATH							0"
+		"		TASK_WAIT_FOR_MOVEMENT					0"
+		"		TASK_STRIDER_FACE_CANNON_TARGET			0"
+		""
+		"	Interrupts "
+		"		COND_CAN_RANGE_ATTACK2"
+		"		COND_STRIDER_SHOULD_CROUCH"
+		"		COND_STRIDER_SHOULD_STAND"
+	)
+
+	DEFINE_SCHEDULE
+	(
+		SCHED_STRIDER_FALL_TO_GROUND,
+
+		"	Tasks "
+		"		TASK_STRIDER_FALL_TO_GROUND		0"
+		""
+		"	Interrupts "
+	)
+
+
+AI_END_CUSTOM_NPC()
+
+//=============================================================================