d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
47 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: cbffd53f8b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'cbffd53f8b'
${ noResults }
source-engine/game/server/hl2/npc_strider.cpp

5745 lines
163 KiB
Raw Blame History

//========= 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 ) )
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 ) )
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()
//=============================================================================