//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Antlion Guard
//
//=============================================================================//
#include "cbase.h"
#include "ai_hint.h"
#include "ai_localnavigator.h"
#include "ai_memory.h"
#include "ai_moveprobe.h"
#include "npcevent.h"
#include "IEffects.h"
#include "ndebugoverlay.h"
#include "soundent.h"
#include "soundenvelope.h"
#include "ai_squad.h"
#include "ai_network.h"
#include "ai_pathfinder.h"
#include "ai_navigator.h"
#include "ai_senses.h"
#include "npc_rollermine.h"
#include "ai_blended_movement.h"
#include "physics_prop_ragdoll.h"
#include "iservervehicle.h"
#include "player_pickup.h"
#include "props.h"
#include "antlion_dust.h"
#include "npc_antlion.h"
#include "decals.h"
#include "prop_combine_ball.h"
#include "eventqueue.h"
#include "te_effect_dispatch.h"
#include "Sprite.h"
#include "particle_parse.h"
#include "particle_system.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
inline void TraceHull_SkipPhysics( const Vector &vecAbsStart, const Vector &vecAbsEnd, const Vector &hullMin,
const Vector &hullMax, unsigned int mask, const CBaseEntity *ignore,
int collisionGroup, trace_t *ptr, float minMass );
ConVar g_debug_antlionguard( "g_debug_antlionguard", "0" );
ConVar sk_antlionguard_dmg_charge( "sk_antlionguard_dmg_charge", "0" );
ConVar sk_antlionguard_dmg_shove( "sk_antlionguard_dmg_shove", "0" );
#if HL2_EPISODIC
// When enabled, add code to have the antlion bleed profusely as it is badly injured.
#define ANTLIONGUARD_BLOOD_EFFECTS 2
ConVar g_antlionguard_hemorrhage( "g_antlionguard_hemorrhage", "1", FCVAR_NONE, "If 1, guard will emit a bleeding particle effect when wounded." );
#endif
// Spawnflags
#define SF_ANTLIONGUARD_SERVERSIDE_RAGDOLL ( 1 << 16 )
#define SF_ANTLIONGUARD_INSIDE_FOOTSTEPS ( 1 << 17 )
#define ENVELOPE_CONTROLLER (CSoundEnvelopeController::GetController())
#define ANTLIONGUARD_MODEL "models/antlion_guard.mdl"
#define MIN_BLAST_DAMAGE 25.0f
#define MIN_CRUSH_DAMAGE 20.0f
//==================================================
//
// Antlion Guard
//
//==================================================
#define ANTLIONGUARD_MAX_OBJECTS 128
#define ANTLIONGUARD_MIN_OBJECT_MASS 8
#define ANTLIONGUARD_MAX_OBJECT_MASS 750
#define ANTLIONGUARD_FARTHEST_PHYSICS_OBJECT 350
#define ANTLIONGUARD_OBJECTFINDING_FOV DOT_45DEGREE // 1/sqrt(2)
//Melee definitions
#define ANTLIONGUARD_MELEE1_RANGE 156.0f
#define ANTLIONGUARD_MELEE1_CONE 0.7f
// Antlion summoning
#define ANTLIONGUARD_SUMMON_COUNT 3
// Sight
#define ANTLIONGUARD_FOV_NORMAL -0.4f
// cavern guard's poisoning behavior
#if HL2_EPISODIC
#define ANTLIONGUARD_POISON_TO 12 // we only poison Gordon down to twelve to give him a chance to regen up to 20 by the next charge
#endif
#define ANTLIONGUARD_CHARGE_MIN 256
#define ANTLIONGUARD_CHARGE_MAX 2048
ConVar sk_antlionguard_health( "sk_antlionguard_health", "0" );
int g_interactionAntlionGuardFoundPhysicsObject = 0; // We're moving to a physics object to shove it, don't all choose the same object
int g_interactionAntlionGuardShovedPhysicsObject = 0; // We've punted an object, it is now clear to be chosen by others
//==================================================
// AntlionGuardSchedules
//==================================================
enum
{
SCHED_ANTLIONGUARD_CHARGE = LAST_SHARED_SCHEDULE,
SCHED_ANTLIONGUARD_CHARGE_CRASH,
SCHED_ANTLIONGUARD_CHARGE_CANCEL,
SCHED_ANTLIONGUARD_PHYSICS_ATTACK,
SCHED_ANTLIONGUARD_PHYSICS_DAMAGE_HEAVY,
SCHED_ANTLIONGUARD_UNBURROW,
SCHED_ANTLIONGUARD_CHARGE_TARGET,
SCHED_ANTLIONGUARD_FIND_CHARGE_POSITION,
SCHED_ANTLIONGUARD_MELEE_ATTACK1,
SCHED_ANTLIONGUARD_SUMMON,
SCHED_ANTLIONGUARD_PATROL_RUN,
SCHED_ANTLIONGUARD_ROAR,
SCHED_ANTLIONGUARD_CHASE_ENEMY_TOLERANCE,
SCHED_FORCE_ANTLIONGUARD_PHYSICS_ATTACK,
SCHED_ANTLIONGUARD_CANT_ATTACK,
SCHED_ANTLIONGUARD_TAKE_COVER_FROM_ENEMY,
SCHED_ANTLIONGUARD_CHASE_ENEMY
};
//==================================================
// AntlionGuardTasks
//==================================================
enum
{
TASK_ANTLIONGUARD_CHARGE = LAST_SHARED_TASK,
TASK_ANTLIONGUARD_GET_PATH_TO_PHYSOBJECT,
TASK_ANTLIONGUARD_SHOVE_PHYSOBJECT,
TASK_ANTLIONGUARD_SUMMON,
TASK_ANTLIONGUARD_SET_FLINCH_ACTIVITY,
TASK_ANTLIONGUARD_GET_PATH_TO_CHARGE_POSITION,
TASK_ANTLIONGUARD_GET_PATH_TO_NEAREST_NODE,
TASK_ANTLIONGUARD_GET_CHASE_PATH_ENEMY_TOLERANCE,
TASK_ANTLIONGUARD_OPPORTUNITY_THROW,
TASK_ANTLIONGUARD_FIND_PHYSOBJECT,
};
//==================================================
// AntlionGuardConditions
//==================================================
enum
{
COND_ANTLIONGUARD_PHYSICS_TARGET = LAST_SHARED_CONDITION,
COND_ANTLIONGUARD_PHYSICS_TARGET_INVALID,
COND_ANTLIONGUARD_HAS_CHARGE_TARGET,
COND_ANTLIONGUARD_CAN_SUMMON,
COND_ANTLIONGUARD_CAN_CHARGE
};
enum
{
SQUAD_SLOT_ANTLIONGUARD_CHARGE = LAST_SHARED_SQUADSLOT,
};
//==================================================
// AntlionGuard Activities
//==================================================
Activity ACT_ANTLIONGUARD_SEARCH;
Activity ACT_ANTLIONGUARD_PEEK_FLINCH;
Activity ACT_ANTLIONGUARD_PEEK_ENTER;
Activity ACT_ANTLIONGUARD_PEEK_EXIT;
Activity ACT_ANTLIONGUARD_PEEK1;
Activity ACT_ANTLIONGUARD_BARK;
Activity ACT_ANTLIONGUARD_PEEK_SIGHTED;
Activity ACT_ANTLIONGUARD_SHOVE_PHYSOBJECT;
Activity ACT_ANTLIONGUARD_FLINCH_LIGHT;
Activity ACT_ANTLIONGUARD_UNBURROW;
Activity ACT_ANTLIONGUARD_ROAR;
Activity ACT_ANTLIONGUARD_RUN_HURT;
// Flinches
Activity ACT_ANTLIONGUARD_PHYSHIT_FR;
Activity ACT_ANTLIONGUARD_PHYSHIT_FL;
Activity ACT_ANTLIONGUARD_PHYSHIT_RR;
Activity ACT_ANTLIONGUARD_PHYSHIT_RL;
// Charge
Activity ACT_ANTLIONGUARD_CHARGE_START;
Activity ACT_ANTLIONGUARD_CHARGE_CANCEL;
Activity ACT_ANTLIONGUARD_CHARGE_RUN;
Activity ACT_ANTLIONGUARD_CHARGE_CRASH;
Activity ACT_ANTLIONGUARD_CHARGE_STOP;
Activity ACT_ANTLIONGUARD_CHARGE_HIT;
Activity ACT_ANTLIONGUARD_CHARGE_ANTICIPATION;
// Anim events
int AE_ANTLIONGUARD_CHARGE_HIT;
int AE_ANTLIONGUARD_SHOVE_PHYSOBJECT;
int AE_ANTLIONGUARD_SHOVE;
int AE_ANTLIONGUARD_FOOTSTEP_LIGHT;
int AE_ANTLIONGUARD_FOOTSTEP_HEAVY;
int AE_ANTLIONGUARD_CHARGE_EARLYOUT;
int AE_ANTLIONGUARD_VOICE_GROWL;
int AE_ANTLIONGUARD_VOICE_BARK;
int AE_ANTLIONGUARD_VOICE_PAIN;
int AE_ANTLIONGUARD_VOICE_SQUEEZE;
int AE_ANTLIONGUARD_VOICE_SCRATCH;
int AE_ANTLIONGUARD_VOICE_GRUNT;
int AE_ANTLIONGUARD_VOICE_ROAR;
int AE_ANTLIONGUARD_BURROW_OUT;
struct PhysicsObjectCriteria_t
{
CBaseEntity *pTarget;
Vector vecCenter; // Center point to look around
float flRadius; // Radius to search within
float flTargetCone;
bool bPreferObjectsAlongTargetVector; // Prefer objects that we can strike easily as we move towards our target
float flNearRadius; // If we won't hit the player with the object, but get this close, throw anyway
};
#define MAX_FAILED_PHYSOBJECTS 8
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CNPC_AntlionGuard : public CAI_BlendedNPC
{
public:
DECLARE_CLASS( CNPC_AntlionGuard, CAI_BlendedNPC );
DECLARE_SERVERCLASS();
DECLARE_DATADESC();
CNPC_AntlionGuard( void );
Class_T Classify( void ) { return CLASS_ANTLION; }
virtual int GetSoundInterests( void ) { return (SOUND_WORLD|SOUND_COMBAT|SOUND_PLAYER|SOUND_DANGER); }
virtual bool QueryHearSound( CSound *pSound );
const impactdamagetable_t &GetPhysicsImpactDamageTable( void );
virtual int MeleeAttack1Conditions( float flDot, float flDist );
virtual int SelectFailSchedule( int failedSchedule, int failedTask, AI_TaskFailureCode_t taskFailCode );
virtual int TranslateSchedule( int scheduleType );
virtual int OnTakeDamage_Alive( const CTakeDamageInfo &info );
virtual void DeathSound( const CTakeDamageInfo &info );
virtual void Event_Killed( const CTakeDamageInfo &info );
virtual int SelectSchedule( void );
virtual float GetAutoAimRadius() { return 36.0f; }
virtual void Precache( void );
virtual void Spawn( void );
virtual void Activate( void );
virtual void HandleAnimEvent( animevent_t *pEvent );
virtual void UpdateEfficiency( bool bInPVS ) { SetEfficiency( ( GetSleepState() != AISS_AWAKE ) ? AIE_DORMANT : AIE_NORMAL ); SetMoveEfficiency( AIME_NORMAL ); }
virtual void PrescheduleThink( void );
virtual void GatherConditions( void );
virtual void TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator );
virtual void StartTask( const Task_t *pTask );
virtual void RunTask( const Task_t *pTask );
virtual void StopLoopingSounds();
virtual bool HandleInteraction( int interactionType, void *data, CBaseCombatCharacter *sender );
// Input handlers.
void InputSetShoveTarget( inputdata_t &inputdata );
void InputSetChargeTarget( inputdata_t &inputdata );
void InputClearChargeTarget( inputdata_t &inputdata );
void InputUnburrow( inputdata_t &inputdata );
void InputRagdoll( inputdata_t &inputdata );
void InputEnableBark( inputdata_t &inputdata );
void InputDisableBark( inputdata_t &inputdata );
void InputSummonedAntlionDied( inputdata_t &inputdata );
void InputEnablePreferPhysicsAttack( inputdata_t &inputdata );
void InputDisablePreferPhysicsAttack( inputdata_t &inputdata );
virtual bool IsLightDamage( const CTakeDamageInfo &info );
virtual bool IsHeavyDamage( const CTakeDamageInfo &info );
virtual bool OverrideMoveFacing( const AILocalMoveGoal_t &move, float flInterval );
virtual bool BecomeRagdollOnClient( const Vector &force );
virtual void UpdateOnRemove( void );
virtual bool IsUnreachable( CBaseEntity* pEntity ); // Is entity is unreachable?
virtual float MaxYawSpeed( void );
virtual bool OverrideMove( float flInterval );
virtual bool CanBecomeRagdoll( void );
virtual bool ShouldProbeCollideAgainstEntity( CBaseEntity *pEntity );
virtual Activity NPC_TranslateActivity( Activity baseAct );
#if HL2_EPISODIC
//---------------------------------
// Navigation & Movement -- prevent stopping paths for the guard
//---------------------------------
class CNavigator : public CAI_ComponentWithOuter<CNPC_AntlionGuard, CAI_Navigator>
{
typedef CAI_ComponentWithOuter<CNPC_AntlionGuard, CAI_Navigator> BaseClass;
public:
CNavigator( CNPC_AntlionGuard *pOuter )
: BaseClass( pOuter )
{
}
bool GetStoppingPath( CAI_WaypointList *pClippedWaypoints );
};
CAI_Navigator * CreateNavigator() { return new CNavigator( this ); }
#endif
DEFINE_CUSTOM_AI;
private:
inline bool CanStandAtPoint( const Vector &vecPos, Vector *pOut );
bool RememberFailedPhysicsTarget( CBaseEntity *pTarget );
void GetPhysicsShoveDir( CBaseEntity *pObject, float flMass, Vector *pOut );
void CreateGlow( CSprite **pSprite, const char *pAttachName );
void DestroyGlows( void );
void Footstep( bool bHeavy );
int SelectCombatSchedule( void );
int SelectUnreachableSchedule( void );
bool CanSummon( bool bIgnoreTime );
void SummonAntlions( void );
void ChargeLookAhead( void );
bool EnemyIsRightInFrontOfMe( CBaseEntity **pEntity );
bool HandleChargeImpact( Vector vecImpact, CBaseEntity *pEntity );
bool ShouldCharge( const Vector &startPos, const Vector &endPos, bool useTime, bool bCheckForCancel );
bool ShouldWatchEnemy( void );
void ImpactShock( const Vector &origin, float radius, float magnitude, CBaseEntity *pIgnored = NULL );
void BuildScheduleTestBits( void );
void Shove( void );
void FoundEnemy( void );
void LostEnemy( void );
void UpdateHead( void );
void UpdatePhysicsTarget( bool bPreferObjectsAlongTargetVector, float flRadius = ANTLIONGUARD_FARTHEST_PHYSICS_OBJECT );
void MaintainPhysicsTarget( void );
void ChargeDamage( CBaseEntity *pTarget );
void StartSounds( void );
void SetHeavyDamageAnim( const Vector &vecSource );
float ChargeSteer( void );
CBaseEntity *FindPhysicsObjectTarget( const PhysicsObjectCriteria_t &criteria );
Vector GetPhysicsHitPosition( CBaseEntity *pObject, CBaseEntity *pTarget, Vector *vecTrajectory, float *flClearDistance );
bool CanStandAtShoveTarget( CBaseEntity *pShoveObject, CBaseEntity *pTarget, Vector *pOut );
CBaseEntity *GetNextShoveTarget( CBaseEntity *pLastEntity, AISightIter_t &iter );
int m_nFlinchActivity;
bool m_bStopped;
bool m_bIsBurrowed;
bool m_bBarkEnabled;
float m_flNextSummonTime;
int m_iNumLiveAntlions;
float m_flSearchNoiseTime;
float m_flAngerNoiseTime;
float m_flBreathTime;
float m_flChargeTime;
float m_flPhysicsCheckTime;
float m_flNextHeavyFlinchTime;
float m_flNextRoarTime;
int m_iChargeMisses;
bool m_bDecidedNotToStop;
bool m_bPreferPhysicsAttack;
CNetworkVar( bool, m_bCavernBreed ); // If this guard is meant to be a cavern dweller (uses different assets)
CNetworkVar( bool, m_bInCavern ); // Behavioral hint telling the guard to change his behavior
Vector m_vecPhysicsTargetStartPos;
Vector m_vecPhysicsHitPosition;
EHANDLE m_hShoveTarget;
EHANDLE m_hChargeTarget;
EHANDLE m_hChargeTargetPosition;
EHANDLE m_hOldTarget;
EHANDLE m_hPhysicsTarget;
CUtlVectorFixed<EHANDLE, MAX_FAILED_PHYSOBJECTS> m_FailedPhysicsTargets;
COutputEvent m_OnSummon;
CSoundPatch *m_pGrowlHighSound;
CSoundPatch *m_pGrowlLowSound;
CSoundPatch *m_pGrowlIdleSound;
CSoundPatch *m_pBreathSound;
CSoundPatch *m_pConfusedSound;
string_t m_iszPhysicsPropClass;
string_t m_strShoveTargets;
CSprite *m_hCaveGlow[2];
#if ANTLIONGUARD_BLOOD_EFFECTS
CNetworkVar( uint8, m_iBleedingLevel );
unsigned char GetBleedingLevel( void ) const;
#endif
protected:
int m_poseThrow;
int m_poseHead_Yaw, m_poseHead_Pitch;
virtual void PopulatePoseParameters( void );
// inline accessors
public:
inline bool IsCavernBreed( void ) const { return m_bCavernBreed; }
inline bool IsInCavern( void ) const { return m_bInCavern; }
};
//==================================================
// CNPC_AntlionGuard::m_DataDesc
//==================================================
BEGIN_DATADESC( CNPC_AntlionGuard )
DEFINE_FIELD( m_nFlinchActivity, FIELD_INTEGER ),
DEFINE_FIELD( m_bStopped, FIELD_BOOLEAN ),
DEFINE_KEYFIELD( m_bIsBurrowed, FIELD_BOOLEAN, "startburrowed" ),
DEFINE_KEYFIELD( m_bBarkEnabled, FIELD_BOOLEAN, "allowbark" ),
DEFINE_FIELD( m_flNextSummonTime, FIELD_TIME ),
DEFINE_FIELD( m_iNumLiveAntlions, FIELD_INTEGER ),
DEFINE_FIELD( m_flSearchNoiseTime, FIELD_TIME ),
DEFINE_FIELD( m_flAngerNoiseTime, FIELD_TIME ),
DEFINE_FIELD( m_flBreathTime, FIELD_TIME ),
DEFINE_FIELD( m_flChargeTime, FIELD_TIME ),
DEFINE_FIELD( m_hShoveTarget, FIELD_EHANDLE ),
DEFINE_FIELD( m_hChargeTarget, FIELD_EHANDLE ),
DEFINE_FIELD( m_hChargeTargetPosition, FIELD_EHANDLE ),
DEFINE_FIELD( m_hOldTarget, FIELD_EHANDLE ),
// m_FailedPhysicsTargets // We do not save/load these
DEFINE_FIELD( m_hPhysicsTarget, FIELD_EHANDLE ),
DEFINE_FIELD( m_vecPhysicsTargetStartPos, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( m_vecPhysicsHitPosition, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( m_flPhysicsCheckTime, FIELD_TIME ),
DEFINE_FIELD( m_flNextHeavyFlinchTime, FIELD_TIME ),
DEFINE_FIELD( m_flNextRoarTime, FIELD_TIME ),
DEFINE_FIELD( m_iChargeMisses, FIELD_INTEGER ),
DEFINE_FIELD( m_bDecidedNotToStop, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bPreferPhysicsAttack, FIELD_BOOLEAN ),
#if ANTLIONGUARD_BLOOD_EFFECTS
DEFINE_FIELD( m_iBleedingLevel, FIELD_CHARACTER ),
#endif
DEFINE_KEYFIELD( m_bCavernBreed,FIELD_BOOLEAN, "cavernbreed" ),
DEFINE_KEYFIELD( m_bInCavern, FIELD_BOOLEAN, "incavern" ),
DEFINE_KEYFIELD( m_strShoveTargets, FIELD_STRING, "shovetargets" ),
DEFINE_AUTO_ARRAY( m_hCaveGlow, FIELD_CLASSPTR ),
DEFINE_OUTPUT( m_OnSummon, "OnSummon" ),
DEFINE_SOUNDPATCH( m_pGrowlHighSound ),
DEFINE_SOUNDPATCH( m_pGrowlLowSound ),
DEFINE_SOUNDPATCH( m_pGrowlIdleSound ),
DEFINE_SOUNDPATCH( m_pBreathSound ),
DEFINE_SOUNDPATCH( m_pConfusedSound ),
DEFINE_INPUTFUNC( FIELD_STRING, "SetShoveTarget", InputSetShoveTarget ),
DEFINE_INPUTFUNC( FIELD_STRING, "SetChargeTarget", InputSetChargeTarget ),
DEFINE_INPUTFUNC( FIELD_VOID, "ClearChargeTarget", InputClearChargeTarget ),
DEFINE_INPUTFUNC( FIELD_VOID, "Unburrow", InputUnburrow ),
DEFINE_INPUTFUNC( FIELD_VOID, "Ragdoll", InputRagdoll ),
DEFINE_INPUTFUNC( FIELD_VOID, "EnableBark", InputEnableBark ),
DEFINE_INPUTFUNC( FIELD_VOID, "DisableBark", InputDisableBark ),
DEFINE_INPUTFUNC( FIELD_VOID, "SummonedAntlionDied", InputSummonedAntlionDied ),
DEFINE_INPUTFUNC( FIELD_VOID, "EnablePreferPhysicsAttack", InputEnablePreferPhysicsAttack ),
DEFINE_INPUTFUNC( FIELD_VOID, "DisablePreferPhysicsAttack", InputDisablePreferPhysicsAttack ),
END_DATADESC()
//Fast Growl (Growl High)
envelopePoint_t envAntlionGuardFastGrowl[] =
{
{ 1.0f, 1.0f,
0.2f, 0.4f,
},
{ 0.1f, 0.1f,
0.8f, 1.0f,
},
{ 0.0f, 0.0f,
0.4f, 0.8f,
},
};
//Bark 1 (Growl High)
envelopePoint_t envAntlionGuardBark1[] =
{
{ 1.0f, 1.0f,
0.1f, 0.2f,
},
{ 0.0f, 0.0f,
0.4f, 0.6f,
},
};
//Bark 2 (Confused)
envelopePoint_t envAntlionGuardBark2[] =
{
{ 1.0f, 1.0f,
0.1f, 0.2f,
},
{ 0.2f, 0.3f,
0.1f, 0.2f,
},
{ 0.0f, 0.0f,
0.4f, 0.6f,
},
};
//Pain
envelopePoint_t envAntlionGuardPain1[] =
{
{ 1.0f, 1.0f,
0.1f, 0.2f,
},
{ -1.0f, -1.0f,
0.5f, 0.8f,
},
{ 0.1f, 0.2f,
0.1f, 0.2f,
},
{ 0.0f, 0.0f,
0.5f, 0.75f,
},
};
//Squeeze (High Growl)
envelopePoint_t envAntlionGuardSqueeze[] =
{
{ 1.0f, 1.0f,
0.1f, 0.2f,
},
{ 0.0f, 0.0f,
1.0f, 1.5f,
},
};
//Scratch (Low Growl)
envelopePoint_t envAntlionGuardScratch[] =
{
{ 1.0f, 1.0f,
0.4f, 0.6f,
},
{ 0.5f, 0.5f,
0.4f, 0.6f,
},
{ 0.0f, 0.0f,
1.0f, 1.5f,
},
};
//Grunt
envelopePoint_t envAntlionGuardGrunt[] =
{
{ 0.6f, 1.0f,
0.1f, 0.2f,
},
{ 0.0f, 0.0f,
0.1f, 0.2f,
},
};
envelopePoint_t envAntlionGuardGrunt2[] =
{
{ 0.2f, 0.4f,
0.1f, 0.2f,
},
{ 0.0f, 0.0f,
0.4f, 0.6f,
},
};
//==============================================================================================
// ANTLION GUARD PHYSICS DAMAGE TABLE
//==============================================================================================
static impactentry_t antlionGuardLinearTable[] =
{
{ 100*100, 10 },
{ 250*250, 25 },
{ 350*350, 50 },
{ 500*500, 75 },
{ 1000*1000,100 },
};
static impactentry_t antlionGuardAngularTable[] =
{
{ 50* 50, 10 },
{ 100*100, 25 },
{ 150*150, 50 },
{ 200*200, 75 },
};
impactdamagetable_t gAntlionGuardImpactDamageTable =
{
antlionGuardLinearTable,
antlionGuardAngularTable,
ARRAYSIZE(antlionGuardLinearTable),
ARRAYSIZE(antlionGuardAngularTable),
200*200,// minimum linear speed squared
180*180,// minimum angular speed squared (360 deg/s to cause spin/slice damage)
15, // can't take damage from anything under 15kg
10, // anything less than 10kg is "small"
5, // never take more than 1 pt of damage from anything under 15kg
128*128,// <15kg objects must go faster than 36 in/s to do damage
45, // large mass in kg
2, // large mass scale (anything over 500kg does 4X as much energy to read from damage table)
1, // large mass falling scale
0, // my min velocity
};
//-----------------------------------------------------------------------------
// Purpose:
// Output : const impactdamagetable_t
//-----------------------------------------------------------------------------
const impactdamagetable_t &CNPC_AntlionGuard::GetPhysicsImpactDamageTable( void )
{
return gAntlionGuardImpactDamageTable;
}
//==================================================
// CNPC_AntlionGuard
//==================================================
CNPC_AntlionGuard::CNPC_AntlionGuard( void )
{
m_bCavernBreed = false;
m_bInCavern = false;
m_iszPhysicsPropClass = AllocPooledString( "prop_physics" );
}
LINK_ENTITY_TO_CLASS( npc_antlionguard, CNPC_AntlionGuard );
IMPLEMENT_SERVERCLASS_ST(CNPC_AntlionGuard, DT_NPC_AntlionGuard)
SendPropBool( SENDINFO( m_bCavernBreed ) ),
SendPropBool( SENDINFO( m_bInCavern ) ),
#if ANTLIONGUARD_BLOOD_EFFECTS
SendPropInt( SENDINFO( m_iBleedingLevel ), 2, SPROP_UNSIGNED ),
#endif
END_SEND_TABLE()
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::UpdateOnRemove( void )
{
DestroyGlows();
// Chain to the base class
BaseClass::UpdateOnRemove();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::Precache( void )
{
PrecacheModel( ANTLIONGUARD_MODEL );
PrecacheScriptSound( "NPC_AntlionGuard.Shove" );
PrecacheScriptSound( "NPC_AntlionGuard.HitHard" );
if ( HasSpawnFlags(SF_ANTLIONGUARD_INSIDE_FOOTSTEPS) )
{
PrecacheScriptSound( "NPC_AntlionGuard.Inside.StepLight" );
PrecacheScriptSound( "NPC_AntlionGuard.Inside.StepHeavy" );
}
else
{
PrecacheScriptSound( "NPC_AntlionGuard.StepLight" );
PrecacheScriptSound( "NPC_AntlionGuard.StepHeavy" );
}
#if HL2_EPISODIC
PrecacheScriptSound( "NPC_AntlionGuard.NearStepLight" );
PrecacheScriptSound( "NPC_AntlionGuard.NearStepHeavy" );
PrecacheScriptSound( "NPC_AntlionGuard.FarStepLight" );
PrecacheScriptSound( "NPC_AntlionGuard.FarStepHeavy" );
PrecacheScriptSound( "NPC_AntlionGuard.BreatheLoop" );
PrecacheScriptSound( "NPC_AntlionGuard.ShellCrack" );
PrecacheScriptSound( "NPC_AntlionGuard.Pain_Roar" );
PrecacheModel( "sprites/grubflare1.vmt" );
#endif // HL2_EPISODIC
PrecacheScriptSound( "NPC_AntlionGuard.Anger" );
PrecacheScriptSound( "NPC_AntlionGuard.Roar" );
PrecacheScriptSound( "NPC_AntlionGuard.Die" );
PrecacheScriptSound( "NPC_AntlionGuard.GrowlHigh" );
PrecacheScriptSound( "NPC_AntlionGuard.GrowlIdle" );
PrecacheScriptSound( "NPC_AntlionGuard.BreathSound" );
PrecacheScriptSound( "NPC_AntlionGuard.Confused" );
PrecacheScriptSound( "NPC_AntlionGuard.Fallover" );
PrecacheScriptSound( "NPC_AntlionGuard.FrustratedRoar" );
PrecacheParticleSystem( "blood_antlionguard_injured_light" );
PrecacheParticleSystem( "blood_antlionguard_injured_heavy" );
BaseClass::Precache();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::DestroyGlows( void )
{
if ( m_hCaveGlow[0] )
{
UTIL_Remove( m_hCaveGlow[0] );
// reset it to NULL in case there is a double death cleanup for some reason.
m_hCaveGlow[0] = NULL;
}
if ( m_hCaveGlow[1] )
{
UTIL_Remove( m_hCaveGlow[1] );
// reset it to NULL in case there is a double death cleanup for some reason.
m_hCaveGlow[1] = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::CreateGlow( CSprite **pSprite, const char *pAttachName )
{
if ( pSprite == NULL )
return;
// Create the glow sprite
*pSprite = CSprite::SpriteCreate( "sprites/grubflare1.vmt", GetLocalOrigin(), false );
Assert( *pSprite );
if ( *pSprite == NULL )
return;
(*pSprite)->TurnOn();
(*pSprite)->SetTransparency( kRenderWorldGlow, 156, 169, 121, 164, kRenderFxNoDissipation );
(*pSprite)->SetScale( 1.0f );
(*pSprite)->SetGlowProxySize( 16.0f );
int nAttachment = LookupAttachment( pAttachName );
(*pSprite)->SetParent( this, nAttachment );
(*pSprite)->SetLocalOrigin( vec3_origin );
// Don't uselessly animate, we're a static sprite!
(*pSprite)->SetThink( NULL );
(*pSprite)->SetNextThink( TICK_NEVER_THINK );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::Spawn( void )
{
Precache();
SetModel( ANTLIONGUARD_MODEL );
// Switch our skin (for now), if we're the cavern guard
if ( m_bCavernBreed )
{
m_nSkin = 1;
// Add glows
CreateGlow( &(m_hCaveGlow[0]), "attach_glow1" );
CreateGlow( &(m_hCaveGlow[1]), "attach_glow2" );
}
else
{
m_hCaveGlow[0] = NULL;
m_hCaveGlow[1] = NULL;
}
SetHullType( HULL_LARGE );
SetHullSizeNormal();
SetDefaultEyeOffset();
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_NOT_STANDABLE );
SetMoveType( MOVETYPE_STEP );
SetNavType( NAV_GROUND );
SetBloodColor( BLOOD_COLOR_YELLOW );
m_iHealth = sk_antlionguard_health.GetFloat();
m_iMaxHealth = m_iHealth;
m_flFieldOfView = ANTLIONGUARD_FOV_NORMAL;
m_flPhysicsCheckTime = 0;
m_flChargeTime = 0;
m_flNextRoarTime = 0;
m_flNextSummonTime = 0;
m_iNumLiveAntlions = 0;
m_iChargeMisses = 0;
m_flNextHeavyFlinchTime = 0;
m_bDecidedNotToStop = false;
ClearHintGroup();
m_bStopped = false;
m_hShoveTarget = NULL;
m_hChargeTarget = NULL;
m_hChargeTargetPosition = NULL;
m_hPhysicsTarget = NULL;
m_HackedGunPos.x = 10;
m_HackedGunPos.y = 0;
m_HackedGunPos.z = 30;
CapabilitiesClear();
CapabilitiesAdd( bits_CAP_MOVE_GROUND | bits_CAP_INNATE_MELEE_ATTACK1 | bits_CAP_SQUAD );
CapabilitiesAdd( bits_CAP_SKIP_NAV_GROUND_CHECK );
NPCInit();
BaseClass::Spawn();
//See if we're supposed to start burrowed
if ( m_bIsBurrowed )
{
AddEffects( EF_NODRAW );
AddFlag( FL_NOTARGET );
m_spawnflags |= SF_NPC_GAG;
AddSolidFlags( FSOLID_NOT_SOLID );
m_takedamage = DAMAGE_NO;
if ( m_hCaveGlow[0] )
m_hCaveGlow[0]->TurnOff();
if ( m_hCaveGlow[1] )
m_hCaveGlow[1]->TurnOff();
}
// Do not dissolve
AddEFlags( EFL_NO_DISSOLVE );
// We get a minute of free knowledge about the target
GetEnemies()->SetEnemyDiscardTime( 120.0f );
GetEnemies()->SetFreeKnowledgeDuration( 60.0f );
// We need to bloat the absbox to encompass all the hitboxes
Vector absMin = -Vector(100,100,0);
Vector absMax = Vector(100,100,128);
CollisionProp()->SetSurroundingBoundsType( USE_SPECIFIED_BOUNDS, &absMin, &absMax );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::Activate( void )
{
BaseClass::Activate();
// Find all nearby physics objects and add them to the list of objects we will sense
CBaseEntity *pObject = NULL;
while ( ( pObject = gEntList.FindEntityInSphere( pObject, WorldSpaceCenter(), 2500 ) ) != NULL )
{
// Can't throw around debris
if ( pObject->GetCollisionGroup() == COLLISION_GROUP_DEBRIS )
continue;
// We can only throw a few types of things
if ( !FClassnameIs( pObject, "prop_physics" ) && !FClassnameIs( pObject, "func_physbox" ) )
continue;
// Ensure it's mass is within range
IPhysicsObject *pPhysObj = pObject->VPhysicsGetObject();
if( ( pPhysObj == NULL ) || ( pPhysObj->GetMass() > ANTLIONGUARD_MAX_OBJECT_MASS ) || ( pPhysObj->GetMass() < ANTLIONGUARD_MIN_OBJECT_MASS ) )
continue;
// Tell the AI sensing list that we want to consider this
g_AI_SensedObjectsManager.AddEntity( pObject );
if ( g_debug_antlionguard.GetInt() == 5 )
{
Msg("Antlion Guard: Added prop with model '%s' to sense list.\n", STRING(pObject->GetModelName()) );
pObject->m_debugOverlays |= OVERLAY_BBOX_BIT;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Return true if the guard's allowed to summon antlions
//-----------------------------------------------------------------------------
bool CNPC_AntlionGuard::CanSummon( bool bIgnoreTime )
{
if ( !m_bBarkEnabled )
return false;
if ( !bIgnoreTime && m_flNextSummonTime > gpGlobals->curtime )
return false;
// Hit the max number of them allowed? Only summon when we're 2 down.
if ( m_iNumLiveAntlions >= MAX(1, ANTLIONGUARD_SUMMON_COUNT-1) )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Our enemy is unreachable. Select a schedule.
//-----------------------------------------------------------------------------
int CNPC_AntlionGuard::SelectUnreachableSchedule( void )
{
// If we're in the cavern setting, we opt out of this
if ( m_bInCavern )
return SCHED_ANTLIONGUARD_CHASE_ENEMY_TOLERANCE;
// Summon antlions if we can
if ( HasCondition( COND_ANTLIONGUARD_CAN_SUMMON ) )
return SCHED_ANTLIONGUARD_SUMMON;
// First, look for objects near ourselves
PhysicsObjectCriteria_t criteria;
criteria.bPreferObjectsAlongTargetVector = false;
criteria.flNearRadius = (40*12);
criteria.flRadius = (250*12);
criteria.flTargetCone = -1.0f;
criteria.pTarget = GetEnemy();
criteria.vecCenter = GetAbsOrigin();
CBaseEntity *pTarget = FindPhysicsObjectTarget( criteria );
if ( pTarget == NULL && GetEnemy() )
{
// Use the same criteria, but search near the target instead of us
criteria.vecCenter = GetEnemy()->GetAbsOrigin();
pTarget = FindPhysicsObjectTarget( criteria );
}
// If we found one, we'll want to attack it
if ( pTarget )
{
m_hPhysicsTarget = pTarget;
SetCondition( COND_ANTLIONGUARD_PHYSICS_TARGET );
m_vecPhysicsTargetStartPos = m_hPhysicsTarget->WorldSpaceCenter();
// Tell any squadmates I'm going for this item so they don't as well
if ( GetSquad() != NULL )
{
GetSquad()->BroadcastInteraction( g_interactionAntlionGuardFoundPhysicsObject, (void *)((CBaseEntity *)m_hPhysicsTarget), this );
}
return SCHED_ANTLIONGUARD_PHYSICS_ATTACK;
}
// Deal with a visible player
if ( HasCondition( COND_SEE_ENEMY ) )
{
// Roar at the player as show of frustration
if ( m_flNextRoarTime < gpGlobals->curtime )
{
m_flNextRoarTime = gpGlobals->curtime + RandomFloat( 20,40 );
return SCHED_ANTLIONGUARD_ROAR;
}
// If we're under attack, then let's leave for a bit
if ( GetEnemy() && HasCondition( COND_HEAVY_DAMAGE ) )
{
Vector dir = GetEnemy()->GetAbsOrigin() - GetAbsOrigin();
VectorNormalize(dir);
GetMotor()->SetIdealYaw( -dir );
return SCHED_ANTLIONGUARD_TAKE_COVER_FROM_ENEMY;
}
}
// If we're too far away, try to close distance to our target first
float flDistToEnemySqr = ( GetEnemy()->GetAbsOrigin() - GetAbsOrigin() ).LengthSqr();
if ( flDistToEnemySqr > Square( 100*12 ) )
return SCHED_ANTLIONGUARD_CHASE_ENEMY_TOLERANCE;
// Fire that we're unable to reach our target!
if ( GetEnemy() && GetEnemy()->IsPlayer() )
{
m_OnLostPlayer.FireOutput( this, this );
}
m_OnLostEnemy.FireOutput( this, this );
GetEnemies()->MarkAsEluded( GetEnemy() );
// Move randomly for the moment
return SCHED_ANTLIONGUARD_CANT_ATTACK;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CNPC_AntlionGuard::SelectCombatSchedule( void )
{
ClearHintGroup();
/*
bool bCanCharge = false;
if ( HasCondition( COND_SEE_ENEMY ) )
{
bCanCharge = ShouldCharge( GetAbsOrigin(), GetEnemy()->GetAbsOrigin(), true, false );
}
*/
// Attack if we can
if ( HasCondition(COND_CAN_MELEE_ATTACK1) )
return SCHED_MELEE_ATTACK1;
// Otherwise, summon antlions
if ( HasCondition(COND_ANTLIONGUARD_CAN_SUMMON) )
{
// If I can charge, and have antlions, charge instead
if ( HasCondition( COND_ANTLIONGUARD_CAN_CHARGE ) && m_iNumLiveAntlions )
return SCHED_ANTLIONGUARD_CHARGE;
return SCHED_ANTLIONGUARD_SUMMON;
}
// See if we can bark
if ( HasCondition( COND_ENEMY_UNREACHABLE ) )
return SelectUnreachableSchedule();
//Physics target
if ( HasCondition( COND_ANTLIONGUARD_PHYSICS_TARGET ) && !m_bInCavern )
return SCHED_ANTLIONGUARD_PHYSICS_ATTACK;
// If we've missed a couple of times, and we can summon, make it harder
if ( m_iChargeMisses >= 2 && CanSummon(true) )
{
m_iChargeMisses--;
return SCHED_ANTLIONGUARD_SUMMON;
}
// Charging
if ( HasCondition( COND_ANTLIONGUARD_CAN_CHARGE ) )
{
// Don't let other squad members charge while we're doing it
OccupyStrategySlot( SQUAD_SLOT_ANTLIONGUARD_CHARGE );
return SCHED_ANTLIONGUARD_CHARGE;
}
return BaseClass::SelectSchedule();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_AntlionGuard::ShouldCharge( const Vector &startPos, const Vector &endPos, bool useTime, bool bCheckForCancel )
{
// Don't charge in tight spaces unless forced to
if ( hl2_episodic.GetBool() && m_bInCavern && !(m_hChargeTarget.Get() && m_hChargeTarget->IsAlive()) )
return false;
// Must have a target
if ( !GetEnemy() )
return false;
// No one else in the squad can be charging already
if ( IsStrategySlotRangeOccupied( SQUAD_SLOT_ANTLIONGUARD_CHARGE, SQUAD_SLOT_ANTLIONGUARD_CHARGE ) )
return false;
// Don't check the distance once we start charging
if ( !bCheckForCancel )
{
// Don't allow use to charge again if it's been too soon
if ( useTime && ( m_flChargeTime > gpGlobals->curtime ) )
return false;
float distance = UTIL_DistApprox2D( startPos, endPos );
// Must be within our tolerance range
if ( ( distance < ANTLIONGUARD_CHARGE_MIN ) || ( distance > ANTLIONGUARD_CHARGE_MAX ) )
return false;
}
if ( GetSquad() )
{
// If someone in our squad is closer to the enemy, then don't charge (we end up hitting them more often than not!)
float flOurDistToEnemySqr = ( GetAbsOrigin() - GetEnemy()->GetAbsOrigin() ).LengthSqr();
AISquadIter_t iter;
for ( CAI_BaseNPC *pSquadMember = GetSquad()->GetFirstMember( &iter ); pSquadMember; pSquadMember = GetSquad()->GetNextMember( &iter ) )
{
if ( pSquadMember->IsAlive() == false || pSquadMember == this )
continue;
if ( ( pSquadMember->GetAbsOrigin() - GetEnemy()->GetAbsOrigin() ).LengthSqr() < flOurDistToEnemySqr )
return false;
}
}
//FIXME: We'd like to exclude small physics objects from this check!
// We only need to hit the endpos with the edge of our bounding box
Vector vecDir = endPos - startPos;
VectorNormalize( vecDir );
float flWidth = WorldAlignSize().x * 0.5;
Vector vecTargetPos = endPos - (vecDir * flWidth);
// See if we can directly move there
AIMoveTrace_t moveTrace;
GetMoveProbe()->MoveLimit( NAV_GROUND, startPos, vecTargetPos, MASK_NPCSOLID_BRUSHONLY, GetEnemy(), &moveTrace );
// Draw the probe
if ( g_debug_antlionguard.GetInt() == 1 )
{
Vector enemyDir = (vecTargetPos - startPos);
float enemyDist = VectorNormalize( enemyDir );
NDebugOverlay::BoxDirection( startPos, GetHullMins(), GetHullMaxs() + Vector(enemyDist,0,0), enemyDir, 0, 255, 0, 8, 1.0f );
}
// If we're not blocked, charge
if ( IsMoveBlocked( moveTrace ) )
{
// Don't allow it if it's too close to us
if ( UTIL_DistApprox( WorldSpaceCenter(), moveTrace.vEndPosition ) < ANTLIONGUARD_CHARGE_MIN )
return false;
// Allow some special cases to not block us
if ( moveTrace.pObstruction != NULL )
{
// If we've hit the world, see if it's a cliff
if ( moveTrace.pObstruction == GetContainingEntity( INDEXENT(0) ) )
{
// Can't be too far above/below the target
if ( fabs( moveTrace.vEndPosition.z - vecTargetPos.z ) > StepHeight() )
return false;
// Allow it if we got pretty close
if ( UTIL_DistApprox( moveTrace.vEndPosition, vecTargetPos ) < 64 )
return true;
}
// Hit things that will take damage
if ( moveTrace.pObstruction->m_takedamage != DAMAGE_NO )
return true;
// Hit things that will move
if ( moveTrace.pObstruction->GetMoveType() == MOVETYPE_VPHYSICS )
return true;
}
return false;
}
// Only update this if we've requested it
if ( useTime )
{
m_flChargeTime = gpGlobals->curtime + 4.0f;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CNPC_AntlionGuard::SelectSchedule( void )
{
// Don't do anything if we're burrowed
if ( m_bIsBurrowed )
return SCHED_IDLE_STAND;
#if 0
// Debug physics object finding
if ( 0 ) //g_debug_antlionguard.GetInt() == 3 )
{
m_flPhysicsCheckTime = 0;
UpdatePhysicsTarget( false );
return SCHED_IDLE_STAND;
}
#endif
// Flinch on heavy damage, but not if we've flinched too recently.
// This is done to prevent stun-locks from grenades.
if ( !m_bInCavern && HasCondition( COND_HEAVY_DAMAGE ) && m_flNextHeavyFlinchTime < gpGlobals->curtime )
{
m_flNextHeavyFlinchTime = gpGlobals->curtime + 8.0f;
return SCHED_ANTLIONGUARD_PHYSICS_DAMAGE_HEAVY;
}
// Prefer to use physics, in this case
if ( m_bPreferPhysicsAttack )
{
// If we have a target, try to go for it
if ( HasCondition( COND_ANTLIONGUARD_PHYSICS_TARGET ) )
return SCHED_ANTLIONGUARD_PHYSICS_ATTACK;
}
// Charge after a target if it's set
if ( m_hChargeTarget && m_hChargeTargetPosition )
{
ClearCondition( COND_ANTLIONGUARD_HAS_CHARGE_TARGET );
ClearHintGroup();
if ( m_hChargeTarget->IsAlive() == false )
{
m_hChargeTarget = NULL;
m_hChargeTargetPosition = NULL;
SetEnemy( m_hOldTarget );
if ( m_hOldTarget == NULL )
{
m_NPCState = NPC_STATE_ALERT;
}
}
else
{
m_hOldTarget = GetEnemy();
SetEnemy( m_hChargeTarget );
UpdateEnemyMemory( m_hChargeTarget, m_hChargeTarget->GetAbsOrigin() );
//If we can't see the target, run to somewhere we can
if ( ShouldCharge( GetAbsOrigin(), GetEnemy()->GetAbsOrigin(), false, false ) == false )
return SCHED_ANTLIONGUARD_FIND_CHARGE_POSITION;
return SCHED_ANTLIONGUARD_CHARGE_TARGET;
}
}
// See if we need to clear a path to our enemy
if ( HasCondition( COND_ENEMY_OCCLUDED ) || HasCondition( COND_ENEMY_UNREACHABLE ) )
{
CBaseEntity *pBlocker = GetEnemyOccluder();
if ( ( pBlocker != NULL ) && FClassnameIs( pBlocker, "prop_physics" ) && !m_bInCavern )
{
m_hPhysicsTarget = pBlocker;
return SCHED_ANTLIONGUARD_PHYSICS_ATTACK;
}
}
//Only do these in combat states
if ( m_NPCState == NPC_STATE_COMBAT && GetEnemy() )
return SelectCombatSchedule();
return BaseClass::SelectSchedule();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CNPC_AntlionGuard::MeleeAttack1Conditions( float flDot, float flDist )
{
// Don't attack again too soon
if ( GetNextAttack() > gpGlobals->curtime )
return 0;
// While charging, we can't melee attack
if ( IsCurSchedule( SCHED_ANTLIONGUARD_CHARGE ) )
return 0;
if ( hl2_episodic.GetBool() && m_bInCavern )
{
// Predict where they'll be and see if THAT is within range
Vector vecPredPos;
UTIL_PredictedPosition( GetEnemy(), 0.25f, &vecPredPos );
if ( ( GetAbsOrigin() - vecPredPos ).Length() > ANTLIONGUARD_MELEE1_RANGE )
return COND_TOO_FAR_TO_ATTACK;
}
else
{
// Must be close enough
if ( flDist > ANTLIONGUARD_MELEE1_RANGE )
return COND_TOO_FAR_TO_ATTACK;
}
// Must be within a viable cone
if ( flDot < ANTLIONGUARD_MELEE1_CONE )
return COND_NOT_FACING_ATTACK;
// If the enemy is on top of me, I'm allowed to hit the sucker
if ( GetEnemy()->GetGroundEntity() == this )
return COND_CAN_MELEE_ATTACK1;
trace_t tr;
TraceHull_SkipPhysics( WorldSpaceCenter(), GetEnemy()->WorldSpaceCenter(), Vector(-10,-10,-10), Vector(10,10,10), MASK_SHOT_HULL, this, COLLISION_GROUP_NONE, &tr, VPhysicsGetObject()->GetMass() * 0.5 );
// If we hit anything, go for it
if ( tr.fraction < 1.0f )
return COND_CAN_MELEE_ATTACK1;
return 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CNPC_AntlionGuard::MaxYawSpeed( void )
{
Activity eActivity = GetActivity();
// Stay still
if (( eActivity == ACT_ANTLIONGUARD_SEARCH ) ||
( eActivity == ACT_ANTLIONGUARD_PEEK_ENTER ) ||
( eActivity == ACT_ANTLIONGUARD_PEEK_EXIT ) ||
( eActivity == ACT_ANTLIONGUARD_PEEK1 ) ||
( eActivity == ACT_ANTLIONGUARD_BARK ) ||
( eActivity == ACT_ANTLIONGUARD_PEEK_SIGHTED ) ||
( eActivity == ACT_MELEE_ATTACK1 ) )
return 0.0f;
CBaseEntity *pEnemy = GetEnemy();
if ( pEnemy != NULL && pEnemy->IsPlayer() == false )
return 16.0f;
// Turn slowly when you're charging
if ( eActivity == ACT_ANTLIONGUARD_CHARGE_START )
return 4.0f;
if ( hl2_episodic.GetBool() && m_bInCavern )
{
// Allow a better turning rate when moving quickly but not charging the player
if ( ( eActivity == ACT_ANTLIONGUARD_CHARGE_RUN ) && IsCurSchedule( SCHED_ANTLIONGUARD_CHARGE ) == false )
return 16.0f;
}
// Turn more slowly as we close in on our target
if ( eActivity == ACT_ANTLIONGUARD_CHARGE_RUN )
{
if ( pEnemy == NULL )
return 2.0f;
float dist = UTIL_DistApprox2D( GetEnemy()->WorldSpaceCenter(), WorldSpaceCenter() );
if ( dist > 512 )
return 16.0f;
//FIXME: Alter by skill level
float yawSpeed = RemapVal( dist, 0, 512, 1.0f, 2.0f );
yawSpeed = clamp( yawSpeed, 1.0f, 2.0f );
return yawSpeed;
}
if ( eActivity == ACT_ANTLIONGUARD_CHARGE_STOP )
return 8.0f;
switch( eActivity )
{
case ACT_TURN_LEFT:
case ACT_TURN_RIGHT:
return 40.0f;
break;
case ACT_RUN:
default:
return 20.0f;
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : flInterval -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_AntlionGuard::OverrideMove( float flInterval )
{
// If the guard's charging, we're handling the movement
if ( IsCurSchedule( SCHED_ANTLIONGUARD_CHARGE ) )
return true;
// TODO: This code increases the guard's ability to successfully hit a target, but adds a new dimension of navigation
// trouble to do with him not being able to "close the distance" between himself and the object he wants to hit.
// Fixing this will require some thought on how he picks the correct distances to his targets and when he's "close enough". -- jdw
/*
if ( m_hPhysicsTarget != NULL )
{
float flWidth = m_hPhysicsTarget->CollisionProp()->BoundingRadius2D();
GetLocalNavigator()->AddObstacle( m_hPhysicsTarget->WorldSpaceCenter(), flWidth * 0.75f, AIMST_AVOID_OBJECT );
//NDebugOverlay::Sphere( m_hPhysicsTarget->WorldSpaceCenter(), vec3_angle, flWidth, 255, 255, 255, 0, true, 0.5f );
}
*/
return BaseClass::OverrideMove( flInterval );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::Shove( void )
{
if ( GetNextAttack() > gpGlobals->curtime )
return;
CBaseEntity *pHurt = NULL;
CBaseEntity *pTarget;
pTarget = ( m_hShoveTarget == NULL ) ? GetEnemy() : m_hShoveTarget.Get();
if ( pTarget == NULL )
{
m_hShoveTarget = NULL;
return;
}
//Always damage bullseyes if we're scripted to hit them
if ( pTarget->Classify() == CLASS_BULLSEYE )
{
pTarget->TakeDamage( CTakeDamageInfo( this, this, 1.0f, DMG_CRUSH ) );
m_hShoveTarget = NULL;
return;
}
float damage = ( pTarget->IsPlayer() ) ? sk_antlionguard_dmg_shove.GetFloat() : 250;
// If the target's still inside the shove cone, ensure we hit him
Vector vecForward, vecEnd;
AngleVectors( GetAbsAngles(), &vecForward );
float flDistSqr = ( pTarget->WorldSpaceCenter() - WorldSpaceCenter() ).LengthSqr();
Vector2D v2LOS = ( pTarget->WorldSpaceCenter() - WorldSpaceCenter() ).AsVector2D();
Vector2DNormalize(v2LOS);
float flDot = DotProduct2D (v2LOS, vecForward.AsVector2D() );
if ( flDistSqr < (ANTLIONGUARD_MELEE1_RANGE*ANTLIONGUARD_MELEE1_RANGE) && flDot >= ANTLIONGUARD_MELEE1_CONE )
{
vecEnd = pTarget->WorldSpaceCenter();
}
else
{
vecEnd = WorldSpaceCenter() + ( BodyDirection3D() * ANTLIONGUARD_MELEE1_RANGE );
}
// Use the melee trace to ensure we hit everything there
trace_t tr;
CTakeDamageInfo dmgInfo( this, this, damage, DMG_SLASH );
CTraceFilterMelee traceFilter( this, COLLISION_GROUP_NONE, &dmgInfo, 1.0, true );
Ray_t ray;
ray.Init( WorldSpaceCenter(), vecEnd, Vector(-16,-16,-16), Vector(16,16,16) );
enginetrace->TraceRay( ray, MASK_SHOT_HULL, &traceFilter, &tr );
pHurt = tr.m_pEnt;
// Knock things around
ImpactShock( tr.endpos, 100.0f, 250.0f );
if ( pHurt )
{
Vector traceDir = ( tr.endpos - tr.startpos );
VectorNormalize( traceDir );
// Generate enough force to make a 75kg guy move away at 600 in/sec
Vector vecForce = traceDir * ImpulseScale( 75, 600 );
CTakeDamageInfo info( this, this, vecForce, tr.endpos, damage, DMG_CLUB );
pHurt->TakeDamage( info );
m_hShoveTarget = NULL;
EmitSound( "NPC_AntlionGuard.Shove" );
// If the player, throw him around
if ( pHurt->IsPlayer() )
{
//Punch the view
pHurt->ViewPunch( QAngle(20,0,-20) );
//Shake the screen
UTIL_ScreenShake( pHurt->GetAbsOrigin(), 100.0, 1.5, 1.0, 2, SHAKE_START );
//Red damage indicator
color32 red = {128,0,0,128};
UTIL_ScreenFade( pHurt, red, 1.0f, 0.1f, FFADE_IN );
Vector forward, up;
AngleVectors( GetLocalAngles(), &forward, NULL, &up );
pHurt->ApplyAbsVelocityImpulse( forward * 400 + up * 150 );
// in the episodes, the cavern guard poisons the player
#if HL2_EPISODIC
// If I am a cavern guard attacking the player, and he still lives, then poison him too.
if ( m_bInCavern && pHurt->IsPlayer() && pHurt->IsAlive() && pHurt->m_iHealth > ANTLIONGUARD_POISON_TO)
{
// That didn't finish them. Take them down to one point with poison damage. It'll heal.
pHurt->TakeDamage( CTakeDamageInfo( this, this, pHurt->m_iHealth - ANTLIONGUARD_POISON_TO, DMG_POISON ) );
}
#endif
}
else
{
CBaseCombatCharacter *pVictim = ToBaseCombatCharacter( pHurt );
if ( pVictim )
{
if ( NPC_Rollermine_IsRollermine( pVictim ) )
{
Pickup_OnPhysGunDrop( pVictim, NULL, LAUNCHED_BY_CANNON );
}
// FIXME: This causes NPCs that are not physically motivated to hop into the air strangely -- jdw
// pVictim->ApplyAbsVelocityImpulse( BodyDirection2D() * 400 + Vector( 0, 0, 250 ) );
}
m_hShoveTarget = NULL;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CTraceFilterCharge : public CTraceFilterEntitiesOnly
{
public:
// It does have a base, but we'll never network anything below here..
DECLARE_CLASS_NOBASE( CTraceFilterCharge );
CTraceFilterCharge( const IHandleEntity *passentity, int collisionGroup, CNPC_AntlionGuard *pAttacker )
: m_pPassEnt(passentity), m_collisionGroup(collisionGroup), m_pAttacker(pAttacker)
{
}
virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
{
if ( !StandardFilterRules( pHandleEntity, contentsMask ) )
return false;
if ( !PassServerEntityFilter( pHandleEntity, m_pPassEnt ) )
return false;
// Don't test if the game code tells us we should ignore this collision...
CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity );
if ( pEntity )
{
if ( !pEntity->ShouldCollide( m_collisionGroup, contentsMask ) )
return false;
if ( !g_pGameRules->ShouldCollide( m_collisionGroup, pEntity->GetCollisionGroup() ) )
return false;
if ( pEntity->m_takedamage == DAMAGE_NO )
return false;
// Translate the vehicle into its driver for damage
if ( pEntity->GetServerVehicle() != NULL )
{
CBaseEntity *pDriver = pEntity->GetServerVehicle()->GetPassenger();
if ( pDriver != NULL )
{
pEntity = pDriver;
}
}
Vector attackDir = pEntity->WorldSpaceCenter() - m_pAttacker->WorldSpaceCenter();
VectorNormalize( attackDir );
float flDamage = ( pEntity->IsPlayer() ) ? sk_antlionguard_dmg_shove.GetFloat() : 250;;
CTakeDamageInfo info( m_pAttacker, m_pAttacker, flDamage, DMG_CRUSH );
CalculateMeleeDamageForce( &info, attackDir, info.GetAttacker()->WorldSpaceCenter(), 4.0f );
CBaseCombatCharacter *pVictimBCC = pEntity->MyCombatCharacterPointer();
// Only do these comparisons between NPCs
if ( pVictimBCC )
{
// Can only damage other NPCs that we hate
if ( m_pAttacker->IRelationType( pEntity ) == D_HT )
{
pEntity->TakeDamage( info );
return true;
}
}
else
{
// Otherwise just damage passive objects in our way
pEntity->TakeDamage( info );
Pickup_ForcePlayerToDropThisObject( pEntity );
}
}
return false;
}
public:
const IHandleEntity *m_pPassEnt;
int m_collisionGroup;
CNPC_AntlionGuard *m_pAttacker;
};
#define MIN_FOOTSTEP_NEAR_DIST Square( 80*12.0f )// ft
//-----------------------------------------------------------------------------
// Purpose: Plays a footstep sound with temporary distance fades
// Input : bHeavy - Larger back hoof is considered a "heavy" step
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::Footstep( bool bHeavy )
{
CBasePlayer *pPlayer = AI_GetSinglePlayer();
Assert( pPlayer != NULL );
if ( pPlayer == NULL )
return;
float flDistanceToPlayerSqr = ( pPlayer->GetAbsOrigin() - GetAbsOrigin() ).LengthSqr();
float flNearVolume = RemapValClamped( flDistanceToPlayerSqr, Square(10*12.0f), MIN_FOOTSTEP_NEAR_DIST, VOL_NORM, 0.0f );
EmitSound_t soundParams;
CPASAttenuationFilter filter( this );
if ( bHeavy )
{
if ( flNearVolume > 0.0f )
{
soundParams.m_pSoundName = "NPC_AntlionGuard.NearStepHeavy";
soundParams.m_flVolume = flNearVolume;
soundParams.m_nFlags = SND_CHANGE_VOL;
EmitSound( filter, entindex(), soundParams );
}
EmitSound( "NPC_AntlionGuard.FarStepHeavy" );
}
else
{
if ( flNearVolume > 0.0f )
{
soundParams.m_pSoundName = "NPC_AntlionGuard.NearStepLight";
soundParams.m_flVolume = flNearVolume;
soundParams.m_nFlags = SND_CHANGE_VOL;
EmitSound( filter, entindex(), soundParams );
}
EmitSound( "NPC_AntlionGuard.FarStepLight" );
}
}
float GetCurrentGravity( void );
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pObject -
// *pOut -
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::GetPhysicsShoveDir( CBaseEntity *pObject, float flMass, Vector *pOut )
{
const Vector vecStart = pObject->WorldSpaceCenter();
const Vector vecTarget = GetEnemy()->WorldSpaceCenter();
const float flBaseSpeed = 800.0f;
float flSpeed = RemapValClamped( flMass, 0.0f, 150.0f, flBaseSpeed * 2.0f, flBaseSpeed );
// Try the most direct route
Vector vecToss = VecCheckThrow( this, vecStart, vecTarget, flSpeed, 1.0f );
// If this failed then try a little faster (flattens the arc)
if ( vecToss == vec3_origin )
{
vecToss = VecCheckThrow( this, vecStart, vecTarget, flSpeed * 1.25f, 1.0f );
if ( vecToss == vec3_origin )
{
const float flGravity = GetCurrentGravity();
vecToss = (vecTarget - vecStart);
// throw at a constant time
float time = vecToss.Length( ) / flSpeed;
vecToss = vecToss * (1.0f / time);
// adjust upward toss to compensate for gravity loss
vecToss.z += flGravity * time * 0.5f;
}
}
// Save out the result
if ( pOut )
{
*pOut = vecToss;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pEvent -
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::HandleAnimEvent( animevent_t *pEvent )
{
if ( pEvent->event == AE_ANTLIONGUARD_CHARGE_EARLYOUT )
{
// Robin: Removed this because it usually made him look less intelligent, not more.
// This code left here so we don't get warnings in the console.
/*
// Cancel the charge if it's no longer valid
if ( ShouldCharge( GetAbsOrigin(), GetEnemy()->GetAbsOrigin(), false, true ) == false )
{
SetSchedule( SCHED_ANTLIONGUARD_CHARGE_CANCEL );
}
*/
return;
}
// Don't handle anim events after death
if ( m_NPCState == NPC_STATE_DEAD )
{
BaseClass::HandleAnimEvent( pEvent );
return;
}
if ( pEvent->event == AE_ANTLIONGUARD_SHOVE_PHYSOBJECT )
{
if ( m_hPhysicsTarget == NULL )
{
// Disrupt other objects near us anyway
ImpactShock( WorldSpaceCenter(), 150, 250.0f );
return;
}
// If we have no enemy, we don't really have a direction to throw the object
// in. But, we still want to clobber it so the animevent doesn't happen fruitlessly,
// and we want to clear the condition flags and other state regarding the m_hPhysicsTarget.
// So, skip the code relevant to computing a launch vector specific to the object I'm
// striking, but use the ImpactShock call further below to punch everything in the neighborhood.
CBaseEntity *pEnemy = GetEnemy();
if ( pEnemy != NULL )
{
//Setup the throw velocity
IPhysicsObject *physObj = m_hPhysicsTarget->VPhysicsGetObject();
Vector vecShoveVel = ( pEnemy->GetAbsOrigin() - m_hPhysicsTarget->WorldSpaceCenter() );
float flTargetDist = VectorNormalize( vecShoveVel );
// Must still be close enough to our target
Vector shoveDir = m_hPhysicsTarget->WorldSpaceCenter() - WorldSpaceCenter();
float shoveDist = VectorNormalize( shoveDir );
if ( shoveDist > 300.0f )
{
// Pick a new target next time (this one foiled us!)
RememberFailedPhysicsTarget( m_hPhysicsTarget );
m_hPhysicsTarget = NULL;
return;
}
// Toss this if we're episodic
if ( hl2_episodic.GetBool() )
{
Vector vecTargetDir = vecShoveVel;
// Get our shove direction
GetPhysicsShoveDir( m_hPhysicsTarget, physObj->GetMass(), &vecShoveVel );
// If the player isn't looking at me, and isn't reachable, be more forgiving about hitting them
if ( HasCondition( COND_ENEMY_UNREACHABLE ) && HasCondition( COND_ENEMY_FACING_ME ) == false )
{
// Build an arc around the top of the target that we'll offset our aim by
Vector vecOffset;
float flSin, flCos;
float flRad = random->RandomFloat( 0, M_PI / 6.0f ); // +/- 30 deg
if ( random->RandomInt( 0, 1 ) )
flRad *= -1.0f;
SinCos( flRad, &flSin, &flCos );
// Rotate the 2-d circle to be "facing" along our shot direction
Vector vecArc;
QAngle vecAngles;
VectorAngles( vecTargetDir, vecAngles );
VectorRotate( Vector( 0.0f, flCos, flSin ), vecAngles, vecArc );
// Find the radius by which to avoid the player
float flOffsetRadius = ( m_hPhysicsTarget->CollisionProp()->BoundingRadius() + GetEnemy()->CollisionProp()->BoundingRadius() ) * 1.5f;
// Add this to our velocity to offset it
vecShoveVel += ( vecArc * flOffsetRadius );
}
// Factor out mass
vecShoveVel *= physObj->GetMass();
// FIXME: We need to restore this on the object at some point if we do this!
float flDragCoef = 0.0f;
physObj->SetDragCoefficient( &flDragCoef, &flDragCoef );
}
else
{
if ( flTargetDist < 512 )
flTargetDist = 512;
if ( flTargetDist > 1024 )
flTargetDist = 1024;
vecShoveVel *= flTargetDist * 3 * physObj->GetMass(); //FIXME: Scale by skill
vecShoveVel[2] += physObj->GetMass() * 350.0f;
}
if ( NPC_Rollermine_IsRollermine( m_hPhysicsTarget ) )
{
Pickup_OnPhysGunDrop( m_hPhysicsTarget, NULL, LAUNCHED_BY_CANNON );
}
//Send it flying
AngularImpulse angVel( random->RandomFloat(-180, 180), 100, random->RandomFloat(-360, 360) );
physObj->ApplyForceCenter( vecShoveVel );
physObj->AddVelocity( NULL, &angVel );
}
//Display dust
Vector vecRandom = RandomVector( -1, 1);
VectorNormalize( vecRandom );
g_pEffects->Dust( m_hPhysicsTarget->WorldSpaceCenter(), vecRandom, 64.0f, 32 );
// If it's being held by the player, break that bond
Pickup_ForcePlayerToDropThisObject( m_hPhysicsTarget );
EmitSound( "NPC_AntlionGuard.HitHard" );
//Clear the state information, we're done
ClearCondition( COND_ANTLIONGUARD_PHYSICS_TARGET );
ClearCondition( COND_ANTLIONGUARD_PHYSICS_TARGET_INVALID );
// Disrupt other objects near it, including the m_hPhysicsTarget if we had no valid enemy
ImpactShock( m_hPhysicsTarget->WorldSpaceCenter(), 150, 250.0f, pEnemy != NULL ? m_hPhysicsTarget : NULL );
// Notify any squad members that we're no longer monopolizing this object
if ( GetSquad() != NULL )
{
GetSquad()->BroadcastInteraction( g_interactionAntlionGuardShovedPhysicsObject, (void *)((CBaseEntity *)m_hPhysicsTarget), this );
}
m_hPhysicsTarget = NULL;
m_FailedPhysicsTargets.RemoveAll();
return;
}
if ( pEvent->event == AE_ANTLIONGUARD_CHARGE_HIT )
{
UTIL_ScreenShake( GetAbsOrigin(), 32.0f, 4.0f, 1.0f, 512, SHAKE_START );
EmitSound( "NPC_AntlionGuard.HitHard" );
Vector startPos = GetAbsOrigin();
float checkSize = ( CollisionProp()->BoundingRadius() + 8.0f );
Vector endPos = startPos + ( BodyDirection3D() * checkSize );
CTraceFilterCharge traceFilter( this, COLLISION_GROUP_NONE, this );
Ray_t ray;
ray.Init( startPos, endPos, GetHullMins(), GetHullMaxs() );
trace_t tr;
enginetrace->TraceRay( ray, MASK_SHOT, &traceFilter, &tr );
if ( g_debug_antlionguard.GetInt() == 1 )
{
Vector hullMaxs = GetHullMaxs();
hullMaxs.x += checkSize;
NDebugOverlay::BoxDirection( startPos, GetHullMins(), hullMaxs, BodyDirection2D(), 100, 255, 255, 20, 1.0f );
}
//NDebugOverlay::Box3D( startPos, endPos, BodyDirection2D(),
if ( m_hChargeTarget && m_hChargeTarget->IsAlive() == false )
{
m_hChargeTarget = NULL;
m_hChargeTargetPosition = NULL;
}
// Cause a shock wave from this point which will distrupt nearby physics objects
ImpactShock( tr.endpos, 200, 500 );
return;
}
if ( pEvent->event == AE_ANTLIONGUARD_SHOVE )
{
EmitSound("NPC_AntlionGuard.StepLight", pEvent->eventtime );
Shove();
return;
}
if ( pEvent->event == AE_ANTLIONGUARD_FOOTSTEP_LIGHT )
{
if ( HasSpawnFlags(SF_ANTLIONGUARD_INSIDE_FOOTSTEPS) )
{
#if HL2_EPISODIC
Footstep( false );
#else
EmitSound("NPC_AntlionGuard.Inside.StepLight", pEvent->eventtime );
#endif // HL2_EPISODIC
}
else
{
#if HL2_EPISODIC
Footstep( false );
#else
EmitSound("NPC_AntlionGuard.StepLight", pEvent->eventtime );
#endif // HL2_EPISODIC
}
return;
}
if ( pEvent->event == AE_ANTLIONGUARD_FOOTSTEP_HEAVY )
{
if ( HasSpawnFlags(SF_ANTLIONGUARD_INSIDE_FOOTSTEPS) )
{
#if HL2_EPISODIC
Footstep( true );
#else
EmitSound( "NPC_AntlionGuard.Inside.StepHeavy", pEvent->eventtime );
#endif // HL2_EPISODIC
}
else
{
#if HL2_EPISODIC
Footstep( true );
#else
EmitSound( "NPC_AntlionGuard.StepHeavy", pEvent->eventtime );
#endif // HL2_EPISODIC
}
return;
}
if ( pEvent->event == AE_ANTLIONGUARD_VOICE_GROWL )
{
StartSounds();
float duration = 0.0f;
if ( random->RandomInt( 0, 10 ) < 6 )
{
duration = ENVELOPE_CONTROLLER.SoundPlayEnvelope( m_pGrowlHighSound, SOUNDCTRL_CHANGE_VOLUME, envAntlionGuardFastGrowl, ARRAYSIZE(envAntlionGuardFastGrowl) );
}
else
{
duration = 1.0f;
EmitSound( "NPC_AntlionGuard.FrustratedRoar" );
ENVELOPE_CONTROLLER.SoundFadeOut( m_pGrowlHighSound, 0.5f, false );
}
m_flAngerNoiseTime = gpGlobals->curtime + duration + random->RandomFloat( 2.0f, 4.0f );
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pBreathSound, 0.0f, 0.1f );
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pGrowlIdleSound, 0.0f, 0.1f );
m_flBreathTime = gpGlobals->curtime + duration - 0.2f;
EmitSound( "NPC_AntlionGuard.Anger" );
return;
}
if ( pEvent->event == AE_ANTLIONGUARD_VOICE_BARK )
{
StartSounds();
float duration = ENVELOPE_CONTROLLER.SoundPlayEnvelope( m_pGrowlHighSound, SOUNDCTRL_CHANGE_VOLUME, envAntlionGuardBark1, ARRAYSIZE(envAntlionGuardBark1) );
ENVELOPE_CONTROLLER.SoundPlayEnvelope( m_pConfusedSound, SOUNDCTRL_CHANGE_VOLUME, envAntlionGuardBark2, ARRAYSIZE(envAntlionGuardBark2) );
m_flAngerNoiseTime = gpGlobals->curtime + duration + random->RandomFloat( 2.0f, 4.0f );
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pBreathSound, 0.0f, 0.1f );
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pGrowlIdleSound, 0.0f, 0.1f );
m_flBreathTime = gpGlobals->curtime + duration - 0.2f;
return;
}
if ( pEvent->event == AE_ANTLIONGUARD_VOICE_ROAR )
{
StartSounds();
float duration = ENVELOPE_CONTROLLER.SoundPlayEnvelope( m_pGrowlHighSound, SOUNDCTRL_CHANGE_VOLUME, envAntlionGuardFastGrowl, ARRAYSIZE(envAntlionGuardFastGrowl) );
m_flAngerNoiseTime = gpGlobals->curtime + duration + random->RandomFloat( 2.0f, 4.0f );
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pBreathSound, 0.0f, 0.1f );
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pGrowlIdleSound, 0.0f, 0.1f );
m_flBreathTime = gpGlobals->curtime + duration - 0.2f;
EmitSound( "NPC_AntlionGuard.Roar" );
return;
}
if ( pEvent->event == AE_ANTLIONGUARD_VOICE_PAIN )
{
StartSounds();
float duration = ENVELOPE_CONTROLLER.SoundPlayEnvelope( m_pConfusedSound, SOUNDCTRL_CHANGE_VOLUME, envAntlionGuardPain1, ARRAYSIZE(envAntlionGuardPain1) );
ENVELOPE_CONTROLLER.SoundPlayEnvelope( m_pGrowlHighSound, SOUNDCTRL_CHANGE_VOLUME, envAntlionGuardBark2, ARRAYSIZE(envAntlionGuardBark2) );
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pBreathSound, 0.0f, 0.1f );
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pGrowlIdleSound, 0.0f, 0.1f );
m_flBreathTime = gpGlobals->curtime + duration - 0.2f;
return;
}
if ( pEvent->event == AE_ANTLIONGUARD_VOICE_SQUEEZE )
{
StartSounds();
float duration = ENVELOPE_CONTROLLER.SoundPlayEnvelope( m_pGrowlHighSound, SOUNDCTRL_CHANGE_VOLUME, envAntlionGuardSqueeze, ARRAYSIZE(envAntlionGuardSqueeze) );
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pBreathSound, 0.6f, random->RandomFloat( 2.0f, 4.0f ) );
ENVELOPE_CONTROLLER.SoundChangePitch( m_pBreathSound, random->RandomInt( 60, 80 ), random->RandomFloat( 2.0f, 4.0f ) );
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pGrowlIdleSound, 0.0f, 0.1f );
m_flBreathTime = gpGlobals->curtime + ( duration * 0.5f );
EmitSound( "NPC_AntlionGuard.Anger" );
return;
}
if ( pEvent->event == AE_ANTLIONGUARD_VOICE_SCRATCH )
{
StartSounds();
float duration = random->RandomFloat( 2.0f, 4.0f );
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pBreathSound, 0.6f, duration );
ENVELOPE_CONTROLLER.SoundChangePitch( m_pBreathSound, random->RandomInt( 60, 80 ), duration );
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pGrowlIdleSound, 0.0f, 0.1f );
m_flBreathTime = gpGlobals->curtime + duration;
EmitSound( "NPC_AntlionGuard.Anger" );
return;
}
if ( pEvent->event == AE_ANTLIONGUARD_VOICE_GRUNT )
{
StartSounds();
float duration = ENVELOPE_CONTROLLER.SoundPlayEnvelope( m_pConfusedSound, SOUNDCTRL_CHANGE_VOLUME, envAntlionGuardGrunt, ARRAYSIZE(envAntlionGuardGrunt) );
ENVELOPE_CONTROLLER.SoundPlayEnvelope( m_pGrowlHighSound, SOUNDCTRL_CHANGE_VOLUME, envAntlionGuardGrunt2, ARRAYSIZE(envAntlionGuardGrunt2) );
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pBreathSound, 0.0f, 0.1f );
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pGrowlIdleSound, 0.0f, 0.1f );
m_flBreathTime = gpGlobals->curtime + duration;
return;
}
if ( pEvent->event == AE_ANTLIONGUARD_BURROW_OUT )
{
EmitSound( "NPC_Antlion.BurrowOut" );
//Shake the screen
UTIL_ScreenShake( GetAbsOrigin(), 0.5f, 80.0f, 1.0f, 256.0f, SHAKE_START );
//Throw dust up
UTIL_CreateAntlionDust( GetAbsOrigin() + Vector(0,0,24), GetLocalAngles() );
RemoveEffects( EF_NODRAW );
RemoveFlag( FL_NOTARGET );
if ( m_bCavernBreed )
{
if ( m_hCaveGlow[0] )
m_hCaveGlow[0]->TurnOn();
if ( m_hCaveGlow[1] )
m_hCaveGlow[1]->TurnOn();
}
return;
}
BaseClass::HandleAnimEvent( pEvent );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::SetHeavyDamageAnim( const Vector &vecSource )
{
if ( !m_bInCavern )
{
Vector vFacing = BodyDirection2D();
Vector vDamageDir = ( vecSource - WorldSpaceCenter() );
vDamageDir.z = 0.0f;
VectorNormalize( vDamageDir );
Vector vDamageRight, vDamageUp;
VectorVectors( vDamageDir, vDamageRight, vDamageUp );
float damageDot = DotProduct( vFacing, vDamageDir );
float damageRightDot = DotProduct( vFacing, vDamageRight );
// See if it's in front
if ( damageDot > 0.0f )
{
// See if it's right
if ( damageRightDot > 0.0f )
{
m_nFlinchActivity = ACT_ANTLIONGUARD_PHYSHIT_FR;
}
else
{
m_nFlinchActivity = ACT_ANTLIONGUARD_PHYSHIT_FL;
}
}
else
{
// Otherwise it's from behind
if ( damageRightDot < 0.0f )
{
m_nFlinchActivity = ACT_ANTLIONGUARD_PHYSHIT_RR;
}
else
{
m_nFlinchActivity = ACT_ANTLIONGUARD_PHYSHIT_RL;
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &info -
//-----------------------------------------------------------------------------
int CNPC_AntlionGuard::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
CTakeDamageInfo dInfo = info;
// Don't take damage from another antlion guard!
if ( dInfo.GetAttacker() && dInfo.GetAttacker() != this && FClassnameIs( dInfo.GetAttacker(), "npc_antlionguard" ) )
return 0;
if ( ( dInfo.GetDamageType() & DMG_CRUSH ) && !( dInfo.GetDamageType() & DMG_VEHICLE ) )
{
// Don't take damage from physics objects that weren't thrown by the player.
CBaseEntity *pInflictor = dInfo.GetInflictor();
IPhysicsObject *pObj = pInflictor->VPhysicsGetObject();
if ( !pObj || !( pObj->GetGameFlags() & FVPHYSICS_WAS_THROWN ) )
{
return 0;
}
}
// Hack to make antlion guard harder in HARD
if ( g_pGameRules->IsSkillLevel(SKILL_HARD) && !(info.GetDamageType() & DMG_CRUSH) )
{
dInfo.SetDamage( dInfo.GetDamage() * 0.75 );
}
// Cap damage taken by crushing (otherwise we can get crushed oddly)
if ( ( dInfo.GetDamageType() & DMG_CRUSH ) && dInfo.GetDamage() > 100 )
{
dInfo.SetDamage( 100 );
}
// Only take damage from what we classify as heavy damages (explosions, refrigerators, etc)
if ( IsHeavyDamage( dInfo ) )
{
// Always take a set amount of damage from a combine ball
if ( info.GetInflictor() && UTIL_IsCombineBall( info.GetInflictor() ) )
{
dInfo.SetDamage( 50 );
}
UTIL_ScreenShake( GetAbsOrigin(), 32.0f, 8.0f, 0.5f, 512, SHAKE_START );
// Set our response animation
SetHeavyDamageAnim( dInfo.GetDamagePosition() );
// Explosive barrels don't carry through their attacker, so this
// condition isn't set, and we still want to flinch. So we set it.
SetCondition( COND_HEAVY_DAMAGE );
// TODO: Make this its own effect!
CEffectData data;
data.m_vOrigin = dInfo.GetDamagePosition();
data.m_vNormal = -dInfo.GetDamageForce();
VectorNormalize( data.m_vNormal );
DispatchEffect( "HunterDamage", data );
// Play a sound for a physics impact
if ( dInfo.GetDamageType() & DMG_CRUSH )
{
EmitSound("NPC_AntlionGuard.ShellCrack");
}
// Roar in pain
EmitSound( "NPC_AntlionGuard.Pain_Roar" );
// TODO: This will require a more complete solution; for now let's shelve it!
/*
if ( dInfo.GetDamageType() & DMG_BLAST )
{
// Create the dust effect in place
CParticleSystem *pParticle = (CParticleSystem *) CreateEntityByName( "info_particle_system" );
if ( pParticle != NULL )
{
// Setup our basic parameters
pParticle->KeyValue( "start_active", "1" );
pParticle->KeyValue( "effect_name", "fire_medium_02_nosmoke" );
pParticle->SetParent( this );
pParticle->SetParentAttachment( "SetParentAttachment", "attach_glow2", true );
pParticle->SetLocalOrigin( Vector( -16, 24, 0 ) );
DispatchSpawn( pParticle );
if ( gpGlobals->curtime > 0.5f )
pParticle->Activate();
pParticle->SetThink( &CBaseEntity::SUB_Remove );
pParticle->SetNextThink( gpGlobals->curtime + random->RandomFloat( 2.0f, 3.0f ) );
}
}
*/
}
int nPreHealth = GetHealth();
int nDamageTaken = BaseClass::OnTakeDamage_Alive( dInfo );
// See if we've crossed a measured phase in our health and flinch from that to show we do take damage
if ( !m_bInCavern && HasCondition( COND_HEAVY_DAMAGE ) == false && ( info.GetDamageType() & DMG_BULLET ) )
{
bool bTakeHeavyDamage = false;
// Do an early flinch so that players understand the guard can be hurt by
if ( ( (float) GetHealth() / (float) GetMaxHealth() ) > 0.9f )
{
float flPrePerc = (float) nPreHealth / (float) GetMaxHealth();
float flPostPerc = (float) GetHealth() / (float) GetMaxHealth();
if ( flPrePerc >= 0.95f && flPostPerc < 0.95f )
{
bTakeHeavyDamage = true;
}
}
// Otherwise see if we've passed a measured point in our health
if ( bTakeHeavyDamage == false )
{
const float flNumDamagePhases = 5.0f;
float flDenom = ( (float) GetMaxHealth() / flNumDamagePhases );
int nPreDamagePhase = ceil( (float) nPreHealth / flDenom );
int nPostDamagePhase = ceil( (float) GetHealth() / flDenom );
if ( nPreDamagePhase != nPostDamagePhase )
{
bTakeHeavyDamage = true;
}
}
// Flinch if we should
if ( bTakeHeavyDamage )
{
// Set our response animation
SetHeavyDamageAnim( dInfo.GetDamagePosition() );
// Roar in pain
EmitSound( "NPC_AntlionGuard.Pain_Roar" );
// Flinch!
SetCondition( COND_HEAVY_DAMAGE );
}
}
return nDamageTaken;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pAttacker -
// flDamage -
// &vecDir -
// *ptr -
// bitsDamageType -
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::TraceAttack( const CTakeDamageInfo &inputInfo, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
{
CTakeDamageInfo info = inputInfo;
// Bullets are weak against us, buckshot less so
if ( info.GetDamageType() & DMG_BUCKSHOT )
{
info.ScaleDamage( 0.5f );
}
else if ( info.GetDamageType() & DMG_BULLET )
{
info.ScaleDamage( 0.25f );
}
// Make sure we haven't rounded down to a minimal amount
if ( info.GetDamage() < 1.0f )
{
info.SetDamage( 1.0f );
}
BaseClass::TraceAttack( info, vecDir, ptr, pAccumulator );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pTask -
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::StartTask( const Task_t *pTask )
{
switch ( pTask->iTask )
{
case TASK_ANTLIONGUARD_SET_FLINCH_ACTIVITY:
SetIdealActivity( (Activity) m_nFlinchActivity );
break;
case TASK_ANTLIONGUARD_SUMMON:
SummonAntlions();
m_OnSummon.FireOutput( this, this, 0 );
TaskComplete();
break;
case TASK_ANTLIONGUARD_SHOVE_PHYSOBJECT:
{
if ( ( m_hPhysicsTarget == NULL ) || ( GetEnemy() == NULL ) )
{
TaskFail( "Tried to shove a NULL physics target!\n" );
break;
}
//Get the direction and distance to our thrown object
Vector dirToTarget = ( m_hPhysicsTarget->WorldSpaceCenter() - WorldSpaceCenter() );
float distToTarget = VectorNormalize( dirToTarget );
dirToTarget.z = 0;
//Validate it's still close enough to shove
//FIXME: Real numbers
if ( distToTarget > 256.0f )
{
RememberFailedPhysicsTarget( m_hPhysicsTarget );
m_hPhysicsTarget = NULL;
TaskFail( "Shove target moved\n" );
break;
}
//Validate its offset from our facing
float targetYaw = UTIL_VecToYaw( dirToTarget );
float offset = UTIL_AngleDiff( targetYaw, UTIL_AngleMod( GetLocalAngles().y ) );
if ( fabs( offset ) > 55 )
{
RememberFailedPhysicsTarget( m_hPhysicsTarget );
m_hPhysicsTarget = NULL;
TaskFail( "Shove target off-center\n" );
break;
}
//Blend properly
SetPoseParameter( m_poseThrow, offset );
//Start playing the animation
SetActivity( ACT_ANTLIONGUARD_SHOVE_PHYSOBJECT );
}
break;
case TASK_ANTLIONGUARD_FIND_PHYSOBJECT:
{
if ( m_bInCavern && !m_bPreferPhysicsAttack )
{
TaskFail( "Cavern guard is not allowed to use physics attacks." );
}
// Force the antlion guard to find a physobject
m_flPhysicsCheckTime = 0;
UpdatePhysicsTarget( false, (100*12) );
if ( m_hPhysicsTarget )
{
TaskComplete();
}
else
{
TaskFail( "Failed to find a physobject.\n" );
}
}
break;
case TASK_ANTLIONGUARD_GET_PATH_TO_PHYSOBJECT:
{
if ( ( m_hPhysicsTarget == NULL ) || ( GetEnemy() == NULL ) )
{
TaskFail( "Tried to find a path to NULL physics target!\n" );
break;
}
Vector vecGoalPos = m_vecPhysicsHitPosition;
AI_NavGoal_t goal( GOALTYPE_LOCATION, vecGoalPos, ACT_RUN );
if ( GetNavigator()->SetGoal( goal ) )
{
if ( g_debug_antlionguard.GetInt() == 1 )
{
NDebugOverlay::Cross3D( vecGoalPos, Vector(8,8,8), -Vector(8,8,8), 0, 255, 0, true, 2.0f );
NDebugOverlay::Line( vecGoalPos, m_hPhysicsTarget->WorldSpaceCenter(), 0, 255, 0, true, 2.0f );
NDebugOverlay::Line( m_hPhysicsTarget->WorldSpaceCenter(), GetEnemy()->WorldSpaceCenter(), 0, 255, 0, true, 2.0f );
}
// Face the enemy
GetNavigator()->SetArrivalDirection( GetEnemy() );
TaskComplete();
}
else
{
if ( g_debug_antlionguard.GetInt() == 1 )
{
NDebugOverlay::Cross3D( vecGoalPos, Vector(8,8,8), -Vector(8,8,8), 255, 0, 0, true, 2.0f );
NDebugOverlay::Line( vecGoalPos, m_hPhysicsTarget->WorldSpaceCenter(), 255, 0, 0, true, 2.0f );
NDebugOverlay::Line( m_hPhysicsTarget->WorldSpaceCenter(), GetEnemy()->WorldSpaceCenter(), 255, 0, 0, true, 2.0f );
}
RememberFailedPhysicsTarget( m_hPhysicsTarget );
m_hPhysicsTarget = NULL;
TaskFail( "Unable to navigate to physics attack target!\n" );
break;
}
//!!!HACKHACK - this is a hack that covers a bug in antlion guard physics target selection! (Tracker #77601)
// This piece of code (combined with some code in GatherConditions) COVERS THE BUG by escaping the schedule
// if 30 seconds have passed (it should never take this long for the guard to get to an object and hit it).
// It's too scary to figure out why this particular antlion guard can't get to its object, but we're shipping
// like, tomorrow. (sjb) 8/22/2007
m_flWaitFinished = gpGlobals->curtime + 30.0f;
}
break;
case TASK_ANTLIONGUARD_CHARGE:
{
// HACK: Because the guard stops running his normal blended movement
// here, he also needs to remove his blended movement layers!
GetMotor()->MoveStop();
SetActivity( ACT_ANTLIONGUARD_CHARGE_START );
m_bDecidedNotToStop = false;
}
break;
case TASK_ANTLIONGUARD_GET_PATH_TO_CHARGE_POSITION:
{
if ( !m_hChargeTargetPosition )
{
TaskFail( "Tried to find a charge position without one specified.\n" );
break;
}
// Move to the charge position
AI_NavGoal_t goal( GOALTYPE_LOCATION, m_hChargeTargetPosition->GetAbsOrigin(), ACT_RUN );
if ( GetNavigator()->SetGoal( goal ) )
{
// We want to face towards the charge target
Vector vecDir = m_hChargeTarget->GetAbsOrigin() - m_hChargeTargetPosition->GetAbsOrigin();
VectorNormalize( vecDir );
vecDir.z = 0;
GetNavigator()->SetArrivalDirection( vecDir );
TaskComplete();
}
else
{
m_hChargeTarget = NULL;
m_hChargeTargetPosition = NULL;
TaskFail( FAIL_NO_ROUTE );
}
}
break;
case TASK_ANTLIONGUARD_GET_PATH_TO_NEAREST_NODE:
{
if ( !GetEnemy() )
{
TaskFail( FAIL_NO_ENEMY );
break;
}
// Find the nearest node to the enemy
int node = GetNavigator()->GetNetwork()->NearestNodeToPoint( this, GetEnemy()->GetAbsOrigin(), false );
CAI_Node *pNode = GetNavigator()->GetNetwork()->GetNode( node );
if( pNode == NULL )
{
TaskFail( FAIL_NO_ROUTE );
break;
}
Vector vecNodePos = pNode->GetPosition( GetHullType() );
AI_NavGoal_t goal( GOALTYPE_LOCATION, vecNodePos, ACT_RUN );
if ( GetNavigator()->SetGoal( goal ) )
{
GetNavigator()->SetArrivalDirection( GetEnemy() );
TaskComplete();
break;
}
TaskFail( FAIL_NO_ROUTE );
break;
}
break;
case TASK_ANTLIONGUARD_GET_CHASE_PATH_ENEMY_TOLERANCE:
{
// Chase the enemy, but allow local navigation to succeed if it gets within the goal tolerance
GetNavigator()->SetLocalSucceedOnWithinTolerance( true );
if ( GetNavigator()->SetGoal( GOALTYPE_ENEMY ) )
{
TaskComplete();
}
else
{
RememberUnreachable(GetEnemy());
TaskFail(FAIL_NO_ROUTE);
}
GetNavigator()->SetLocalSucceedOnWithinTolerance( false );
}
break;
case TASK_ANTLIONGUARD_OPPORTUNITY_THROW:
{
// If we've got some live antlions, look for a physics object to throw
if ( m_iNumLiveAntlions >= 2 && RandomFloat(0,1) > 0.5 )
{
m_FailedPhysicsTargets.RemoveAll();
UpdatePhysicsTarget( false, m_bPreferPhysicsAttack ? (100*12) : ANTLIONGUARD_FARTHEST_PHYSICS_OBJECT );
if ( HasCondition( COND_ANTLIONGUARD_PHYSICS_TARGET ) && !m_bInCavern )
{
SetSchedule( SCHED_ANTLIONGUARD_PHYSICS_ATTACK );
}
}
TaskComplete();
}
break;
default:
BaseClass::StartTask(pTask);
break;
}
}
//-----------------------------------------------------------------------------
// Purpose: Calculate & apply damage & force for a charge to a target.
// Done outside of the guard because we need to do this inside a trace filter.
//-----------------------------------------------------------------------------
void ApplyChargeDamage( CBaseEntity *pAntlionGuard, CBaseEntity *pTarget, float flDamage )
{
Vector attackDir = ( pTarget->WorldSpaceCenter() - pAntlionGuard->WorldSpaceCenter() );
VectorNormalize( attackDir );
Vector offset = RandomVector( -32, 32 ) + pTarget->WorldSpaceCenter();
// Generate enough force to make a 75kg guy move away at 700 in/sec
Vector vecForce = attackDir * ImpulseScale( 75, 700 );
// Deal the damage
CTakeDamageInfo info( pAntlionGuard, pAntlionGuard, vecForce, offset, flDamage, DMG_CLUB );
pTarget->TakeDamage( info );
#if HL2_EPISODIC
// If I am a cavern guard attacking the player, and he still lives, then poison him too.
Assert( dynamic_cast<CNPC_AntlionGuard *>(pAntlionGuard) );
if ( static_cast<CNPC_AntlionGuard *>(pAntlionGuard)->IsInCavern() && pTarget->IsPlayer() && pTarget->IsAlive() && pTarget->m_iHealth > ANTLIONGUARD_POISON_TO)
{
// That didn't finish them. Take them down to one point with poison damage. It'll heal.
pTarget->TakeDamage( CTakeDamageInfo( pAntlionGuard, pAntlionGuard, pTarget->m_iHealth - ANTLIONGUARD_POISON_TO, DMG_POISON ) );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: A simple trace filter class to skip small moveable physics objects
//-----------------------------------------------------------------------------
class CTraceFilterSkipPhysics : public CTraceFilter
{
public:
// It does have a base, but we'll never network anything below here..
DECLARE_CLASS_NOBASE( CTraceFilterSkipPhysics );
CTraceFilterSkipPhysics( const IHandleEntity *passentity, int collisionGroup, float minMass )
: m_pPassEnt(passentity), m_collisionGroup(collisionGroup), m_minMass(minMass)
{
}
virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
{
if ( !StandardFilterRules( pHandleEntity, contentsMask ) )
return false;
if ( !PassServerEntityFilter( pHandleEntity, m_pPassEnt ) )
return false;
// Don't test if the game code tells us we should ignore this collision...
CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity );
if ( pEntity )
{
if ( !pEntity->ShouldCollide( m_collisionGroup, contentsMask ) )
return false;
if ( !g_pGameRules->ShouldCollide( m_collisionGroup, pEntity->GetCollisionGroup() ) )
return false;
// don't test small moveable physics objects (unless it's an NPC)
if ( !pEntity->IsNPC() && pEntity->GetMoveType() == MOVETYPE_VPHYSICS )
{
IPhysicsObject *pPhysics = pEntity->VPhysicsGetObject();
Assert(pPhysics);
if ( pPhysics->IsMoveable() && pPhysics->GetMass() < m_minMass )
return false;
}
// If we hit an antlion, don't stop, but kill it
if ( pEntity->Classify() == CLASS_ANTLION )
{
CBaseEntity *pGuard = (CBaseEntity*)EntityFromEntityHandle( m_pPassEnt );
ApplyChargeDamage( pGuard, pEntity, pEntity->GetHealth() );
return false;
}
}
return true;
}
private:
const IHandleEntity *m_pPassEnt;
int m_collisionGroup;
float m_minMass;
};
inline void TraceHull_SkipPhysics( const Vector &vecAbsStart, const Vector &vecAbsEnd, const Vector &hullMin,
const Vector &hullMax, unsigned int mask, const CBaseEntity *ignore,
int collisionGroup, trace_t *ptr, float minMass )
{
Ray_t ray;
ray.Init( vecAbsStart, vecAbsEnd, hullMin, hullMax );
CTraceFilterSkipPhysics traceFilter( ignore, collisionGroup, minMass );
enginetrace->TraceRay( ray, mask, &traceFilter, ptr );
}
//-----------------------------------------------------------------------------
// Purpose: Return true if our charge target is right in front of the guard
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_AntlionGuard::EnemyIsRightInFrontOfMe( CBaseEntity **pEntity )
{
if ( !GetEnemy() )
return false;
if ( (GetEnemy()->WorldSpaceCenter() - WorldSpaceCenter()).LengthSqr() < (156*156) )
{
Vector vecLOS = ( GetEnemy()->GetAbsOrigin() - GetAbsOrigin() );
vecLOS.z = 0;
VectorNormalize( vecLOS );
Vector vBodyDir = BodyDirection2D();
if ( DotProduct( vecLOS, vBodyDir ) > 0.8 )
{
// He's in front of me, and close. Make sure he's not behind a wall.
trace_t tr;
UTIL_TraceLine( WorldSpaceCenter(), GetEnemy()->EyePosition(), MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
if ( tr.m_pEnt == GetEnemy() )
{
*pEntity = tr.m_pEnt;
return true;
}
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: While charging, look ahead and see if we're going to run into anything.
// If we are, start the gesture so it looks like we're anticipating the hit.
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::ChargeLookAhead( void )
{
trace_t tr;
Vector vecForward;
GetVectors( &vecForward, NULL, NULL );
Vector vecTestPos = GetAbsOrigin() + ( vecForward * m_flGroundSpeed * 0.75 );
Vector testHullMins = GetHullMins();
testHullMins.z += (StepHeight() * 2);
TraceHull_SkipPhysics( GetAbsOrigin(), vecTestPos, testHullMins, GetHullMaxs(), MASK_SHOT_HULL, this, COLLISION_GROUP_NONE, &tr, VPhysicsGetObject()->GetMass() * 0.5 );
//NDebugOverlay::Box( tr.startpos, testHullMins, GetHullMaxs(), 0, 255, 0, true, 0.1f );
//NDebugOverlay::Box( vecTestPos, testHullMins, GetHullMaxs(), 255, 0, 0, true, 0.1f );
if ( tr.fraction != 1.0 )
{
// Start playing the hit animation
AddGesture( ACT_ANTLIONGUARD_CHARGE_ANTICIPATION );
}
}
//-----------------------------------------------------------------------------
// Purpose: Handles the guard charging into something. Returns true if it hit the world.
//-----------------------------------------------------------------------------
bool CNPC_AntlionGuard::HandleChargeImpact( Vector vecImpact, CBaseEntity *pEntity )
{
// Cause a shock wave from this point which will disrupt nearby physics objects
ImpactShock( vecImpact, 128, 350 );
// Did we hit anything interesting?
if ( !pEntity || pEntity->IsWorld() )
{
// Robin: Due to some of the finicky details in the motor, the guard will hit
// the world when it is blocked by our enemy when trying to step up
// during a moveprobe. To get around this, we see if the enemy's within
// a volume in front of the guard when we hit the world, and if he is,
// we hit him anyway.
EnemyIsRightInFrontOfMe( &pEntity );
// Did we manage to find him? If not, increment our charge miss count and abort.
if ( pEntity->IsWorld() )
{
m_iChargeMisses++;
return true;
}
}
// Hit anything we don't like
if ( IRelationType( pEntity ) == D_HT && ( GetNextAttack() < gpGlobals->curtime ) )
{
EmitSound( "NPC_AntlionGuard.Shove" );
if ( !IsPlayingGesture( ACT_ANTLIONGUARD_CHARGE_HIT ) )
{
RestartGesture( ACT_ANTLIONGUARD_CHARGE_HIT );
}
ChargeDamage( pEntity );
pEntity->ApplyAbsVelocityImpulse( ( BodyDirection2D() * 400 ) + Vector( 0, 0, 200 ) );
if ( !pEntity->IsAlive() && GetEnemy() == pEntity )
{
SetEnemy( NULL );
}
SetNextAttack( gpGlobals->curtime + 2.0f );
SetActivity( ACT_ANTLIONGUARD_CHARGE_STOP );
// We've hit something, so clear our miss count
m_iChargeMisses = 0;
return false;
}
// Hit something we don't hate. If it's not moveable, crash into it.
if ( pEntity->GetMoveType() == MOVETYPE_NONE || pEntity->GetMoveType() == MOVETYPE_PUSH )
return true;
// If it's a vphysics object that's too heavy, crash into it too.
if ( pEntity->GetMoveType() == MOVETYPE_VPHYSICS )
{
IPhysicsObject *pPhysics = pEntity->VPhysicsGetObject();
if ( pPhysics )
{
// If the object is being held by the player, knock it out of his hands
if ( pPhysics->GetGameFlags() & FVPHYSICS_PLAYER_HELD )
{
Pickup_ForcePlayerToDropThisObject( pEntity );
return false;
}
if ( (!pPhysics->IsMoveable() || pPhysics->GetMass() > VPhysicsGetObject()->GetMass() * 0.5f ) )
return true;
}
}
return false;
/*
ROBIN: Wrote & then removed this. If we want to have large rocks that the guard
should smack around, then we should enable it.
else
{
// If we hit a physics prop, smack the crap out of it. (large rocks)
// Factor the object mass into it, because we want to move it no matter how heavy it is.
if ( pEntity->GetMoveType() == MOVETYPE_VPHYSICS )
{
CTakeDamageInfo info( this, this, 250, DMG_BLAST );
info.SetDamagePosition( vecImpact );
float flForce = ImpulseScale( pEntity->VPhysicsGetObject()->GetMass(), 250 );
flForce *= random->RandomFloat( 0.85, 1.15 );
// Calculate the vector and stuff it into the takedamageinfo
Vector vecForce = BodyDirection3D();
VectorNormalize( vecForce );
vecForce *= flForce;
vecForce *= phys_pushscale.GetFloat();
info.SetDamageForce( vecForce );
pEntity->VPhysicsTakeDamage( info );
}
}
*/
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float CNPC_AntlionGuard::ChargeSteer( void )
{
trace_t tr;
Vector testPos, steer, forward, right;
QAngle angles;
const float testLength = m_flGroundSpeed * 0.15f;
//Get our facing
GetVectors( &forward, &right, NULL );
steer = forward;
const float faceYaw = UTIL_VecToYaw( forward );
//Offset right
VectorAngles( forward, angles );
angles[YAW] += 45.0f;
AngleVectors( angles, &forward );
//Probe out
testPos = GetAbsOrigin() + ( forward * testLength );
//Offset by step height
Vector testHullMins = GetHullMins();
testHullMins.z += (StepHeight() * 2);
//Probe
TraceHull_SkipPhysics( GetAbsOrigin(), testPos, testHullMins, GetHullMaxs(), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr, VPhysicsGetObject()->GetMass() * 0.5f );
//Debug info
if ( g_debug_antlionguard.GetInt() == 1 )
{
if ( tr.fraction == 1.0f )
{
NDebugOverlay::BoxDirection( GetAbsOrigin(), testHullMins, GetHullMaxs() + Vector(testLength,0,0), forward, 0, 255, 0, 8, 0.1f );
}
else
{
NDebugOverlay::BoxDirection( GetAbsOrigin(), testHullMins, GetHullMaxs() + Vector(testLength,0,0), forward, 255, 0, 0, 8, 0.1f );
}
}
//Add in this component
steer += ( right * 0.5f ) * ( 1.0f - tr.fraction );
//Offset left
angles[YAW] -= 90.0f;
AngleVectors( angles, &forward );
//Probe out
testPos = GetAbsOrigin() + ( forward * testLength );
// Probe
TraceHull_SkipPhysics( GetAbsOrigin(), testPos, testHullMins, GetHullMaxs(), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr, VPhysicsGetObject()->GetMass() * 0.5f );
//Debug
if ( g_debug_antlionguard.GetInt() == 1 )
{
if ( tr.fraction == 1.0f )
{
NDebugOverlay::BoxDirection( GetAbsOrigin(), testHullMins, GetHullMaxs() + Vector(testLength,0,0), forward, 0, 255, 0, 8, 0.1f );
}
else
{
NDebugOverlay::BoxDirection( GetAbsOrigin(), testHullMins, GetHullMaxs() + Vector(testLength,0,0), forward, 255, 0, 0, 8, 0.1f );
}
}
//Add in this component
steer -= ( right * 0.5f ) * ( 1.0f - tr.fraction );
//Debug
if ( g_debug_antlionguard.GetInt() == 1 )
{
NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + ( steer * 512.0f ), 255, 255, 0, true, 0.1f );
NDebugOverlay::Cross3D( GetAbsOrigin() + ( steer * 512.0f ), Vector(2,2,2), -Vector(2,2,2), 255, 255, 0, true, 0.1f );
NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + ( BodyDirection3D() * 256.0f ), 255, 0, 255, true, 0.1f );
NDebugOverlay::Cross3D( GetAbsOrigin() + ( BodyDirection3D() * 256.0f ), Vector(2,2,2), -Vector(2,2,2), 255, 0, 255, true, 0.1f );
}
return UTIL_AngleDiff( UTIL_VecToYaw( steer ), faceYaw );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pTask -
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::RunTask( const Task_t *pTask )
{
switch (pTask->iTask)
{
case TASK_ANTLIONGUARD_SET_FLINCH_ACTIVITY:
AutoMovement( );
if ( IsActivityFinished() )
{
TaskComplete();
}
break;
case TASK_ANTLIONGUARD_SHOVE_PHYSOBJECT:
if ( IsActivityFinished() )
{
TaskComplete();
}
break;
/*
case TASK_RUN_PATH:
{
}
break;
*/
case TASK_ANTLIONGUARD_CHARGE:
{
Activity eActivity = GetActivity();
// See if we're trying to stop after hitting/missing our target
if ( eActivity == ACT_ANTLIONGUARD_CHARGE_STOP || eActivity == ACT_ANTLIONGUARD_CHARGE_CRASH )
{
if ( IsActivityFinished() )
{
TaskComplete();
return;
}
// Still in the process of slowing down. Run movement until it's done.
AutoMovement();
return;
}
// Check for manual transition
if ( ( eActivity == ACT_ANTLIONGUARD_CHARGE_START ) && ( IsActivityFinished() ) )
{
SetActivity( ACT_ANTLIONGUARD_CHARGE_RUN );
}
// See if we're still running
if ( eActivity == ACT_ANTLIONGUARD_CHARGE_RUN || eActivity == ACT_ANTLIONGUARD_CHARGE_START )
{
if ( HasCondition( COND_NEW_ENEMY ) || HasCondition( COND_LOST_ENEMY ) || HasCondition( COND_ENEMY_DEAD ) )
{
SetActivity( ACT_ANTLIONGUARD_CHARGE_STOP );
return;
}
else
{
if ( GetEnemy() != NULL )
{
Vector goalDir = ( GetEnemy()->GetAbsOrigin() - GetAbsOrigin() );
VectorNormalize( goalDir );
if ( DotProduct( BodyDirection2D(), goalDir ) < 0.25f )
{
if ( !m_bDecidedNotToStop )
{
// We've missed the target. Randomly decide not to stop, which will cause
// the guard to just try and swing around for another pass.
m_bDecidedNotToStop = true;
if ( RandomFloat(0,1) > 0.3 )
{
m_iChargeMisses++;
SetActivity( ACT_ANTLIONGUARD_CHARGE_STOP );
}
}
}
else
{
m_bDecidedNotToStop = false;
}
}
}
}
// Steer towards our target
float idealYaw;
if ( GetEnemy() == NULL )
{
idealYaw = GetMotor()->GetIdealYaw();
}
else
{
idealYaw = CalcIdealYaw( GetEnemy()->GetAbsOrigin() );
}
// Add in our steering offset
idealYaw += ChargeSteer();
// Turn to face
GetMotor()->SetIdealYawAndUpdate( idealYaw );
// See if we're going to run into anything soon
ChargeLookAhead();
// Let our animations simply move us forward. Keep the result
// of the movement so we know whether we've hit our target.
AIMoveTrace_t moveTrace;
if ( AutoMovement( GetEnemy(), &moveTrace ) == false )
{
// Only stop if we hit the world
if ( HandleChargeImpact( moveTrace.vEndPosition, moveTrace.pObstruction ) )
{
// If we're starting up, this is an error
if ( eActivity == ACT_ANTLIONGUARD_CHARGE_START )
{
TaskFail( "Unable to make initial movement of charge\n" );
return;
}
// Crash unless we're trying to stop already
if ( eActivity != ACT_ANTLIONGUARD_CHARGE_STOP )
{
if ( moveTrace.fStatus == AIMR_BLOCKED_WORLD && moveTrace.vHitNormal == vec3_origin )
{
SetActivity( ACT_ANTLIONGUARD_CHARGE_STOP );
}
else
{
SetActivity( ACT_ANTLIONGUARD_CHARGE_CRASH );
}
}
}
else if ( moveTrace.pObstruction )
{
// If we hit an antlion, don't stop, but kill it
if ( moveTrace.pObstruction->Classify() == CLASS_ANTLION )
{
if ( FClassnameIs( moveTrace.pObstruction, "npc_antlionguard" ) )
{
// Crash unless we're trying to stop already
if ( eActivity != ACT_ANTLIONGUARD_CHARGE_STOP )
{
SetActivity( ACT_ANTLIONGUARD_CHARGE_STOP );
}
}
else
{
ApplyChargeDamage( this, moveTrace.pObstruction, moveTrace.pObstruction->GetHealth() );
}
}
}
}
}
break;
case TASK_WAIT_FOR_MOVEMENT:
{
// the cavern antlion can clothesline gordon
if ( m_bInCavern )
{
// See if we're going to run into anything soon
ChargeLookAhead();
if ( HasCondition(COND_CAN_MELEE_ATTACK1) )
{
CBaseEntity *pEntity = GetEnemy();
if (pEntity && pEntity->IsPlayer())
{
EmitSound( "NPC_AntlionGuard.Shove" );
if ( !IsPlayingGesture( ACT_ANTLIONGUARD_CHARGE_HIT ) )
{
RestartGesture( ACT_ANTLIONGUARD_CHARGE_HIT );
}
ChargeDamage( pEntity );
pEntity->ApplyAbsVelocityImpulse( ( BodyDirection2D() * 400 ) + Vector( 0, 0, 200 ) );
if ( !pEntity->IsAlive() && GetEnemy() == pEntity )
{
SetEnemy( NULL );
}
SetNextAttack( gpGlobals->curtime + 2.0f );
SetActivity( ACT_ANTLIONGUARD_CHARGE_STOP );
// We've hit something, so clear our miss count
m_iChargeMisses = 0;
AutoMovement();
TaskComplete();
return;
}
}
}
BaseClass::RunTask( pTask );
}
break;
default:
BaseClass::RunTask(pTask);
break;
}
}
//-----------------------------------------------------------------------------
// Purpose: Summon antlions around the guard
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::SummonAntlions( void )
{
// We want to spawn them around the guard
Vector vecForward, vecRight;
AngleVectors( QAngle(0,GetAbsAngles().y,0), &vecForward, &vecRight, NULL );
// Spawn positions
struct spawnpos_t
{
float flForward;
float flRight;
};
spawnpos_t sAntlionSpawnPositions[] =
{
{ 0, 200 },
{ 0, -200 },
{ 128, 128 },
{ 128, -128 },
{ -128, 128 },
{ -128, -128 },
{ 200, 0 },
{ -200, 0 },
};
// Only spawn up to our max count
int iSpawnPoint = 0;
for ( int i = 0; (m_iNumLiveAntlions < ANTLIONGUARD_SUMMON_COUNT) && (iSpawnPoint < ARRAYSIZE(sAntlionSpawnPositions)); i++ )
{
// Determine spawn position for the antlion
Vector vecSpawn = GetAbsOrigin() + ( sAntlionSpawnPositions[iSpawnPoint].flForward * vecForward ) + ( sAntlionSpawnPositions[iSpawnPoint].flRight * vecRight );
iSpawnPoint++;
// Randomise it a little
vecSpawn.x += RandomFloat( -64, 64 );
vecSpawn.y += RandomFloat( -64, 64 );
vecSpawn.z += 64;
// Make sure it's clear, and make sure we hit something
trace_t tr;
UTIL_TraceHull( vecSpawn, vecSpawn - Vector(0,0,128), NAI_Hull::Mins( HULL_MEDIUM ), NAI_Hull::Maxs( HULL_MEDIUM ), MASK_NPCSOLID, NULL, COLLISION_GROUP_NONE, &tr );
if ( tr.startsolid || tr.allsolid || tr.fraction == 1.0 )
{
if ( g_debug_antlionguard.GetInt() == 2 )
{
NDebugOverlay::Box( tr.endpos, NAI_Hull::Mins( HULL_MEDIUM ), NAI_Hull::Maxs( HULL_MEDIUM ), 255, 0, 0, true, 5.0f );
}
continue;
}
// Ensure it's dirt or sand
const surfacedata_t *pdata = physprops->GetSurfaceData( tr.surface.surfaceProps );
if ( ( pdata->game.material != CHAR_TEX_DIRT ) && ( pdata->game.material != CHAR_TEX_SAND ) )
{
if ( g_debug_antlionguard.GetInt() == 2 )
{
NDebugOverlay::Box( tr.endpos, NAI_Hull::Mins( HULL_MEDIUM ), NAI_Hull::Maxs( HULL_MEDIUM ), 255, 128, 128, true, 5.0f );
}
continue;
}
// Make sure the guard can see it
trace_t tr_vis;
UTIL_TraceLine( WorldSpaceCenter(), tr.endpos, MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr_vis );
if ( tr_vis.fraction != 1.0 )
{
if ( g_debug_antlionguard.GetInt() == 2 )
{
NDebugOverlay::Line( WorldSpaceCenter(), tr.endpos, 255, 0, 0, true, 5.0f );
}
continue;
}
CAI_BaseNPC *pent = (CAI_BaseNPC*)CreateEntityByName( "npc_antlion" );
if ( !pent )
break;
CNPC_Antlion *pAntlion = assert_cast<CNPC_Antlion*>(pent);
if ( g_debug_antlionguard.GetInt() == 2 )
{
NDebugOverlay::Box( tr.endpos, NAI_Hull::Mins( HULL_MEDIUM ), NAI_Hull::Maxs( HULL_MEDIUM ), 0, 255, 0, true, 5.0f );
NDebugOverlay::Line( WorldSpaceCenter(), tr.endpos, 0, 255, 0, true, 5.0f );
}
vecSpawn = tr.endpos;
pAntlion->SetAbsOrigin( vecSpawn );
// Start facing our enemy if we have one, otherwise just match the guard.
Vector vecFacing = vecForward;
if ( GetEnemy() )
{
vecFacing = GetEnemy()->GetAbsOrigin() - GetAbsOrigin();
VectorNormalize( vecFacing );
}
QAngle vecAngles;
VectorAngles( vecFacing, vecAngles );
pAntlion->SetAbsAngles( vecAngles );
pAntlion->AddSpawnFlags( SF_NPC_FALL_TO_GROUND );
pAntlion->AddSpawnFlags( SF_NPC_FADE_CORPSE );
// Make the antlion fire my input when he dies
pAntlion->KeyValue( "OnDeath", UTIL_VarArgs("%s,SummonedAntlionDied,,0,-1", STRING(GetEntityName())) );
// Start the antlion burrowed, and tell him to come up
pAntlion->m_bStartBurrowed = true;
DispatchSpawn( pAntlion );
pAntlion->Activate();
g_EventQueue.AddEvent( pAntlion, "Unburrow", RandomFloat(0.1, 1.0), this, this );
// Add it to our squad
if ( GetSquad() != NULL )
{
GetSquad()->AddToSquad( pAntlion );
}
// Set the antlion's enemy to our enemy
if ( GetEnemy() )
{
pAntlion->SetEnemy( GetEnemy() );
pAntlion->SetState( NPC_STATE_COMBAT );
pAntlion->UpdateEnemyMemory( GetEnemy(), GetEnemy()->GetAbsOrigin() );
}
m_iNumLiveAntlions++;
}
if ( g_debug_antlionguard.GetInt() == 2 )
{
Msg("Guard summoned antlion count: %d\n", m_iNumLiveAntlions );
}
if ( m_iNumLiveAntlions > 2 )
{
m_flNextSummonTime = gpGlobals->curtime + RandomFloat( 15,20 );
}
else
{
m_flNextSummonTime = gpGlobals->curtime + RandomFloat( 10,15 );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::FoundEnemy( void )
{
m_flAngerNoiseTime = gpGlobals->curtime + 2.0f;
SetState( NPC_STATE_COMBAT );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::LostEnemy( void )
{
m_flSearchNoiseTime = gpGlobals->curtime + 2.0f;
SetState( NPC_STATE_ALERT );
m_OnLostPlayer.FireOutput( this, this );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::InputSetShoveTarget( inputdata_t &inputdata )
{
if ( IsAlive() == false )
return;
CBaseEntity *pTarget = gEntList.FindEntityByName( NULL, inputdata.value.String(), NULL, inputdata.pActivator, inputdata.pCaller );
if ( pTarget == NULL )
{
Warning( "**Guard %s cannot find shove target %s\n", GetClassname(), inputdata.value.String() );
m_hShoveTarget = NULL;
return;
}
m_hShoveTarget = pTarget;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::InputSetChargeTarget( inputdata_t &inputdata )
{
if ( !IsAlive() )
return;
// Pull the target & position out of the string
char parseString[255];
Q_strncpy(parseString, inputdata.value.String(), sizeof(parseString));
// Get charge target name
char *pszParam = strtok(parseString," ");
CBaseEntity *pTarget = gEntList.FindEntityByName( NULL, pszParam, NULL, inputdata.pActivator, inputdata.pCaller );
if ( !pTarget )
{
Warning( "ERROR: Guard %s cannot find charge target '%s'\n", STRING(GetEntityName()), pszParam );
return;
}
// Get the charge position name
pszParam = strtok(NULL," ");
CBaseEntity *pPosition = gEntList.FindEntityByName( NULL, pszParam, NULL, inputdata.pActivator, inputdata.pCaller );
if ( !pPosition )
{
Warning( "ERROR: Guard %s cannot find charge position '%s'\nMake sure you've specified the parameters as [target start]!\n", STRING(GetEntityName()), pszParam );
return;
}
// Make sure we don't stack charge targets
if ( m_hChargeTarget )
{
if ( GetEnemy() == m_hChargeTarget )
{
SetEnemy( NULL );
}
}
SetCondition( COND_ANTLIONGUARD_HAS_CHARGE_TARGET );
m_hChargeTarget = pTarget;
m_hChargeTargetPosition = pPosition;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::InputClearChargeTarget( inputdata_t &inputdata )
{
m_hChargeTarget = NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : baseAct -
// Output : Activity
//-----------------------------------------------------------------------------
Activity CNPC_AntlionGuard::NPC_TranslateActivity( Activity baseAct )
{
//See which run to use
if ( ( baseAct == ACT_RUN ) && IsCurSchedule( SCHED_ANTLIONGUARD_CHARGE ) )
return (Activity) ACT_ANTLIONGUARD_CHARGE_RUN;
// Do extra code if we're trying to close on an enemy in a confined space (unless scripted)
if ( hl2_episodic.GetBool() && m_bInCavern && baseAct == ACT_RUN && IsInAScript() == false )
return (Activity) ACT_ANTLIONGUARD_CHARGE_RUN;
if ( ( baseAct == ACT_RUN ) && ( m_iHealth <= (m_iMaxHealth/4) ) )
return (Activity) ACT_ANTLIONGUARD_RUN_HURT;
return baseAct;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_AntlionGuard::ShouldWatchEnemy( void )
{
Activity nActivity = GetActivity();
if ( ( nActivity == ACT_ANTLIONGUARD_SEARCH ) ||
( nActivity == ACT_ANTLIONGUARD_PEEK_ENTER ) ||
( nActivity == ACT_ANTLIONGUARD_PEEK_EXIT ) ||
( nActivity == ACT_ANTLIONGUARD_PEEK1 ) ||
( nActivity == ACT_ANTLIONGUARD_PEEK_SIGHTED ) ||
( nActivity == ACT_ANTLIONGUARD_SHOVE_PHYSOBJECT ) ||
( nActivity == ACT_ANTLIONGUARD_PHYSHIT_FR ) ||
( nActivity == ACT_ANTLIONGUARD_PHYSHIT_FL ) ||
( nActivity == ACT_ANTLIONGUARD_PHYSHIT_RR ) ||
( nActivity == ACT_ANTLIONGUARD_PHYSHIT_RL ) ||
( nActivity == ACT_ANTLIONGUARD_CHARGE_CRASH ) ||
( nActivity == ACT_ANTLIONGUARD_CHARGE_HIT ) ||
( nActivity == ACT_ANTLIONGUARD_CHARGE_ANTICIPATION ) )
{
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::UpdateHead( void )
{
float yaw = GetPoseParameter( m_poseHead_Yaw );
float pitch = GetPoseParameter( m_poseHead_Pitch );
// If we should be watching our enemy, turn our head
if ( ShouldWatchEnemy() && ( GetEnemy() != NULL ) )
{
Vector enemyDir = GetEnemy()->WorldSpaceCenter() - WorldSpaceCenter();
VectorNormalize( enemyDir );
float angle = VecToYaw( BodyDirection3D() );
float angleDiff = VecToYaw( enemyDir );
angleDiff = UTIL_AngleDiff( angleDiff, angle + yaw );
SetPoseParameter( m_poseHead_Yaw, UTIL_Approach( yaw + angleDiff, yaw, 50 ) );
angle = UTIL_VecToPitch( BodyDirection3D() );
angleDiff = UTIL_VecToPitch( enemyDir );
angleDiff = UTIL_AngleDiff( angleDiff, angle + pitch );
SetPoseParameter( m_poseHead_Pitch, UTIL_Approach( pitch + angleDiff, pitch, 50 ) );
}
else
{
// Otherwise turn the head back to its normal position
SetPoseParameter( m_poseHead_Yaw, UTIL_Approach( 0, yaw, 10 ) );
SetPoseParameter( m_poseHead_Pitch, UTIL_Approach( 0, pitch, 10 ) );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::MaintainPhysicsTarget( void )
{
if ( m_hPhysicsTarget == NULL || GetEnemy() == NULL )
return;
// Update our current target to make sure it's still valid
float flTargetDistSqr = ( m_hPhysicsTarget->WorldSpaceCenter() - m_vecPhysicsTargetStartPos ).LengthSqr();
bool bTargetMoved = ( flTargetDistSqr > Square(30*12.0f) );
bool bEnemyCloser = ( ( GetEnemy()->GetAbsOrigin() - GetAbsOrigin() ).LengthSqr() <= flTargetDistSqr );
// Make sure this hasn't moved too far or that the player is now closer
if ( bTargetMoved || bEnemyCloser )
{
ClearCondition( COND_ANTLIONGUARD_PHYSICS_TARGET );
SetCondition( COND_ANTLIONGUARD_PHYSICS_TARGET_INVALID );
m_hPhysicsTarget = NULL;
return;
}
else
{
SetCondition( COND_ANTLIONGUARD_PHYSICS_TARGET );
ClearCondition( COND_ANTLIONGUARD_PHYSICS_TARGET_INVALID );
}
if ( g_debug_antlionguard.GetInt() == 3 )
{
NDebugOverlay::Cross3D( m_hPhysicsTarget->WorldSpaceCenter(), -Vector(32,32,32), Vector(32,32,32), 255, 255, 255, true, 1.0f );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::UpdatePhysicsTarget( bool bPreferObjectsAlongTargetVector, float flRadius )
{
if ( GetEnemy() == NULL )
return;
// Already have a target, don't bother looking
if ( m_hPhysicsTarget != NULL )
return;
// Too soon to check again
if ( m_flPhysicsCheckTime > gpGlobals->curtime )
return;
// Attempt to find a valid shove target
PhysicsObjectCriteria_t criteria;
criteria.pTarget = GetEnemy();
criteria.vecCenter = GetEnemy()->GetAbsOrigin();
criteria.flRadius = flRadius;
criteria.flTargetCone = ANTLIONGUARD_OBJECTFINDING_FOV;
criteria.bPreferObjectsAlongTargetVector = bPreferObjectsAlongTargetVector;
criteria.flNearRadius = (20*12); // TODO: It may preferable to disable this for legacy products as well -- jdw
m_hPhysicsTarget = FindPhysicsObjectTarget( criteria );
// Found one, so interrupt us if we care
if ( m_hPhysicsTarget != NULL )
{
SetCondition( COND_ANTLIONGUARD_PHYSICS_TARGET );
m_vecPhysicsTargetStartPos = m_hPhysicsTarget->WorldSpaceCenter();
}
// Don't search again for another second
m_flPhysicsCheckTime = gpGlobals->curtime + 1.0f;
}
//-----------------------------------------------------------------------------
// Purpose: Let the probe know I can run through small debris
//-----------------------------------------------------------------------------
bool CNPC_AntlionGuard::ShouldProbeCollideAgainstEntity( CBaseEntity *pEntity )
{
if ( m_iszPhysicsPropClass != pEntity->m_iClassname )
return BaseClass::ShouldProbeCollideAgainstEntity( pEntity );
if ( m_hPhysicsTarget == pEntity )
return false;
if ( pEntity->GetMoveType() == MOVETYPE_VPHYSICS )
{
IPhysicsObject *pPhysObj = pEntity->VPhysicsGetObject();
if( pPhysObj && pPhysObj->GetMass() <= ANTLIONGUARD_MAX_OBJECT_MASS )
{
return false;
}
}
return BaseClass::ShouldProbeCollideAgainstEntity( pEntity );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::PrescheduleThink( void )
{
BaseClass::PrescheduleThink();
// Don't do anything after death
if ( m_NPCState == NPC_STATE_DEAD )
return;
// If we're burrowed, then don't do any of this
if ( m_bIsBurrowed )
return;
// Automatically update our physics target when chasing enemies
if ( IsCurSchedule( SCHED_ANTLIONGUARD_CHASE_ENEMY ) ||
IsCurSchedule( SCHED_ANTLIONGUARD_PATROL_RUN ) ||
IsCurSchedule( SCHED_ANTLIONGUARD_CANT_ATTACK ) ||
IsCurSchedule( SCHED_ANTLIONGUARD_CHASE_ENEMY_TOLERANCE ) )
{
bool bCheckAlongLine = ( IsCurSchedule( SCHED_ANTLIONGUARD_CHASE_ENEMY ) || IsCurSchedule( SCHED_ANTLIONGUARD_CHASE_ENEMY_TOLERANCE ) );
UpdatePhysicsTarget( bCheckAlongLine );
}
else if ( !IsCurSchedule( SCHED_ANTLIONGUARD_PHYSICS_ATTACK ) )
{
ClearCondition( COND_ANTLIONGUARD_PHYSICS_TARGET );
m_hPhysicsTarget = NULL;
}
UpdateHead();
if ( ( m_flGroundSpeed <= 0.0f ) )
{
if ( m_bStopped == false )
{
StartSounds();
float duration = random->RandomFloat( 2.0f, 8.0f );
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pBreathSound, 0.0f, duration );
ENVELOPE_CONTROLLER.SoundChangePitch( m_pBreathSound, random->RandomInt( 40, 60 ), duration );
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pGrowlIdleSound, 0.0f, duration );
ENVELOPE_CONTROLLER.SoundChangePitch( m_pGrowlIdleSound, random->RandomInt( 120, 140 ), duration );
m_flBreathTime = gpGlobals->curtime + duration - (duration*0.75f);
}
m_bStopped = true;
if ( m_flBreathTime < gpGlobals->curtime )
{
StartSounds();
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pGrowlIdleSound, random->RandomFloat( 0.2f, 0.3f ), random->RandomFloat( 0.5f, 1.0f ) );
ENVELOPE_CONTROLLER.SoundChangePitch( m_pGrowlIdleSound, random->RandomInt( 80, 120 ), random->RandomFloat( 0.5f, 1.0f ) );
m_flBreathTime = gpGlobals->curtime + random->RandomFloat( 1.0f, 8.0f );
}
}
else
{
if ( m_bStopped )
{
StartSounds();
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pBreathSound, 0.6f, random->RandomFloat( 2.0f, 4.0f ) );
ENVELOPE_CONTROLLER.SoundChangePitch( m_pBreathSound, random->RandomInt( 140, 160 ), random->RandomFloat( 2.0f, 4.0f ) );
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pGrowlIdleSound, 0.0f, 1.0f );
ENVELOPE_CONTROLLER.SoundChangePitch( m_pGrowlIdleSound, random->RandomInt( 90, 110 ), 0.2f );
}
m_bStopped = false;
}
// Put danger sounds out in front of us
for ( int i = 0; i < 3; i++ )
{
CSoundEnt::InsertSound( SOUND_DANGER, WorldSpaceCenter() + ( BodyDirection3D() * 128 * (i+1) ), 128, 0.1f, this );
}
#if ANTLIONGUARD_BLOOD_EFFECTS
// compute and if necessary transmit the bleeding level for the particle effect
m_iBleedingLevel = GetBleedingLevel();
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::GatherConditions( void )
{
BaseClass::GatherConditions();
if ( CanSummon(false) )
{
SetCondition( COND_ANTLIONGUARD_CAN_SUMMON );
}
else
{
ClearCondition( COND_ANTLIONGUARD_CAN_SUMMON );
}
// Make sure our physics target is still valid
MaintainPhysicsTarget();
if( IsCurSchedule(SCHED_ANTLIONGUARD_PHYSICS_ATTACK) )
{
if( gpGlobals->curtime > m_flWaitFinished )
{
ClearCondition( COND_ANTLIONGUARD_PHYSICS_TARGET );
SetCondition( COND_ANTLIONGUARD_PHYSICS_TARGET_INVALID );
m_hPhysicsTarget = NULL;
}
}
// See if we can charge the target
if ( GetEnemy() )
{
if ( ShouldCharge( GetAbsOrigin(), GetEnemy()->GetAbsOrigin(), true, false ) )
{
SetCondition( COND_ANTLIONGUARD_CAN_CHARGE );
}
else
{
ClearCondition( COND_ANTLIONGUARD_CAN_CHARGE );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::StopLoopingSounds()
{
//Stop all sounds
ENVELOPE_CONTROLLER.SoundDestroy( m_pGrowlHighSound );
ENVELOPE_CONTROLLER.SoundDestroy( m_pGrowlIdleSound );
ENVELOPE_CONTROLLER.SoundDestroy( m_pBreathSound );
ENVELOPE_CONTROLLER.SoundDestroy( m_pConfusedSound );
m_pGrowlHighSound = NULL;
m_pGrowlIdleSound = NULL;
m_pBreathSound = NULL;
m_pConfusedSound = NULL;
BaseClass::StopLoopingSounds();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::InputUnburrow( inputdata_t &inputdata )
{
if ( IsAlive() == false )
return;
if ( m_bIsBurrowed == false )
return;
m_spawnflags &= ~SF_NPC_GAG;
RemoveSolidFlags( FSOLID_NOT_SOLID );
AddSolidFlags( FSOLID_NOT_STANDABLE );
m_takedamage = DAMAGE_YES;
SetSchedule( SCHED_ANTLIONGUARD_UNBURROW );
m_bIsBurrowed = false;
}
//------------------------------------------------------------------------------
// Purpose : Returns true is entity was remembered as unreachable.
// After a time delay reachability is checked
// Input :
// Output :
//------------------------------------------------------------------------------
bool CNPC_AntlionGuard::IsUnreachable(CBaseEntity *pEntity)
{
float UNREACHABLE_DIST_TOLERANCE_SQ = (240 * 240);
// Note that it's ok to remove elements while I'm iterating
// as long as I iterate backwards and remove them using FastRemove
for (int i=m_UnreachableEnts.Size()-1;i>=0;i--)
{
// Remove any dead elements
if (m_UnreachableEnts[i].hUnreachableEnt == NULL)
{
m_UnreachableEnts.FastRemove(i);
}
else if (pEntity == m_UnreachableEnts[i].hUnreachableEnt)
{
// Test for reachability on any elements that have timed out
if ( gpGlobals->curtime > m_UnreachableEnts[i].fExpireTime ||
pEntity->GetAbsOrigin().DistToSqr(m_UnreachableEnts[i].vLocationWhenUnreachable) > UNREACHABLE_DIST_TOLERANCE_SQ)
{
m_UnreachableEnts.FastRemove(i);
return false;
}
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Return the point at which the guard wants to stand on to knock the physics object at the target entity
// Input : *pObject - Object to be shoved.
// *pTarget - Target to be shoved at.
// *vecTrajectory - Trajectory to our target
// *flClearDistance - Distance behind the entity we're clear to use
// Output : Position at which to attempt to strike the object
//-----------------------------------------------------------------------------
Vector CNPC_AntlionGuard::GetPhysicsHitPosition( CBaseEntity *pObject, CBaseEntity *pTarget, Vector *vecTrajectory, float *flClearDistance )
{
// Get the trajectory we want to knock the object along
Vector vecToTarget = pTarget->WorldSpaceCenter() - pObject->WorldSpaceCenter();
VectorNormalize( vecToTarget );
vecToTarget.z = 0;
// Get the distance we want to be from the object when we hit it
IPhysicsObject *pPhys = pObject->VPhysicsGetObject();
Vector extent = physcollision->CollideGetExtent( pPhys->GetCollide(), pObject->GetAbsOrigin(), pObject->GetAbsAngles(), -vecToTarget );
float flDist = ( extent - pObject->WorldSpaceCenter() ).Length() + CollisionProp()->BoundingRadius() + 32.0f;
if ( vecTrajectory != NULL )
{
*vecTrajectory = vecToTarget;
}
if ( flClearDistance != NULL )
{
*flClearDistance = flDist;
}
// Position at which we'd like to be
return (pObject->WorldSpaceCenter() + ( vecToTarget * -flDist ));
}
//-----------------------------------------------------------------------------
// Purpose: See if we're able to stand on the ground at this point
// Input : &vecPos - Position to try
// *pOut - Result position (only valid if we return true)
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
inline bool CNPC_AntlionGuard::CanStandAtPoint( const Vector &vecPos, Vector *pOut )
{
Vector vecStart = vecPos + Vector( 0, 0, (4*12) );
Vector vecEnd = vecPos - Vector( 0, 0, (4*12) );
trace_t tr;
bool bTraceCleared = false;
// Start high and try to go lower, looking for the ground between here and there
// We do this first because it's more likely to succeed in the typical guard arenas (with open terrain)
UTIL_TraceHull( vecStart, vecEnd, GetHullMins(), GetHullMaxs(), MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );
if ( tr.startsolid && !tr.allsolid )
{
// We started in solid but didn't end up there, see if we can stand where we ended up
UTIL_TraceHull( tr.endpos, tr.endpos, GetHullMins(), GetHullMaxs(), MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );
// Must not be in solid
bTraceCleared = ( !tr.allsolid && !tr.startsolid );
}
else
{
// Must not be in solid and must have found a floor (otherwise we're potentially hanging over a ledge)
bTraceCleared = ( tr.allsolid == false && tr.fraction < 1.0f );
}
// Either we're clear or we're still unlucky
if ( bTraceCleared == false )
{
if ( g_debug_antlionguard.GetInt() == 3 )
{
NDebugOverlay::Box( vecPos, GetHullMins(), GetHullMaxs(), 255, 0, 0, 0, 15.0f );
}
return false;
}
if ( pOut )
{
*pOut = tr.endpos;
}
if ( g_debug_antlionguard.GetInt() == 3 )
{
NDebugOverlay::Box( (*pOut), GetHullMins(), GetHullMaxs(), 0, 255, 0, 0, 15.0f );
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Determines whether or not the guard can stand in a position to strike a specified object
// Input : *pShoveObject - Object being shoved
// *pTarget - Target we're shoving the object at
// *pOut - The position we decide to stand at
// Output : Returns true if the guard can stand and deliver.
//-----------------------------------------------------------------------------
bool CNPC_AntlionGuard::CanStandAtShoveTarget( CBaseEntity *pShoveObject, CBaseEntity *pTarget, Vector *pOut )
{
// Get the position we want to be at to swing at the object
float flClearDistance;
Vector vecTrajectory;
Vector vecHitPosition = GetPhysicsHitPosition( pShoveObject, pTarget, &vecTrajectory, &flClearDistance );
Vector vecStandPosition;
if ( g_debug_antlionguard.GetInt() == 3 )
{
NDebugOverlay::HorzArrow( pShoveObject->WorldSpaceCenter(), pShoveObject->WorldSpaceCenter() + vecTrajectory * 64.0f, 16.0f, 255, 255, 0, 16, true, 15.0f );
}
// If we failed, try around the sides
if ( CanStandAtPoint( vecHitPosition, &vecStandPosition ) == false )
{
// Get the angle (in reverse) to the target
float flRad = atan2( -vecTrajectory.y, -vecTrajectory.x );
float flRadOffset = DEG2RAD( 45.0f );
// Build an offset vector, rotating around the base
Vector vecSkewTrajectory;
SinCos( flRad + flRadOffset, &vecSkewTrajectory.y, &vecSkewTrajectory.x );
vecSkewTrajectory.z = 0.0f;
// Try to the side
if ( CanStandAtPoint( ( pShoveObject->WorldSpaceCenter() + ( vecSkewTrajectory * flClearDistance ) ), &vecStandPosition ) == false )
{
// Try the other side
SinCos( flRad - flRadOffset, &vecSkewTrajectory.y, &vecSkewTrajectory.x );
vecSkewTrajectory.z = 0.0f;
if ( CanStandAtPoint( ( pShoveObject->WorldSpaceCenter() + ( vecSkewTrajectory * flClearDistance ) ), &vecStandPosition ) == false )
return false;
}
}
// Found it, report it
if ( pOut != NULL )
{
*pOut = vecStandPosition;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Iterate through a number of lists depending on our criteria
//-----------------------------------------------------------------------------
CBaseEntity *CNPC_AntlionGuard::GetNextShoveTarget( CBaseEntity *pLastEntity, AISightIter_t &iter )
{
// Try to find scripted items first
if ( m_strShoveTargets != NULL_STRING )
{
CBaseEntity *pFound = gEntList.FindEntityByName( pLastEntity, m_strShoveTargets );
if ( pFound )
return pFound;
}
// Failing that, use our senses
if ( iter != (AISightIter_t)(-1) )
return GetSenses()->GetNextSeenEntity( &iter );
return GetSenses()->GetFirstSeenEntity( &iter, SEEN_MISC );
}
//-----------------------------------------------------------------------------
// Purpose: Search for a physics item to swat at the player
// Output : Returns the object we're going to swat.
//-----------------------------------------------------------------------------
CBaseEntity *CNPC_AntlionGuard::FindPhysicsObjectTarget( const PhysicsObjectCriteria_t &criteria )
{
// Must have a valid target entity
if ( criteria.pTarget == NULL )
return NULL;
if ( g_debug_antlionguard.GetInt() == 3 )
{
NDebugOverlay::Circle( GetAbsOrigin(), QAngle( -90, 0, 0 ), criteria.flRadius, 255, 0, 0, 8, true, 2.0f );
}
// Get the vector to our target, from ourself
Vector vecDirToTarget = criteria.pTarget->GetAbsOrigin() - GetAbsOrigin();
VectorNormalize( vecDirToTarget );
vecDirToTarget.z = 0;
// Cost is determined by distance to the object, modified by how "in line" it is with our target direction of travel
// Use the distance to the player as the base cost for throwing an object (avoids pushing things too close to the player)
float flLeastCost = ( criteria.bPreferObjectsAlongTargetVector ) ? ( criteria.pTarget->GetAbsOrigin() - GetAbsOrigin() ).LengthSqr() : Square( criteria.flRadius );
float flCost;
AISightIter_t iter = (AISightIter_t)(-1);
CBaseEntity *pObject = NULL;
CBaseEntity *pNearest = NULL;
Vector vecBestHitPosition = vec3_origin;
// Look through the list of sensed objects for possible targets
while( ( pObject = GetNextShoveTarget( pObject, iter ) ) != NULL )
{
// If we couldn't shove this object last time, don't try again
if ( m_FailedPhysicsTargets.Find( pObject ) != m_FailedPhysicsTargets.InvalidIndex() )
continue;
// Ignore things less than half a foot in diameter
if ( pObject->CollisionProp()->BoundingRadius() < 6.0f )
continue;
IPhysicsObject *pPhysObj = pObject->VPhysicsGetObject();
if ( pPhysObj == NULL )
continue;
// Ignore motion disabled props
if ( pPhysObj->IsMoveable() == false )
continue;
// Ignore things lighter than 5kg
if ( pPhysObj->GetMass() < 5.0f )
continue;
// Ignore objects moving too quickly (they'll be too hard to catch otherwise)
Vector velocity;
pPhysObj->GetVelocity( &velocity, NULL );
if ( velocity.LengthSqr() > (16*16) )
continue;
// Get the direction from us to the physics object
Vector vecDirToObject = pObject->WorldSpaceCenter() - GetAbsOrigin();
VectorNormalize( vecDirToObject );
vecDirToObject.z = 0;
Vector vecObjCenter = pObject->WorldSpaceCenter();
float flDistSqr = 0.0f;
float flDot = 0.0f;
// If we want to find things along the vector to the target, do so
if ( criteria.bPreferObjectsAlongTargetVector )
{
// Object must be closer than our target
if ( ( GetAbsOrigin() - vecObjCenter ).LengthSqr() > ( GetAbsOrigin() - criteria.pTarget->GetAbsOrigin() ).LengthSqr() )
continue;
// Calculate a "cost" to this object
flDistSqr = ( GetAbsOrigin() - vecObjCenter ).LengthSqr();
flDot = DotProduct( vecDirToTarget, vecDirToObject );
// Ignore things outside our allowed cone
if ( flDot < criteria.flTargetCone )
continue;
// The more perpendicular we are, the higher the cost
float flCostScale = RemapValClamped( flDot, 1.0f, criteria.flTargetCone, 1.0f, 4.0f );
flCost = flDistSqr * flCostScale;
}
else
{
// Straight distance cost
flCost = ( criteria.vecCenter - vecObjCenter ).LengthSqr();
}
// This must be a less costly object to use
if ( flCost >= flLeastCost )
{
if ( g_debug_antlionguard.GetInt() == 3 )
{
NDebugOverlay::Box( vecObjCenter, -Vector(16,16,16), Vector(16,16,16), 255, 0, 0, 0, 2.0f );
}
continue;
}
// Check for a (roughly) clear trajectory path from the object to target
trace_t tr;
UTIL_TraceLine( vecObjCenter, criteria.pTarget->BodyTarget( vecObjCenter ), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
// See how close to our target we got (we still look good hurling things that won't necessarily hit)
if ( ( tr.endpos - criteria.pTarget->WorldSpaceCenter() ).LengthSqr() > Square(criteria.flNearRadius) )
continue;
// Must be able to stand at a position to hit the object
Vector vecHitPosition;
if ( CanStandAtShoveTarget( pObject, criteria.pTarget, &vecHitPosition ) == false )
{
if ( g_debug_antlionguard.GetInt() == 3 )
{
NDebugOverlay::HorzArrow( GetAbsOrigin(), pObject->WorldSpaceCenter(), 32.0f, 255, 0, 0, 64, true, 2.0f );
}
continue;
}
// Take this as the best object so far
pNearest = pObject;
flLeastCost = flCost;
vecBestHitPosition = vecHitPosition;
if ( g_debug_antlionguard.GetInt() == 3 )
{
NDebugOverlay::HorzArrow( GetAbsOrigin(), pObject->WorldSpaceCenter(), 16.0f, 255, 255, 0, 0, true, 2.0f );
}
}
// Set extra info if we've succeeded
if ( pNearest != NULL )
{
m_vecPhysicsHitPosition = vecBestHitPosition;
if ( g_debug_antlionguard.GetInt() == 3 )
{
NDebugOverlay::HorzArrow( GetAbsOrigin(), pNearest->WorldSpaceCenter(), 32.0f, 0, 255, 0, 128, true, 2.0f );
}
}
return pNearest;
}
//-----------------------------------------------------------------------------
// Purpose: Allows for modification of the interrupt mask for the current schedule.
// In the most cases the base implementation should be called first.
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::BuildScheduleTestBits( void )
{
BaseClass::BuildScheduleTestBits();
// Interrupt if we can shove something
if ( IsCurSchedule( SCHED_ANTLIONGUARD_CHASE_ENEMY ) )
{
SetCustomInterruptCondition( COND_ANTLIONGUARD_PHYSICS_TARGET );
SetCustomInterruptCondition( COND_ANTLIONGUARD_CAN_SUMMON );
}
// Interrupt if we've been given a charge target
if ( IsCurSchedule( SCHED_ANTLIONGUARD_CHARGE ) == false )
{
SetCustomInterruptCondition( COND_ANTLIONGUARD_HAS_CHARGE_TARGET );
}
// Once we commit to doing this, just do it!
if ( IsCurSchedule( SCHED_MELEE_ATTACK1 ) )
{
ClearCustomInterruptCondition( COND_ENEMY_OCCLUDED );
}
// Always take heavy damage
SetCustomInterruptCondition( COND_HEAVY_DAMAGE );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &origin -
// radius -
// magnitude -
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::ImpactShock( const Vector &origin, float radius, float magnitude, CBaseEntity *pIgnored )
{
// Also do a local physics explosion to push objects away
float adjustedDamage, flDist;
Vector vecSpot;
float falloff = 1.0f / 2.5f;
CBaseEntity *pEntity = NULL;
// Find anything within our radius
while ( ( pEntity = gEntList.FindEntityInSphere( pEntity, origin, radius ) ) != NULL )
{
// Don't affect the ignored target
if ( pEntity == pIgnored )
continue;
if ( pEntity == this )
continue;
// UNDONE: Ask the object if it should get force if it's not MOVETYPE_VPHYSICS?
if ( pEntity->GetMoveType() == MOVETYPE_VPHYSICS || ( pEntity->VPhysicsGetObject() && pEntity->IsPlayer() == false ) )
{
vecSpot = pEntity->BodyTarget( GetAbsOrigin() );
// decrease damage for an ent that's farther from the bomb.
flDist = ( GetAbsOrigin() - vecSpot ).Length();
if ( radius == 0 || flDist <= radius )
{
adjustedDamage = flDist * falloff;
adjustedDamage = magnitude - adjustedDamage;
if ( adjustedDamage < 1 )
{
adjustedDamage = 1;
}
CTakeDamageInfo info( this, this, adjustedDamage, DMG_BLAST );
CalculateExplosiveDamageForce( &info, (vecSpot - GetAbsOrigin()), GetAbsOrigin() );
pEntity->VPhysicsTakeDamage( info );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pTarget -
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::ChargeDamage( CBaseEntity *pTarget )
{
if ( pTarget == NULL )
return;
CBasePlayer *pPlayer = ToBasePlayer( pTarget );
if ( pPlayer != NULL )
{
//Kick the player angles
pPlayer->ViewPunch( QAngle( 20, 20, -30 ) );
Vector dir = pPlayer->WorldSpaceCenter() - WorldSpaceCenter();
VectorNormalize( dir );
dir.z = 0.0f;
Vector vecNewVelocity = dir * 250.0f;
vecNewVelocity[2] += 128.0f;
pPlayer->SetAbsVelocity( vecNewVelocity );
color32 red = {128,0,0,128};
UTIL_ScreenFade( pPlayer, red, 1.0f, 0.1f, FFADE_IN );
}
// Player takes less damage
float flDamage = ( pPlayer == NULL ) ? 250 : sk_antlionguard_dmg_charge.GetFloat();
// If it's being held by the player, break that bond
Pickup_ForcePlayerToDropThisObject( pTarget );
// Calculate the physics force
ApplyChargeDamage( this, pTarget, flDamage );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::InputRagdoll( inputdata_t &inputdata )
{
if ( IsAlive() == false )
return;
//Set us to nearly dead so the velocity from death is minimal
SetHealth( 1 );
CTakeDamageInfo info( this, this, GetHealth(), DMG_CRUSH );
BaseClass::TakeDamage( info );
}
//-----------------------------------------------------------------------------
// Purpose: make m_bPreferPhysicsAttack true
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::InputEnablePreferPhysicsAttack( inputdata_t &inputdata )
{
m_bPreferPhysicsAttack = true;
}
//-----------------------------------------------------------------------------
// Purpose: make m_bPreferPhysicsAttack false
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::InputDisablePreferPhysicsAttack( inputdata_t &inputdata )
{
m_bPreferPhysicsAttack = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CNPC_AntlionGuard::SelectFailSchedule( int failedSchedule, int failedTask, AI_TaskFailureCode_t taskFailCode )
{
// Figure out what to do next
if ( failedSchedule == SCHED_ANTLIONGUARD_CHASE_ENEMY && HasCondition( COND_ENEMY_UNREACHABLE ) )
return SelectUnreachableSchedule();
return BaseClass::SelectFailSchedule( failedSchedule,failedTask, taskFailCode );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : scheduleType -
// Output : int
//-----------------------------------------------------------------------------
int CNPC_AntlionGuard::TranslateSchedule( int scheduleType )
{
switch( scheduleType )
{
case SCHED_CHASE_ENEMY:
return SCHED_ANTLIONGUARD_CHASE_ENEMY;
break;
}
return BaseClass::TranslateSchedule( scheduleType );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::StartSounds( void )
{
//Initialize the additive sound channels
CPASAttenuationFilter filter( this );
if ( m_pGrowlHighSound == NULL )
{
m_pGrowlHighSound = ENVELOPE_CONTROLLER.SoundCreate( filter, entindex(), CHAN_VOICE, "NPC_AntlionGuard.GrowlHigh", ATTN_NORM );
if ( m_pGrowlHighSound )
{
ENVELOPE_CONTROLLER.Play( m_pGrowlHighSound,0.0f, 100 );
}
}
if ( m_pGrowlIdleSound == NULL )
{
m_pGrowlIdleSound = ENVELOPE_CONTROLLER.SoundCreate( filter, entindex(), CHAN_STATIC, "NPC_AntlionGuard.GrowlIdle", ATTN_NORM );
if ( m_pGrowlIdleSound )
{
ENVELOPE_CONTROLLER.Play( m_pGrowlIdleSound,0.0f, 100 );
}
}
if ( m_pBreathSound == NULL )
{
m_pBreathSound = ENVELOPE_CONTROLLER.SoundCreate( filter, entindex(), CHAN_ITEM, "NPC_AntlionGuard.BreathSound", ATTN_NORM );
if ( m_pBreathSound )
{
ENVELOPE_CONTROLLER.Play( m_pBreathSound, 0.0f, 100 );
}
}
if ( m_pConfusedSound == NULL )
{
m_pConfusedSound = ENVELOPE_CONTROLLER.SoundCreate( filter, entindex(), CHAN_WEAPON,"NPC_AntlionGuard.Confused", ATTN_NORM );
if ( m_pConfusedSound )
{
ENVELOPE_CONTROLLER.Play( m_pConfusedSound, 0.0f, 100 );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::InputEnableBark( inputdata_t &inputdata )
{
m_bBarkEnabled = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::InputDisableBark( inputdata_t &inputdata )
{
m_bBarkEnabled = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::DeathSound( const CTakeDamageInfo &info )
{
EmitSound( "NPC_AntlionGuard.Die" );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &info -
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::Event_Killed( const CTakeDamageInfo &info )
{
BaseClass::Event_Killed( info );
// Tell all of my antlions to burrow away, 'cos they fear the Freeman
if ( m_iNumLiveAntlions )
{
CBaseEntity *pSearch = NULL;
// Iterate through all antlions and see if there are any orphans
while ( ( pSearch = gEntList.FindEntityByClassname( pSearch, "npc_antlion" ) ) != NULL )
{
CNPC_Antlion *pAntlion = assert_cast<CNPC_Antlion *>(pSearch);
// See if it's a live orphan
if ( pAntlion && pAntlion->GetOwnerEntity() == NULL && pAntlion->IsAlive() )
{
g_EventQueue.AddEvent( pAntlion, "BurrowAway", RandomFloat(0.1, 2.0), this, this );
}
}
}
DestroyGlows();
// If I'm bleeding, stop due to decreased pressure of hemolymph after
// cessation of aortic contraction
#if ANTLIONGUARD_BLOOD_EFFECTS
m_iBleedingLevel = 0;
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Don't become a ragdoll until we've finished our death anim
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_AntlionGuard::CanBecomeRagdoll( void )
{
if ( IsCurSchedule( SCHED_DIE ) )
return true;
return hl2_episodic.GetBool();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &force -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_AntlionGuard::BecomeRagdollOnClient( const Vector &force )
{
if ( !CanBecomeRagdoll() )
return false;
EmitSound( "NPC_AntlionGuard.Fallover" );
// Become server-side ragdoll if we're flagged to do it
if ( m_spawnflags & SF_ANTLIONGUARD_SERVERSIDE_RAGDOLL )
{
CTakeDamageInfo info;
// Fake the info
info.SetDamageType( DMG_GENERIC );
info.SetDamageForce( force );
info.SetDamagePosition( WorldSpaceCenter() );
CBaseEntity *pRagdoll = CreateServerRagdoll( this, 0, info, COLLISION_GROUP_NONE );
// Transfer our name to the new ragdoll
pRagdoll->SetName( GetEntityName() );
pRagdoll->SetCollisionGroup( COLLISION_GROUP_DEBRIS );
// Get rid of our old body
UTIL_Remove(this);
return true;
}
return BaseClass::BecomeRagdollOnClient( force );
}
//-----------------------------------------------------------------------------
// Purpose: Override how we face our target as we move
// Output :
//-----------------------------------------------------------------------------
bool CNPC_AntlionGuard::OverrideMoveFacing( const AILocalMoveGoal_t &move, float flInterval )
{
Vector vecFacePosition = vec3_origin;
CBaseEntity *pFaceTarget = NULL;
bool bFaceTarget = false;
// FIXME: this will break scripted sequences that walk when they have an enemy
if ( m_hChargeTarget )
{
vecFacePosition = m_hChargeTarget->GetAbsOrigin();
pFaceTarget = m_hChargeTarget;
bFaceTarget = true;
}
#ifdef HL2_EPISODIC
else if ( GetEnemy() && IsCurSchedule( SCHED_ANTLIONGUARD_CANT_ATTACK ) )
{
// Always face our enemy when randomly patrolling around
vecFacePosition = GetEnemy()->EyePosition();
pFaceTarget = GetEnemy();
bFaceTarget = true;
}
#endif // HL2_EPISODIC
else if ( GetEnemy() && GetNavigator()->GetMovementActivity() == ACT_RUN )
{
Vector vecEnemyLKP = GetEnemyLKP();
// Only start facing when we're close enough
if ( ( UTIL_DistApprox( vecEnemyLKP, GetAbsOrigin() ) < 512 ) || IsCurSchedule( SCHED_ANTLIONGUARD_PATROL_RUN ) )
{
vecFacePosition = vecEnemyLKP;
pFaceTarget = GetEnemy();
bFaceTarget = true;
}
}
// Face
if ( bFaceTarget )
{
AddFacingTarget( pFaceTarget, vecFacePosition, 1.0, 0.2 );
}
return BaseClass::OverrideMoveFacing( move, flInterval );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &info -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_AntlionGuard::IsHeavyDamage( const CTakeDamageInfo &info )
{
// Struck by blast
if ( info.GetDamageType() & DMG_BLAST )
{
if ( info.GetDamage() > MIN_BLAST_DAMAGE )
return true;
}
// Struck by large object
if ( info.GetDamageType() & DMG_CRUSH )
{
IPhysicsObject *pPhysObject = info.GetInflictor()->VPhysicsGetObject();
if ( ( pPhysObject != NULL ) && ( pPhysObject->GetGameFlags() & FVPHYSICS_WAS_THROWN ) )
{
// Always take hits from a combine ball
if ( UTIL_IsAR2CombineBall( info.GetInflictor() ) )
return true;
// If we're under half health, stop being interrupted by heavy damage
if ( GetHealth() < (GetMaxHealth() * 0.25) )
return false;
// Ignore physics damages that don't do much damage
if ( info.GetDamage() < MIN_CRUSH_DAMAGE )
return false;
return true;
}
return false;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &info -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_AntlionGuard::IsLightDamage( const CTakeDamageInfo &info )
{
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pChild -
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::InputSummonedAntlionDied( inputdata_t &inputdata )
{
m_iNumLiveAntlions--;
Assert( m_iNumLiveAntlions >= 0 );
if ( g_debug_antlionguard.GetInt() == 2 )
{
Msg("Guard summoned antlion count: %d\n", m_iNumLiveAntlions );
}
}
//-----------------------------------------------------------------------------
// Purpose: Filter out sounds we don't care about
// Input : *pSound - sound to test against
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_AntlionGuard::QueryHearSound( CSound *pSound )
{
// Don't bother with danger sounds from antlions or other guards
if ( pSound->SoundType() == SOUND_DANGER && ( pSound->m_hOwner != NULL && pSound->m_hOwner->Classify() == CLASS_ANTLION ) )
return false;
return BaseClass::QueryHearSound( pSound );
}
#if HL2_EPISODIC
//---------------------------------------------------------
// Prevent the cavern guard from using stopping paths, as it occasionally forces him off the navmesh.
//---------------------------------------------------------
bool CNPC_AntlionGuard::CNavigator::GetStoppingPath( CAI_WaypointList *pClippedWaypoints )
{
if (GetOuter()->m_bInCavern)
{
return false;
}
else
{
return BaseClass::GetStoppingPath( pClippedWaypoints );
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pTarget -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_AntlionGuard::RememberFailedPhysicsTarget( CBaseEntity *pTarget )
{
// Already in the list?
if ( m_FailedPhysicsTargets.Find( pTarget ) != m_FailedPhysicsTargets.InvalidIndex() )
return true;
// We're not holding on to any more
if ( ( m_FailedPhysicsTargets.Count() + 1 ) > MAX_FAILED_PHYSOBJECTS )
return false;
m_FailedPhysicsTargets.AddToTail( pTarget );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Handle squad or NPC interactions
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_AntlionGuard::HandleInteraction( int interactionType, void *data, CBaseCombatCharacter *sender )
{
// Don't chase targets that other guards in our squad may be going after!
if ( interactionType == g_interactionAntlionGuardFoundPhysicsObject )
{
RememberFailedPhysicsTarget( (CBaseEntity *) data );
return true;
}
// Mark a shoved object as being free to pursue again
if ( interactionType == g_interactionAntlionGuardShovedPhysicsObject )
{
CBaseEntity *pObject = (CBaseEntity *) data;
m_FailedPhysicsTargets.FindAndRemove( pObject );
return true;
}
return BaseClass::HandleInteraction( interactionType, data, sender );
}
//-----------------------------------------------------------------------------
// Purpose: Cache whatever pose parameters we intend to use
//-----------------------------------------------------------------------------
void CNPC_AntlionGuard::PopulatePoseParameters( void )
{
m_poseThrow = LookupPoseParameter("throw");
m_poseHead_Pitch = LookupPoseParameter("head_pitch");
m_poseHead_Yaw = LookupPoseParameter("head_yaw" );
BaseClass::PopulatePoseParameters();
}
#if ANTLIONGUARD_BLOOD_EFFECTS
//-----------------------------------------------------------------------------
// Purpose: Return desired level for the continuous bleeding effect (not the
// individual blood spurts you see per bullet hit)
// Return 0 for don't bleed,
// 1 for mild bleeding
// 2 for severe bleeding
//-----------------------------------------------------------------------------
unsigned char CNPC_AntlionGuard::GetBleedingLevel( void ) const
{
if ( m_iHealth > ( m_iMaxHealth >> 1 ) )
{ // greater than 50%
return 0;
}
else if ( m_iHealth > ( m_iMaxHealth >> 2 ) )
{ // less than 50% but greater than 25%
return 1;
}
else
{
return 2;
}
}
#endif
//-----------------------------------------------------------------------------
//
// Schedules
//
//-----------------------------------------------------------------------------
AI_BEGIN_CUSTOM_NPC( npc_antlionguard, CNPC_AntlionGuard )
// Interactions
DECLARE_INTERACTION( g_interactionAntlionGuardFoundPhysicsObject )
DECLARE_INTERACTION( g_interactionAntlionGuardShovedPhysicsObject )
// Squadslots
DECLARE_SQUADSLOT( SQUAD_SLOT_ANTLIONGUARD_CHARGE )
//Tasks
DECLARE_TASK( TASK_ANTLIONGUARD_CHARGE )
DECLARE_TASK( TASK_ANTLIONGUARD_GET_PATH_TO_PHYSOBJECT )
DECLARE_TASK( TASK_ANTLIONGUARD_SHOVE_PHYSOBJECT )
DECLARE_TASK( TASK_ANTLIONGUARD_SUMMON )
DECLARE_TASK( TASK_ANTLIONGUARD_SET_FLINCH_ACTIVITY )
DECLARE_TASK( TASK_ANTLIONGUARD_GET_PATH_TO_CHARGE_POSITION )
DECLARE_TASK( TASK_ANTLIONGUARD_GET_PATH_TO_NEAREST_NODE )
DECLARE_TASK( TASK_ANTLIONGUARD_GET_CHASE_PATH_ENEMY_TOLERANCE )
DECLARE_TASK( TASK_ANTLIONGUARD_OPPORTUNITY_THROW )
DECLARE_TASK( TASK_ANTLIONGUARD_FIND_PHYSOBJECT )
//Activities
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_SEARCH )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_PEEK_FLINCH )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_PEEK_ENTER )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_PEEK_EXIT )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_PEEK1 )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_BARK )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_PEEK_SIGHTED )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_CHARGE_START )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_CHARGE_CANCEL )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_CHARGE_RUN )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_CHARGE_CRASH )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_CHARGE_STOP )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_CHARGE_HIT )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_CHARGE_ANTICIPATION )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_SHOVE_PHYSOBJECT )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_FLINCH_LIGHT )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_UNBURROW )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_ROAR )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_RUN_HURT )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_PHYSHIT_FR )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_PHYSHIT_FL )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_PHYSHIT_RR )
DECLARE_ACTIVITY( ACT_ANTLIONGUARD_PHYSHIT_RL )
//Adrian: events go here
DECLARE_ANIMEVENT( AE_ANTLIONGUARD_CHARGE_HIT )
DECLARE_ANIMEVENT( AE_ANTLIONGUARD_SHOVE_PHYSOBJECT )
DECLARE_ANIMEVENT( AE_ANTLIONGUARD_SHOVE )
DECLARE_ANIMEVENT( AE_ANTLIONGUARD_FOOTSTEP_LIGHT )
DECLARE_ANIMEVENT( AE_ANTLIONGUARD_FOOTSTEP_HEAVY )
DECLARE_ANIMEVENT( AE_ANTLIONGUARD_CHARGE_EARLYOUT )
DECLARE_ANIMEVENT( AE_ANTLIONGUARD_VOICE_GROWL )
DECLARE_ANIMEVENT( AE_ANTLIONGUARD_VOICE_BARK )
DECLARE_ANIMEVENT( AE_ANTLIONGUARD_VOICE_PAIN )
DECLARE_ANIMEVENT( AE_ANTLIONGUARD_VOICE_SQUEEZE )
DECLARE_ANIMEVENT( AE_ANTLIONGUARD_VOICE_SCRATCH )
DECLARE_ANIMEVENT( AE_ANTLIONGUARD_VOICE_GRUNT )
DECLARE_ANIMEVENT( AE_ANTLIONGUARD_BURROW_OUT )
DECLARE_ANIMEVENT( AE_ANTLIONGUARD_VOICE_ROAR )
DECLARE_CONDITION( COND_ANTLIONGUARD_PHYSICS_TARGET )
DECLARE_CONDITION( COND_ANTLIONGUARD_PHYSICS_TARGET_INVALID )
DECLARE_CONDITION( COND_ANTLIONGUARD_HAS_CHARGE_TARGET )
DECLARE_CONDITION( COND_ANTLIONGUARD_CAN_SUMMON )
DECLARE_CONDITION( COND_ANTLIONGUARD_CAN_CHARGE )
//==================================================
// SCHED_ANTLIONGUARD_SUMMON
//==================================================
DEFINE_SCHEDULE
(
SCHED_ANTLIONGUARD_SUMMON,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_FACE_ENEMY 0"
" TASK_PLAY_SEQUENCE ACTIVITY:ACT_ANTLIONGUARD_BARK"
" TASK_ANTLIONGUARD_SUMMON 0"
" TASK_ANTLIONGUARD_OPPORTUNITY_THROW 0"
" "
" Interrupts"
" COND_HEAVY_DAMAGE"
)
//==================================================
// SCHED_ANTLIONGUARD_CHARGE
//==================================================
DEFINE_SCHEDULE
(
SCHED_ANTLIONGUARD_CHARGE,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_ANTLIONGUARD_CHASE_ENEMY"
" TASK_FACE_ENEMY 0"
" TASK_ANTLIONGUARD_CHARGE 0"
""
" Interrupts"
" COND_TASK_FAILED"
" COND_HEAVY_DAMAGE"
// These are deliberately left out so they can be detected during the
// charge Task and correctly play the charge stop animation.
//" COND_NEW_ENEMY"
//" COND_ENEMY_DEAD"
//" COND_LOST_ENEMY"
)
//==================================================
// SCHED_ANTLIONGUARD_CHARGE_TARGET
//==================================================
DEFINE_SCHEDULE
(
SCHED_ANTLIONGUARD_CHARGE_TARGET,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_FACE_ENEMY 0"
" TASK_ANTLIONGUARD_CHARGE 0"
""
" Interrupts"
" COND_TASK_FAILED"
" COND_ENEMY_DEAD"
" COND_HEAVY_DAMAGE"
)
//==================================================
// SCHED_ANTLIONGUARD_CHARGE_SMASH
//==================================================
DEFINE_SCHEDULE
(
SCHED_ANTLIONGUARD_CHARGE_CRASH,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_PLAY_SEQUENCE ACTIVITY:ACT_ANTLIONGUARD_CHARGE_CRASH"
""
" Interrupts"
" COND_TASK_FAILED"
" COND_HEAVY_DAMAGE"
)
//==================================================
// SCHED_ANTLIONGUARD_PHYSICS_ATTACK
//==================================================
DEFINE_SCHEDULE
(
SCHED_ANTLIONGUARD_PHYSICS_ATTACK,
" Tasks"
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_ANTLIONGUARD_CHASE_ENEMY"
" TASK_ANTLIONGUARD_GET_PATH_TO_PHYSOBJECT 0"
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
" TASK_FACE_ENEMY 0"
" TASK_ANTLIONGUARD_SHOVE_PHYSOBJECT 0"
""
" Interrupts"
" COND_TASK_FAILED"
" COND_ENEMY_DEAD"
" COND_LOST_ENEMY"
" COND_NEW_ENEMY"
" COND_ANTLIONGUARD_PHYSICS_TARGET_INVALID"
" COND_HEAVY_DAMAGE"
)
//==================================================
// SCHED_FORCE_ANTLIONGUARD_PHYSICS_ATTACK
//==================================================
DEFINE_SCHEDULE
(
SCHED_FORCE_ANTLIONGUARD_PHYSICS_ATTACK,
" Tasks"
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_ANTLIONGUARD_CANT_ATTACK"
" TASK_ANTLIONGUARD_FIND_PHYSOBJECT 0"
" TASK_SET_SCHEDULE SCHEDULE:SCHED_ANTLIONGUARD_PHYSICS_ATTACK"
""
" Interrupts"
" COND_ANTLIONGUARD_PHYSICS_TARGET"
" COND_HEAVY_DAMAGE"
)
//==================================================
// SCHED_ANTLIONGUARD_CANT_ATTACK
// If we're here, the guard can't chase enemy, can't find a physobject to attack with, and can't summon
//==================================================
#ifdef HL2_EPISODIC
DEFINE_SCHEDULE
(
SCHED_ANTLIONGUARD_CANT_ATTACK,
" Tasks"
" TASK_SET_ROUTE_SEARCH_TIME 2" // Spend 5 seconds trying to build a path if stuck
" TASK_GET_PATH_TO_RANDOM_NODE 1024"
" TASK_WALK_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
" TASK_WAIT_PVS 0"
""
" Interrupts"
" COND_GIVE_WAY"
" COND_NEW_ENEMY"
" COND_ANTLIONGUARD_PHYSICS_TARGET"
" COND_HEAVY_DAMAGE"
)
#else
DEFINE_SCHEDULE
(
SCHED_ANTLIONGUARD_CANT_ATTACK,
" Tasks"
" TASK_WAIT 5"
""
" Interrupts"
)
#endif
//==================================================
// SCHED_ANTLIONGUARD_PHYSICS_DAMAGE_HEAVY
//==================================================
DEFINE_SCHEDULE
(
SCHED_ANTLIONGUARD_PHYSICS_DAMAGE_HEAVY,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_RESET_ACTIVITY 0"
" TASK_ANTLIONGUARD_SET_FLINCH_ACTIVITY 0"
""
" Interrupts"
)
//==================================================
// SCHED_ANTLIONGUARD_UNBURROW
//==================================================
DEFINE_SCHEDULE
(
SCHED_ANTLIONGUARD_UNBURROW,
" Tasks"
" TASK_PLAY_SEQUENCE ACTIVITY:ACT_ANTLIONGUARD_UNBURROW"
""
" Interrupts"
)
//==================================================
// SCHED_ANTLIONGUARD_CHARGE_CANCEL
//==================================================
DEFINE_SCHEDULE
(
SCHED_ANTLIONGUARD_CHARGE_CANCEL,
" Tasks"
" TASK_PLAY_SEQUENCE ACTIVITY:ACT_ANTLIONGUARD_CHARGE_CANCEL"
""
" Interrupts"
)
//==================================================
// SCHED_ANTLIONGUARD_FIND_CHARGE_POSITION
//==================================================
DEFINE_SCHEDULE
(
SCHED_ANTLIONGUARD_FIND_CHARGE_POSITION,
" Tasks"
" TASK_ANTLIONGUARD_GET_PATH_TO_CHARGE_POSITION 0"
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
" "
" Interrupts"
" COND_ENEMY_DEAD"
" COND_GIVE_WAY"
" COND_TASK_FAILED"
" COND_HEAVY_DAMAGE"
)
//=========================================================
// > SCHED_ANTLIONGUARD_CHASE_ENEMY_TOLERANCE
//=========================================================
DEFINE_SCHEDULE
(
SCHED_ANTLIONGUARD_CHASE_ENEMY_TOLERANCE,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_ANTLIONGUARD_PATROL_RUN"
" TASK_ANTLIONGUARD_GET_PATH_TO_NEAREST_NODE 500"
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
" TASK_FACE_ENEMY 0"
""
" Interrupts"
" COND_TASK_FAILED"
" COND_CAN_MELEE_ATTACK1"
" COND_GIVE_WAY"
" COND_NEW_ENEMY"
" COND_ANTLIONGUARD_CAN_SUMMON"
" COND_ANTLIONGUARD_PHYSICS_TARGET"
" COND_HEAVY_DAMAGE"
" COND_ANTLIONGUARD_CAN_CHARGE"
);
//=========================================================
// > PATROL_RUN
//=========================================================
DEFINE_SCHEDULE
(
SCHED_ANTLIONGUARD_PATROL_RUN,
" Tasks"
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_ANTLIONGUARD_CANT_ATTACK"
" TASK_SET_ROUTE_SEARCH_TIME 3" // Spend 3 seconds trying to build a path if stuck
" TASK_ANTLIONGUARD_GET_PATH_TO_NEAREST_NODE 500"
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
""
" Interrupts"
" COND_TASK_FAILED"
" COND_CAN_MELEE_ATTACK1"
" COND_GIVE_WAY"
" COND_NEW_ENEMY"
" COND_ANTLIONGUARD_PHYSICS_TARGET"
" COND_ANTLIONGUARD_CAN_SUMMON"
" COND_HEAVY_DAMAGE"
" COND_ANTLIONGUARD_CAN_CHARGE"
);
//==================================================
// SCHED_ANTLIONGUARD_ROAR
//==================================================
DEFINE_SCHEDULE
(
SCHED_ANTLIONGUARD_ROAR,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_FACE_ENEMY 0"
" TASK_PLAY_SEQUENCE ACTIVITY:ACT_ANTLIONGUARD_ROAR"
" "
" Interrupts"
" COND_HEAVY_DAMAGE"
)
//==================================================
// SCHED_ANTLIONGUARD_TAKE_COVER_FROM_ENEMY
//==================================================
DEFINE_SCHEDULE
(
SCHED_ANTLIONGUARD_TAKE_COVER_FROM_ENEMY,
" Tasks"
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_ANTLIONGUARD_CANT_ATTACK"
" TASK_FIND_COVER_FROM_ENEMY 0"
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
" TASK_STOP_MOVING 0"
""
" Interrupts"
" COND_TASK_FAILED"
" COND_NEW_ENEMY"
" COND_ENEMY_DEAD"
" COND_ANTLIONGUARD_PHYSICS_TARGET"
" COND_ANTLIONGUARD_CAN_SUMMON"
" COND_HEAVY_DAMAGE"
)
//=========================================================
// SCHED_ANTLIONGUARD_CHASE_ENEMY
//=========================================================
DEFINE_SCHEDULE
(
SCHED_ANTLIONGUARD_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_TASK_FAILED"
" COND_LOST_ENEMY"
" COND_HEAVY_DAMAGE"
" COND_ANTLIONGUARD_CAN_CHARGE"
)
AI_END_CUSTOM_NPC()