646 lines
21 KiB
C++
646 lines
21 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================//
|
|
|
|
#ifndef NPC_STRIDER_H
|
|
#define NPC_STRIDER_H
|
|
|
|
#include "ai_blended_movement.h"
|
|
#include "ai_pathfinder.h"
|
|
#include "ai_navigator.h"
|
|
#include "ai_utils.h"
|
|
#include "smoke_trail.h"
|
|
#include "physics_bone_follower.h"
|
|
#include "physics_prop_ragdoll.h"
|
|
|
|
#if defined( _WIN32 )
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "tier0/memdbgon.h"
|
|
|
|
class CNPC_Strider;
|
|
class CNPC_Bullseye;
|
|
class CStriderMinigun;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Support for moving Strider air nodes to the correct Z for the Strider
|
|
// regardless of Hammer placement
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class CAI_Network;
|
|
class CAI_Node;
|
|
struct StriderMinigunViewcone_t;
|
|
struct AI_EnemyInfo_t;
|
|
|
|
void AdjustStriderNodePosition( CAI_Network *pNetwork, CAI_Node *pNode );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Strider Minigun
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
abstract_class IMinigunHost
|
|
{
|
|
public:
|
|
virtual void ShootMinigun( const Vector *pTarget, float aimError, const Vector &vecSpread = vec3_origin ) = 0;
|
|
virtual void UpdateMinigunControls( float &yaw, float &pitch ) = 0;
|
|
virtual void GetViewCone( StriderMinigunViewcone_t &cone ) = 0;
|
|
virtual void NewTarget() = 0;
|
|
virtual void OnMinigunStartShooting( CBaseEntity *pTarget ) = 0;
|
|
virtual void OnMinigunStopShooting( CBaseEntity *pTarget ) = 0;
|
|
virtual CAI_BaseNPC *GetEntity() = 0;
|
|
};
|
|
|
|
abstract_class IStriderMinigunHost : public IMinigunHost
|
|
{
|
|
public:
|
|
virtual float GetMinigunRateOfFire() = 0;
|
|
virtual float GetMinigunOnTargetTime() = 0;
|
|
virtual float GetMinigunShootDuration() = 0;
|
|
virtual float GetMinigunShootDowntime() = 0;
|
|
virtual float GetMinigunShootVariation() = 0;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// npc_strider
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
const int NUM_STRIDER_IK_TARGETS = 6;
|
|
|
|
//---------------------------------------------------------
|
|
|
|
class CNPC_Strider : public CAI_BlendingHost<CAI_BaseNPC>,
|
|
public IStriderMinigunHost
|
|
{
|
|
DECLARE_CLASS( CNPC_Strider, CAI_BaseNPC );
|
|
DECLARE_SERVERCLASS();
|
|
|
|
public:
|
|
CNPC_Strider();
|
|
~CNPC_Strider();
|
|
|
|
//---------------------------------
|
|
|
|
void Precache();
|
|
void Spawn();
|
|
bool CreateVPhysics();
|
|
void InitBoneFollowers( void );
|
|
void PostNPCInit();
|
|
void Activate();
|
|
void UpdateOnRemove();
|
|
void InitBoneControllers();
|
|
void OnRestore();
|
|
|
|
Class_T Classify();
|
|
bool ShouldAttractAutoAim( CBaseEntity *pAimingEnt );
|
|
|
|
virtual float GetAutoAimRadius() { return 80.0f; }
|
|
|
|
int DrawDebugTextOverlays();
|
|
|
|
void UpdateEfficiency( bool bInPVS ) { SetEfficiency( ( GetSleepState() != AISS_AWAKE ) ? AIE_DORMANT : AIE_NORMAL ); SetMoveEfficiency( AIME_NORMAL ); }
|
|
virtual bool ShouldProbeCollideAgainstEntity( CBaseEntity *pEntity );
|
|
|
|
//---------------------------------
|
|
|
|
virtual Vector GetNodeViewOffset() { return BaseClass::GetDefaultEyeOffset(); }
|
|
|
|
Vector EyePosition();
|
|
const Vector & GetViewOffset();
|
|
Vector EyePositionCrouched() { return GetAbsOrigin() - Vector( 0, 0, 330 ); }
|
|
|
|
//---------------------------------
|
|
// CBaseAnimating
|
|
void CalculateIKLocks( float currentTime );
|
|
float GetIdealAccel() const { return GetIdealSpeed(); }
|
|
|
|
//---------------------------------
|
|
// Behavior
|
|
//---------------------------------
|
|
void NPCThink();
|
|
void PrescheduleThink();
|
|
void GatherConditions();
|
|
void CheckFlinches() {} // Strider handles on own
|
|
void GatherHeightConditions( const Vector &vTestPos, CBaseEntity *pEntity );
|
|
void OnStateChange( NPC_STATE oldState, NPC_STATE newState );
|
|
void BuildScheduleTestBits();
|
|
int SelectSchedule();
|
|
int TranslateSchedule( int scheduleType );
|
|
void StartTask( const Task_t *pTask );
|
|
void RunTask( const Task_t *pTask );
|
|
bool HandleInteraction( int interactionType, void *data, CBaseCombatCharacter* sourceEnt );
|
|
void HandleAnimEvent( animevent_t *pEvent );
|
|
|
|
Disposition_t IRelationType( CBaseEntity *pTarget );
|
|
void AddEntityRelationship( CBaseEntity *pEntity, Disposition_t nDisposition, int nPriority );
|
|
|
|
bool ScheduledMoveToGoalEntity( int scheduleType, CBaseEntity *pGoalEntity, Activity movementActivity );
|
|
bool ScheduledFollowPath( int scheduleType, CBaseEntity *pPathStart, Activity movementActivity );
|
|
|
|
//---------------------------------
|
|
// Inputs
|
|
//---------------------------------
|
|
void InputSetMinigunTime( inputdata_t &inputdata );
|
|
void InputSetMinigunTarget( inputdata_t &inputdata );
|
|
void InputDisableMinigun( inputdata_t &inputdata );
|
|
void InputEnableMinigun( inputdata_t &inputdata );
|
|
void InputSetCannonTarget( inputdata_t &inputdata );
|
|
void InputFlickRagdoll( inputdata_t &inputdata );
|
|
void InputDisableCollisionWith( inputdata_t &inputdata );
|
|
void InputEnableCollisionWith( inputdata_t &inputdata );
|
|
void InputCrouch( inputdata_t &inputdata );
|
|
void InputCrouchInstantly( inputdata_t &inputdata );
|
|
void InputStand( inputdata_t &inputdata );
|
|
void InputSetHeight( inputdata_t &inputdata );
|
|
void InputSetTargetPath( inputdata_t &inputdata );
|
|
void InputClearTargetPath( inputdata_t &inputdata );
|
|
void InputDisableCrouchWalk( inputdata_t &inputdata );
|
|
void InputEnableCrouchWalk( inputdata_t &inputdata );
|
|
void InputEnableAggressiveBehavior( inputdata_t &inputdata );
|
|
void InputDisableAggressiveBehavior( inputdata_t &inputdata );
|
|
void InputStopShootingMinigunForSeconds( inputdata_t &inputdata );
|
|
void InputDisableCrouch( inputdata_t &inputdata );
|
|
void InputDisableMoveToLOS( inputdata_t &inputdata );
|
|
void InputExplode( inputdata_t &inputdata );
|
|
void InputScaleGroundSpeed( inputdata_t &inputdata );
|
|
|
|
//---------------------------------
|
|
// Combat
|
|
//---------------------------------
|
|
bool HasPass() { return m_PlayerFreePass.HasPass(); }
|
|
|
|
bool FVisible( CBaseEntity *pEntity, int traceMask = MASK_BLOCKLOS, CBaseEntity **ppBlocker = NULL );
|
|
Vector BodyTarget( const Vector &posSrc, bool bNoisy );
|
|
|
|
bool IsValidEnemy( CBaseEntity *pTarget );
|
|
bool UpdateEnemyMemory( CBaseEntity *pEnemy, const Vector &position, CBaseEntity *pInformer = NULL );
|
|
float StriderEnemyDistance( CBaseEntity *pEnemy );
|
|
|
|
bool FCanCheckAttacks();
|
|
int RangeAttack2Conditions( float flDot, float flDist );
|
|
int MeleeAttack1Conditions( float flDot, float flDist );
|
|
int MeleeAttack2Conditions( float flDot, float flDist );
|
|
bool WeaponLOSCondition(const Vector &ownerPos, const Vector &targetPos, bool bSetConditions);
|
|
bool CurrentWeaponLOSCondition(const Vector &targetPos, bool bSetConditions);
|
|
bool IsValidShootPosition ( const Vector &vecCoverLocation, CAI_Node *pNode, CAI_Hint const *pHint );
|
|
bool TestShootPosition(const Vector &vecShootPos, const Vector &targetPos );
|
|
|
|
Vector Weapon_ShootPosition();
|
|
|
|
void MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType );
|
|
void DoImpactEffect( trace_t &tr, int nDamageType );
|
|
void DoMuzzleFlash( void );
|
|
|
|
bool CanShootThrough( const trace_t &tr, const Vector &vecTarget );
|
|
|
|
void CreateFocus();
|
|
CNPC_Bullseye * GetFocus();
|
|
|
|
bool GetWeaponLosZ( const Vector &vOrigin, float minZ, float maxZ, float increment, CBaseEntity *pTarget, float *pResult );
|
|
|
|
//---------------------------------
|
|
// Sounds & speech
|
|
//---------------------------------
|
|
void AlertSound();
|
|
void PainSound( const CTakeDamageInfo &info );
|
|
void DeathSound( const CTakeDamageInfo &info );
|
|
void HuntSound();
|
|
|
|
//---------------------------------
|
|
// Damage handling
|
|
//---------------------------------
|
|
void TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator );
|
|
int OnTakeDamage_Alive( const CTakeDamageInfo &info );
|
|
int TakeDamageFromCombineBall( const CTakeDamageInfo &info );
|
|
void Event_Killed( const CTakeDamageInfo &info );
|
|
void RagdollDeathEffect( CRagdollProp *pRagdoll, float flDuration );
|
|
bool BecomeRagdoll( const CTakeDamageInfo &info, const Vector &forceVector );
|
|
void StartSmoking();
|
|
void StopSmoking( float flDelay = 0.1 );
|
|
bool IsSmoking() { return m_hSmoke != NULL; }
|
|
void Explode();
|
|
|
|
//---------------------------------
|
|
// Posture
|
|
//---------------------------------
|
|
float GetMaxHeightModel() const { return 500.0; }
|
|
float GetMaxHeight() const { return 490.0; }
|
|
float GetMinHeight() const { return 200.0; }
|
|
float GetHeightRange() const { return GetMaxHeight() - GetMinHeight(); }
|
|
void SetHeight( float h );
|
|
float GetHeight() { return GetPoseParameter( gm_BodyHeightPoseParam ); }
|
|
void SetIdealHeight( float h );
|
|
void SetAbsIdealHeight( float z );
|
|
float GetIdealHeight() { return m_idealHeight; }
|
|
Vector GetAdjustedOrigin() { Vector result = GetAbsOrigin(); result.z -= GetMaxHeightModel() - GetHeight(); return result; }
|
|
|
|
bool IsInCrouchedPosture() { return GetIdealHeight() < GetMaxHeight() * .5; }
|
|
bool IsInStandingPosture() { return !IsInCrouchedPosture(); }
|
|
bool IsStriderCrouching();
|
|
bool IsStriderStanding();
|
|
void SetupGlobalModelData();
|
|
|
|
virtual bool CanBecomeServerRagdoll( void ) { return false; }
|
|
|
|
//---------------------------------
|
|
// Navigation & Movement
|
|
//---------------------------------
|
|
class CNavigator : public CAI_ComponentWithOuter<CNPC_Strider, CAI_Navigator>
|
|
{
|
|
typedef CAI_ComponentWithOuter<CNPC_Strider, CAI_Navigator> BaseClass;
|
|
public:
|
|
CNavigator( CNPC_Strider *pOuter )
|
|
: BaseClass( pOuter )
|
|
{
|
|
}
|
|
|
|
void MoveCalcBaseGoal( AILocalMoveGoal_t *pMoveGoal );
|
|
bool MoveUpdateWaypoint( AIMoveResult_t *pResult );
|
|
bool DoFindPathToPos();
|
|
bool ShouldOptimizeInitialPathSegment( AI_Waypoint_t *pFirstWaypoint );
|
|
bool GetStoppingPath( CAI_WaypointList *pClippedWaypoints );
|
|
};
|
|
|
|
class CPathfinder : public CAI_Pathfinder
|
|
{
|
|
typedef CAI_Pathfinder BaseClass;
|
|
public:
|
|
CPathfinder( CNPC_Strider *pOuter ) : BaseClass( pOuter ) {}
|
|
virtual bool CanUseLocalNavigation() { return false; }
|
|
};
|
|
|
|
friend class CNavigator;
|
|
friend void AdjustStriderNodePosition( CAI_Network *pNetwork, CAI_Node *pNode );
|
|
|
|
bool OverrideMove( float flInterval );
|
|
void MaintainTurnActivity( void );
|
|
bool IsUnusableNode(int iNodeID, CAI_Hint *pHint); // Override for special NPC behavior
|
|
void TranslateNavGoal( CBaseEntity *pEnemy, Vector &chasePosition );
|
|
bool HasPendingTargetPath();
|
|
void SetTargetPath();
|
|
float GetDefaultNavGoalTolerance();
|
|
void OnMovementComplete();
|
|
float GetSequenceGroundSpeed( CStudioHdr *pStudioHdr, int iSequence );
|
|
|
|
float MaxYawSpeed();
|
|
|
|
CAI_Navigator * CreateNavigator() { return new CNavigator( this ); }
|
|
CAI_Pathfinder *CreatePathfinder() { return new CPathfinder( this ); }
|
|
|
|
//---------------------------------
|
|
// Minigun
|
|
//---------------------------------
|
|
void ShootMinigun( const Vector *pTarget, float aimError, const Vector &vecSpread = vec3_origin );
|
|
void UpdateMinigunControls( float &yaw, float &pitch );
|
|
void GetViewCone( StriderMinigunViewcone_t &cone );
|
|
void NewTarget() { m_flTargetAcquiredTime = gpGlobals->curtime; }
|
|
void OnMinigunStartShooting( CBaseEntity *pTarget ) {};
|
|
void OnMinigunStopShooting( CBaseEntity *pTarget );
|
|
float GetMinigunRateOfFire();
|
|
float GetMinigunOnTargetTime();
|
|
float GetMinigunShootDuration();
|
|
float GetMinigunShootDowntime();
|
|
float GetMinigunShootVariation();
|
|
|
|
CAI_BaseNPC * GetEntity() { return this; }
|
|
|
|
bool IsUsingAggressiveBehavior() { return m_bUseAggressiveBehavior; }
|
|
|
|
//---------------------------------
|
|
// Cannon
|
|
//---------------------------------
|
|
Vector CannonPosition();
|
|
CBaseEntity * GetCannonTarget();
|
|
bool HasCannonTarget() const;
|
|
bool IsCannonTarget( CBaseEntity *pTarget ) const;
|
|
bool AimCannonAt( CBaseEntity *pEntity, float flInterval );
|
|
void FireCannon();
|
|
void CannonHitThink();
|
|
|
|
//---------------------------------
|
|
// Collision handling
|
|
//---------------------------------
|
|
|
|
void VPhysicsShadowCollision( int index, gamevcollisionevent_t *pEvent );
|
|
bool TestCollision( const Ray_t &ray, unsigned int mask, trace_t& trace );
|
|
|
|
// Conservative collision volumes
|
|
static float gm_strideLength;
|
|
|
|
#ifdef HL2_EPISODIC
|
|
void StriderBusterAttached( CBaseEntity *pAttached );
|
|
void StriderBusterDetached( CBaseEntity *pAttached );
|
|
#endif // HL2_EPISODIC
|
|
|
|
public:
|
|
|
|
//---------------------------------
|
|
// Misc
|
|
//---------------------------------
|
|
bool CarriedByDropship();
|
|
void CarriedThink();
|
|
|
|
//---------------------------------
|
|
// Foot handling
|
|
//---------------------------------
|
|
Vector LeftFootHit( float eventtime );
|
|
Vector RightFootHit( float eventtime );
|
|
Vector BackFootHit( float eventtime );
|
|
void StompHit( int followerBoneIndex );
|
|
|
|
void FootFX( const Vector &origin );
|
|
Vector CalculateStompHitPosition( CBaseEntity *pEnemy );
|
|
bool IsLegBoneFollower( CBoneFollower *pFollower );
|
|
CBoneFollower *GetBoneFollowerByIndex( int nIndex );
|
|
int GetBoneFollowerIndex( CBoneFollower *pFollower );
|
|
|
|
protected:
|
|
// Because the strider is a leaf class, we can use
|
|
// static variables to store this information, and save some memory.
|
|
// Should the strider end up having inheritors, their activate may
|
|
// stomp these numbers, in which case you should make these ordinary members
|
|
// again.
|
|
//
|
|
// The strider also caches some pose parameters in SetupGlobalModelData().
|
|
static int m_poseMiniGunYaw, m_poseMiniGunPitch;
|
|
static bool m_sbStaticPoseParamsLoaded;
|
|
virtual void PopulatePoseParameters( void );
|
|
|
|
private:
|
|
|
|
bool ShouldExplodeFromDamage( const CTakeDamageInfo &info );
|
|
bool m_bExploding;
|
|
|
|
//-----------------------------------------------------
|
|
// Conditions, Schedules, Tasks
|
|
//-----------------------------------------------------
|
|
enum
|
|
{
|
|
SCHED_STRIDER_RANGE_ATTACK1 = BaseClass::NEXT_SCHEDULE,
|
|
SCHED_STRIDER_RANGE_ATTACK2, // Immolator
|
|
SCHED_STRIDER_CROUCH,
|
|
SCHED_STRIDER_STAND,
|
|
SCHED_STRIDER_DODGE,
|
|
SCHED_STRIDER_STOMPL,
|
|
SCHED_STRIDER_STOMPR,
|
|
SCHED_STRIDER_FLICKL,
|
|
SCHED_STRIDER_FLICKR,
|
|
SCHED_STRIDER_HUNT,
|
|
SCHED_STRIDER_DIE,
|
|
SCHED_STRIDER_ATTACK_CANNON_TARGET,
|
|
SCHED_STRIDER_CHASE_ENEMY,
|
|
SCHED_STRIDER_COMBAT_FACE,
|
|
SCHED_STRIDER_AGGRESSIVE_COMBAT_STAND,
|
|
SCHED_STRIDER_ESTABLISH_LINE_OF_FIRE_CANNON,
|
|
SCHED_STRIDER_FALL_TO_GROUND,
|
|
|
|
TASK_STRIDER_AIM = BaseClass::NEXT_TASK,
|
|
TASK_STRIDER_DODGE,
|
|
TASK_STRIDER_STOMP,
|
|
TASK_STRIDER_BREAKDOWN,
|
|
TASK_STRIDER_START_MOVING,
|
|
TASK_STRIDER_REFRESH_HUNT_PATH,
|
|
TASK_STRIDER_GET_PATH_TO_CANNON_TARGET,
|
|
TASK_STRIDER_FACE_CANNON_TARGET,
|
|
TASK_STRIDER_SET_HEIGHT,
|
|
TASK_STRIDER_GET_PATH_TO_CANNON_LOS,
|
|
TASK_STRIDER_SET_CANNON_HEIGHT,
|
|
TASK_STRIDER_FIRE_CANNON,
|
|
TASK_STRIDER_FALL_TO_GROUND,
|
|
|
|
COND_STRIDER_DO_FLICK = BaseClass::NEXT_CONDITION,
|
|
COND_TRACK_PATH_GO,
|
|
COND_STRIDER_SHOULD_CROUCH,
|
|
COND_STRIDER_SHOULD_STAND,
|
|
COND_STRIDER_MINIGUN_SHOOTING,
|
|
COND_STRIDER_MINIGUN_NOT_SHOOTING,
|
|
COND_STRIDER_HAS_CANNON_TARGET,
|
|
COND_STRIDER_ENEMY_UPDATED,
|
|
COND_STRIDER_HAS_LOS_Z,
|
|
};
|
|
|
|
string_t m_iszStriderBusterName;
|
|
string_t m_iszMagnadeClassname;
|
|
string_t m_iszHunterClassname;
|
|
|
|
CStriderMinigun *m_pMinigun;
|
|
int m_miniGunAmmo;
|
|
int m_miniGunDirectAmmo;
|
|
float m_nextShootTime;
|
|
float m_nextStompTime;
|
|
float m_ragdollTime;
|
|
float m_miniGunShootDuration;
|
|
float m_aimYaw;
|
|
float m_aimPitch;
|
|
Vector m_blastHit;
|
|
Vector m_blastNormal;
|
|
CNetworkVector( m_vecHitPos );
|
|
CNetworkArray( Vector, m_vecIKTarget, NUM_STRIDER_IK_TARGETS );
|
|
|
|
CRandSimTimer m_PostureAnimationTimer;
|
|
|
|
EHANDLE m_hRagdoll;
|
|
|
|
EHANDLE m_hCannonTarget;
|
|
CSimpleSimTimer m_AttemptCannonLOSTimer;
|
|
|
|
float m_flSpeedScale;
|
|
float m_flTargetSpeedScale;
|
|
|
|
CSimpleSimTimer m_LowZCorrectionTimer;
|
|
|
|
// Contained Bone Follower manager
|
|
CBoneFollowerManager m_BoneFollowerManager;
|
|
|
|
int m_BodyTargetBone;
|
|
|
|
bool m_bDisableBoneFollowers;
|
|
|
|
int m_iVisibleEnemies;
|
|
float m_flTargetAcquiredTime;
|
|
bool m_bCrouchLocked; // Designer made the strider crouch. Don't let the AI stand him up.
|
|
bool m_bNoCrouchWalk;
|
|
bool m_bDontCrouch;
|
|
bool m_bNoMoveToLOS;
|
|
bool m_bFastCrouch;
|
|
bool m_bMinigunEnabled; // If false, minigun disabled by level designer until further notice.
|
|
|
|
float m_idealHeight;
|
|
float m_HeightVelocity;
|
|
|
|
// FIXME: move to a base class to handle turning for blended movement derived characters
|
|
float m_prevYaw;
|
|
float m_doTurn;
|
|
float m_doLeft;
|
|
float m_doRight;
|
|
float m_flNextTurnAct;
|
|
|
|
string_t m_strTrackName;
|
|
|
|
EHANDLE m_hFocus;
|
|
|
|
float m_flTimeLastAlertSound;
|
|
float m_flTimeNextHuntSound;
|
|
bool m_bUseAggressiveBehavior;
|
|
float m_flTimePlayerMissileDetected;
|
|
EHANDLE m_hPlayersMissile;
|
|
bool m_bMinigunUseDirectFire;
|
|
|
|
CHandle<SmokeTrail> m_hSmoke;
|
|
|
|
CSimpleSimTimer m_EnemyUpdatedTimer;
|
|
|
|
CAI_FreePass m_PlayerFreePass;
|
|
|
|
#ifdef HL2_EPISODIC
|
|
CUtlVector< EHANDLE > m_hAttachedBusters; // List of busters attached to us
|
|
#endif // HL2_EPISODIC
|
|
|
|
static float gm_zCannonDist;
|
|
static float gm_zMinigunDist;
|
|
static Vector gm_vLocalRelativePositionCannon;
|
|
static Vector gm_vLocalRelativePositionMinigun;
|
|
|
|
static int gm_YawControl;
|
|
static int gm_PitchControl;
|
|
static int gm_CannonAttachment;
|
|
static int gm_BodyHeightPoseParam;
|
|
|
|
DEFINE_CUSTOM_AI;
|
|
|
|
DECLARE_DATADESC();
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//---------------------------------------------------------
|
|
|
|
enum StriderMinigunPeg_t
|
|
{
|
|
MINIGUN_PEGGED_DONT_CARE = 0,
|
|
MINIGUN_PEGGED_UP,
|
|
MINIGUN_PEGGED_DOWN,
|
|
MINIGUN_PEGGED_LEFT,
|
|
MINIGUN_PEGGED_RIGHT,
|
|
};
|
|
|
|
//---------------------------------------------------------
|
|
|
|
struct StriderMinigunViewcone_t
|
|
{
|
|
Vector origin;
|
|
Vector axis;
|
|
float cosAngle;
|
|
float length;
|
|
};
|
|
|
|
//---------------------------------------------------------
|
|
|
|
struct StriderMinigunAnimController_t
|
|
{
|
|
float current;
|
|
float target;
|
|
float rate;
|
|
|
|
void Update( float dt, bool approach = true )
|
|
{
|
|
if( approach )
|
|
{
|
|
current = Approach( target, current, rate * dt );
|
|
}
|
|
else
|
|
{
|
|
current = target;
|
|
}
|
|
}
|
|
|
|
void Random( float minTarget, float maxTarget, float minRate, float maxRate )
|
|
{
|
|
target = random->RandomFloat( minTarget, maxTarget );
|
|
rate = random->RandomFloat( minRate, maxRate );
|
|
}
|
|
};
|
|
|
|
//---------------------------------------------------------
|
|
|
|
class CStriderMinigun
|
|
{
|
|
public:
|
|
DECLARE_DATADESC();
|
|
|
|
void Init();
|
|
void SetTarget( IStriderMinigunHost *pHost, CBaseEntity *pTarget, bool bOverrideEnemy = false );
|
|
CBaseEntity *GetTarget() { return m_hTarget.Get(); }
|
|
void Think( IStriderMinigunHost *pHost, float dt );
|
|
void SetState( int newState );
|
|
bool ShouldFindTarget( IMinigunHost *pHost );
|
|
void AimAtPoint( IStriderMinigunHost *pHost, const Vector &vecPoint, bool bSnap = false );
|
|
void AimAtTarget( IStriderMinigunHost *pHost, CBaseEntity *pTarget, bool bSnap = false );
|
|
void ShootAtTarget( IStriderMinigunHost *pHost, CBaseEntity *pTarget, float shootTime );
|
|
void StartShooting( IStriderMinigunHost *pHost, CBaseEntity *pTarget, float duration );
|
|
void ExtendShooting( float timeExtend );
|
|
void SetShootDuration( float duration );
|
|
void StopShootingForSeconds( IStriderMinigunHost *pHost, CBaseEntity *pTarget, float duration );
|
|
bool IsPegged( int dir = MINIGUN_PEGGED_DONT_CARE );
|
|
bool CanStartShooting( IStriderMinigunHost *pHost, CBaseEntity *pTargetEnt );
|
|
float GetBurstTimeRemaining() { return m_burstTime - gpGlobals->curtime; }
|
|
|
|
void RecordShotOnTarget() { m_iOnTargetShots++; }
|
|
void ClearOnTarget() { m_iOnTargetShots = 0; }
|
|
bool IsOnTarget( int numShots = 0 ) { return ( numShots == 0 ) ? (m_iOnTargetShots > 0) : (m_iOnTargetShots >= numShots); }
|
|
|
|
void Enable( IMinigunHost *pHost, bool enable );
|
|
float GetAimError();
|
|
|
|
enum minigunstates_t
|
|
{
|
|
MINIGUN_OFF = 0,
|
|
MINIGUN_SHOOTING = 1,
|
|
};
|
|
|
|
int GetState() { return m_minigunState; }
|
|
bool IsShooting() { return GetState() == MINIGUN_SHOOTING; }
|
|
|
|
private:
|
|
bool m_enable;
|
|
int m_minigunState;
|
|
float m_nextBulletTime; // Minigun is shooting, when can I fire my next bullet?
|
|
float m_burstTime; // If firing, how long till done? If not, how long till I can?
|
|
float m_nextTwitchTime;
|
|
int m_randomState;
|
|
EHANDLE m_hTarget;
|
|
StriderMinigunAnimController_t m_yaw;
|
|
StriderMinigunAnimController_t m_pitch;
|
|
bool m_bWarnedAI;
|
|
float m_shootDuration;
|
|
Vector m_vecAnchor; // A burst starts here and goes to the target's orgin.
|
|
bool m_bOverrideEnemy; // The minigun wants something other than the Strider's enemy as a target right now.
|
|
Vector m_vecLastTargetPos; // Last place minigun saw the target.
|
|
int m_iOnTargetShots;
|
|
};
|
|
|
|
|
|
class CSparkTrail : public CPointEntity
|
|
{
|
|
DECLARE_CLASS( CSparkTrail, CPointEntity );
|
|
void Spawn( void );
|
|
void SparkThink( void );
|
|
|
|
virtual void Precache();
|
|
|
|
DECLARE_DATADESC();
|
|
};
|
|
|
|
#include "tier0/memdbgoff.h"
|
|
|
|
#endif // NPC_STRIDER_H
|
|
|
|
//=============================================================================
|