You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2157 lines
57 KiB
2157 lines
57 KiB
![]()
4 years ago
|
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
|
//
|
||
|
// Purpose:
|
||
|
//
|
||
|
// $NoKeywords: $
|
||
|
//=============================================================================//
|
||
|
|
||
|
#include "cbase.h"
|
||
|
#include "ai_basenpc.h"
|
||
|
#include "ai_default.h"
|
||
|
#include "ai_schedule.h"
|
||
|
#include "ai_hull.h"
|
||
|
#include "ai_motor.h"
|
||
|
#include "ai_memory.h"
|
||
|
#include "ai_route.h"
|
||
|
#include "soundent.h"
|
||
|
#include "game.h"
|
||
|
#include "npcevent.h"
|
||
|
#include "entitylist.h"
|
||
|
#include "ai_task.h"
|
||
|
#include "activitylist.h"
|
||
|
#include "engine/IEngineSound.h"
|
||
|
#include "npc_BaseZombie.h"
|
||
|
#include "movevars_shared.h"
|
||
|
#include "IEffects.h"
|
||
|
#include "props.h"
|
||
|
#include "physics_npc_solver.h"
|
||
|
#include "physics_prop_ragdoll.h"
|
||
|
|
||
|
#ifdef HL2_EPISODIC
|
||
|
#include "episodic/ai_behavior_passenger_zombie.h"
|
||
|
#endif // HL2_EPISODIC
|
||
|
|
||
|
// memdbgon must be the last include file in a .cpp file!!!
|
||
|
#include "tier0/memdbgon.h"
|
||
|
|
||
|
#define FASTZOMBIE_IDLE_PITCH 35
|
||
|
#define FASTZOMBIE_MIN_PITCH 70
|
||
|
#define FASTZOMBIE_MAX_PITCH 130
|
||
|
#define FASTZOMBIE_SOUND_UPDATE_FREQ 0.5
|
||
|
|
||
|
#define FASTZOMBIE_MAXLEAP_Z 128
|
||
|
|
||
|
#define FASTZOMBIE_EXCITE_DIST 480.0
|
||
|
|
||
|
#define FASTZOMBIE_BASE_FREQ 1.5
|
||
|
|
||
|
// If flying at an enemy, and this close or closer, start playing the maul animation!!
|
||
|
#define FASTZOMBIE_MAUL_RANGE 300
|
||
|
|
||
|
#ifdef HL2_EPISODIC
|
||
|
|
||
|
int AE_PASSENGER_PHYSICS_PUSH;
|
||
|
int AE_FASTZOMBIE_VEHICLE_LEAP;
|
||
|
int AE_FASTZOMBIE_VEHICLE_SS_DIE; // Killed while doing scripted sequence on vehicle
|
||
|
|
||
|
#endif // HL2_EPISODIC
|
||
|
|
||
|
enum
|
||
|
{
|
||
|
COND_FASTZOMBIE_CLIMB_TOUCH = LAST_BASE_ZOMBIE_CONDITION,
|
||
|
};
|
||
|
|
||
|
envelopePoint_t envFastZombieVolumeJump[] =
|
||
|
{
|
||
|
{ 1.0f, 1.0f,
|
||
|
0.1f, 0.1f,
|
||
|
},
|
||
|
{ 0.0f, 0.0f,
|
||
|
1.0f, 1.2f,
|
||
|
},
|
||
|
};
|
||
|
|
||
|
envelopePoint_t envFastZombieVolumePain[] =
|
||
|
{
|
||
|
{ 1.0f, 1.0f,
|
||
|
0.1f, 0.1f,
|
||
|
},
|
||
|
{ 0.0f, 0.0f,
|
||
|
1.0f, 1.0f,
|
||
|
},
|
||
|
};
|
||
|
|
||
|
envelopePoint_t envFastZombieInverseVolumePain[] =
|
||
|
{
|
||
|
{ 0.0f, 0.0f,
|
||
|
0.1f, 0.1f,
|
||
|
},
|
||
|
{ 1.0f, 1.0f,
|
||
|
1.0f, 1.0f,
|
||
|
},
|
||
|
};
|
||
|
|
||
|
envelopePoint_t envFastZombieVolumeJumpPostApex[] =
|
||
|
{
|
||
|
{ 1.0f, 1.0f,
|
||
|
0.1f, 0.1f,
|
||
|
},
|
||
|
{ 0.0f, 0.0f,
|
||
|
1.0f, 1.2f,
|
||
|
},
|
||
|
};
|
||
|
|
||
|
envelopePoint_t envFastZombieVolumeClimb[] =
|
||
|
{
|
||
|
{ 1.0f, 1.0f,
|
||
|
0.1f, 0.1f,
|
||
|
},
|
||
|
{ 0.0f, 0.0f,
|
||
|
0.2f, 0.2f,
|
||
|
},
|
||
|
};
|
||
|
|
||
|
envelopePoint_t envFastZombieMoanVolumeFast[] =
|
||
|
{
|
||
|
{ 1.0f, 1.0f,
|
||
|
0.1f, 0.1f,
|
||
|
},
|
||
|
{ 0.0f, 0.0f,
|
||
|
0.2f, 0.3f,
|
||
|
},
|
||
|
};
|
||
|
|
||
|
envelopePoint_t envFastZombieMoanVolume[] =
|
||
|
{
|
||
|
{ 1.0f, 1.0f,
|
||
|
0.1f, 0.1f,
|
||
|
},
|
||
|
{ 1.0f, 1.0f,
|
||
|
0.2f, 0.2f,
|
||
|
},
|
||
|
{ 0.0f, 0.0f,
|
||
|
1.0f, 0.4f,
|
||
|
},
|
||
|
};
|
||
|
|
||
|
envelopePoint_t envFastZombieFootstepVolume[] =
|
||
|
{
|
||
|
{ 1.0f, 1.0f,
|
||
|
0.1f, 0.1f,
|
||
|
},
|
||
|
{ 0.7f, 0.7f,
|
||
|
0.2f, 0.2f,
|
||
|
},
|
||
|
};
|
||
|
|
||
|
envelopePoint_t envFastZombieVolumeFrenzy[] =
|
||
|
{
|
||
|
{ 1.0f, 1.0f,
|
||
|
0.1f, 0.1f,
|
||
|
},
|
||
|
{ 0.0f, 0.0f,
|
||
|
2.0f, 2.0f,
|
||
|
},
|
||
|
};
|
||
|
|
||
|
|
||
|
//=========================================================
|
||
|
// animation events
|
||
|
//=========================================================
|
||
|
int AE_FASTZOMBIE_LEAP;
|
||
|
int AE_FASTZOMBIE_GALLOP_LEFT;
|
||
|
int AE_FASTZOMBIE_GALLOP_RIGHT;
|
||
|
int AE_FASTZOMBIE_CLIMB_LEFT;
|
||
|
int AE_FASTZOMBIE_CLIMB_RIGHT;
|
||
|
|
||
|
//=========================================================
|
||
|
// tasks
|
||
|
//=========================================================
|
||
|
enum
|
||
|
{
|
||
|
TASK_FASTZOMBIE_DO_ATTACK = LAST_SHARED_TASK + 100, // again, my !!!HACKHACK
|
||
|
TASK_FASTZOMBIE_LAND_RECOVER,
|
||
|
TASK_FASTZOMBIE_UNSTICK_JUMP,
|
||
|
TASK_FASTZOMBIE_JUMP_BACK,
|
||
|
TASK_FASTZOMBIE_VERIFY_ATTACK,
|
||
|
};
|
||
|
|
||
|
//=========================================================
|
||
|
// activities
|
||
|
//=========================================================
|
||
|
int ACT_FASTZOMBIE_LEAP_SOAR;
|
||
|
int ACT_FASTZOMBIE_LEAP_STRIKE;
|
||
|
int ACT_FASTZOMBIE_LAND_RIGHT;
|
||
|
int ACT_FASTZOMBIE_LAND_LEFT;
|
||
|
int ACT_FASTZOMBIE_FRENZY;
|
||
|
int ACT_FASTZOMBIE_BIG_SLASH;
|
||
|
|
||
|
//=========================================================
|
||
|
// schedules
|
||
|
//=========================================================
|
||
|
enum
|
||
|
{
|
||
|
SCHED_FASTZOMBIE_RANGE_ATTACK1 = LAST_SHARED_SCHEDULE + 100, // hack to get past the base zombie's schedules
|
||
|
SCHED_FASTZOMBIE_UNSTICK_JUMP,
|
||
|
SCHED_FASTZOMBIE_CLIMBING_UNSTICK_JUMP,
|
||
|
SCHED_FASTZOMBIE_MELEE_ATTACK1,
|
||
|
SCHED_FASTZOMBIE_TORSO_MELEE_ATTACK1,
|
||
|
};
|
||
|
|
||
|
|
||
|
|
||
|
//=========================================================
|
||
|
//=========================================================
|
||
|
class CFastZombie : public CNPC_BaseZombie
|
||
|
{
|
||
|
DECLARE_CLASS( CFastZombie, CNPC_BaseZombie );
|
||
|
|
||
|
public:
|
||
|
void Spawn( void );
|
||
|
void Precache( void );
|
||
|
|
||
|
void SetZombieModel( void );
|
||
|
bool CanSwatPhysicsObjects( void ) { return false; }
|
||
|
|
||
|
int TranslateSchedule( int scheduleType );
|
||
|
|
||
|
Activity NPC_TranslateActivity( Activity baseAct );
|
||
|
|
||
|
void LeapAttackTouch( CBaseEntity *pOther );
|
||
|
void ClimbTouch( CBaseEntity *pOther );
|
||
|
|
||
|
void StartTask( const Task_t *pTask );
|
||
|
void RunTask( const Task_t *pTask );
|
||
|
int SelectSchedule( void );
|
||
|
void OnScheduleChange( void );
|
||
|
|
||
|
void PrescheduleThink( void );
|
||
|
|
||
|
float InnateRange1MaxRange( void );
|
||
|
int RangeAttack1Conditions( float flDot, float flDist );
|
||
|
int MeleeAttack1Conditions( float flDot, float flDist );
|
||
|
|
||
|
virtual float GetClawAttackRange() const { return 50; }
|
||
|
|
||
|
bool ShouldPlayFootstepMoan( void ) { return false; }
|
||
|
|
||
|
void HandleAnimEvent( animevent_t *pEvent );
|
||
|
|
||
|
void PostNPCInit( void );
|
||
|
|
||
|
void LeapAttack( void );
|
||
|
void LeapAttackSound( void );
|
||
|
|
||
|
void BecomeTorso( const Vector &vecTorsoForce, const Vector &vecLegsForce );
|
||
|
|
||
|
bool IsJumpLegal(const Vector &startPos, const Vector &apex, const Vector &endPos) const;
|
||
|
bool MovementCost( int moveType, const Vector &vecStart, const Vector &vecEnd, float *pCost );
|
||
|
bool ShouldFailNav( bool bMovementFailed );
|
||
|
|
||
|
int SelectFailSchedule( int failedSchedule, int failedTask, AI_TaskFailureCode_t taskFailCode );
|
||
|
|
||
|
const char *GetMoanSound( int nSound );
|
||
|
|
||
|
void OnChangeActivity( Activity NewActivity );
|
||
|
void OnStateChange( NPC_STATE OldState, NPC_STATE NewState );
|
||
|
void Event_Killed( const CTakeDamageInfo &info );
|
||
|
bool ShouldBecomeTorso( const CTakeDamageInfo &info, float flDamageThreshold );
|
||
|
|
||
|
virtual Vector GetAutoAimCenter() { return WorldSpaceCenter() - Vector( 0, 0, 12.0f ); }
|
||
|
|
||
|
void PainSound( const CTakeDamageInfo &info );
|
||
|
void DeathSound( const CTakeDamageInfo &info );
|
||
|
void AlertSound( void );
|
||
|
void IdleSound( void );
|
||
|
void AttackSound( void );
|
||
|
void AttackHitSound( void );
|
||
|
void AttackMissSound( void );
|
||
|
void FootstepSound( bool fRightFoot );
|
||
|
void FootscuffSound( bool fRightFoot ) {}; // fast guy doesn't scuff
|
||
|
void StopLoopingSounds( void );
|
||
|
|
||
|
void SoundInit( void );
|
||
|
void SetIdleSoundState( void );
|
||
|
void SetAngrySoundState( void );
|
||
|
|
||
|
void BuildScheduleTestBits( void );
|
||
|
|
||
|
void BeginNavJump( void );
|
||
|
void EndNavJump( void );
|
||
|
|
||
|
bool IsNavJumping( void ) { return m_fIsNavJumping; }
|
||
|
void OnNavJumpHitApex( void );
|
||
|
|
||
|
void BeginAttackJump( void );
|
||
|
void EndAttackJump( void );
|
||
|
|
||
|
float MaxYawSpeed( void );
|
||
|
|
||
|
virtual const char *GetHeadcrabClassname( void );
|
||
|
virtual const char *GetHeadcrabModel( void );
|
||
|
virtual const char *GetLegsModel( void );
|
||
|
virtual const char *GetTorsoModel( void );
|
||
|
|
||
|
//=============================================================================
|
||
|
#ifdef HL2_EPISODIC
|
||
|
|
||
|
public:
|
||
|
virtual bool CreateBehaviors( void );
|
||
|
virtual void VPhysicsCollision( int index, gamevcollisionevent_t *pEvent );
|
||
|
virtual void UpdateEfficiency( bool bInPVS );
|
||
|
virtual bool IsInAVehicle( void );
|
||
|
void InputAttachToVehicle( inputdata_t &inputdata );
|
||
|
void VehicleLeapAttackTouch( CBaseEntity *pOther );
|
||
|
|
||
|
private:
|
||
|
void VehicleLeapAttack( void );
|
||
|
bool CanEnterVehicle( CPropJeepEpisodic *pVehicle );
|
||
|
|
||
|
CAI_PassengerBehaviorZombie m_PassengerBehavior;
|
||
|
|
||
|
#endif // HL2_EPISODIC
|
||
|
//=============================================================================
|
||
|
|
||
|
protected:
|
||
|
|
||
|
static const char *pMoanSounds[];
|
||
|
|
||
|
// Sound stuff
|
||
|
float m_flDistFactor;
|
||
|
unsigned char m_iClimbCount; // counts rungs climbed (for sound)
|
||
|
bool m_fIsNavJumping;
|
||
|
bool m_fIsAttackJumping;
|
||
|
bool m_fHitApex;
|
||
|
mutable float m_flJumpDist;
|
||
|
|
||
|
bool m_fHasScreamed;
|
||
|
|
||
|
private:
|
||
|
float m_flNextMeleeAttack;
|
||
|
bool m_fJustJumped;
|
||
|
float m_flJumpStartAltitude;
|
||
|
float m_flTimeUpdateSound;
|
||
|
|
||
|
CSoundPatch *m_pLayer2; // used for climbing ladders, and when jumping (pre apex)
|
||
|
|
||
|
public:
|
||
|
DEFINE_CUSTOM_AI;
|
||
|
DECLARE_DATADESC();
|
||
|
};
|
||
|
|
||
|
LINK_ENTITY_TO_CLASS( npc_fastzombie, CFastZombie );
|
||
|
LINK_ENTITY_TO_CLASS( npc_fastzombie_torso, CFastZombie );
|
||
|
|
||
|
|
||
|
BEGIN_DATADESC( CFastZombie )
|
||
|
|
||
|
DEFINE_FIELD( m_flDistFactor, FIELD_FLOAT ),
|
||
|
DEFINE_FIELD( m_iClimbCount, FIELD_CHARACTER ),
|
||
|
DEFINE_FIELD( m_fIsNavJumping, FIELD_BOOLEAN ),
|
||
|
DEFINE_FIELD( m_fIsAttackJumping, FIELD_BOOLEAN ),
|
||
|
DEFINE_FIELD( m_fHitApex, FIELD_BOOLEAN ),
|
||
|
DEFINE_FIELD( m_flJumpDist, FIELD_FLOAT ),
|
||
|
DEFINE_FIELD( m_fHasScreamed, FIELD_BOOLEAN ),
|
||
|
DEFINE_FIELD( m_flNextMeleeAttack, FIELD_TIME ),
|
||
|
DEFINE_FIELD( m_fJustJumped, FIELD_BOOLEAN ),
|
||
|
DEFINE_FIELD( m_flJumpStartAltitude, FIELD_FLOAT ),
|
||
|
DEFINE_FIELD( m_flTimeUpdateSound, FIELD_TIME ),
|
||
|
|
||
|
// Function Pointers
|
||
|
DEFINE_ENTITYFUNC( LeapAttackTouch ),
|
||
|
DEFINE_ENTITYFUNC( ClimbTouch ),
|
||
|
DEFINE_SOUNDPATCH( m_pLayer2 ),
|
||
|
|
||
|
#ifdef HL2_EPISODIC
|
||
|
DEFINE_ENTITYFUNC( VehicleLeapAttackTouch ),
|
||
|
DEFINE_INPUTFUNC( FIELD_STRING, "AttachToVehicle", InputAttachToVehicle ),
|
||
|
#endif // HL2_EPISODIC
|
||
|
|
||
|
END_DATADESC()
|
||
|
|
||
|
|
||
|
const char *CFastZombie::pMoanSounds[] =
|
||
|
{
|
||
|
"NPC_FastZombie.Moan1",
|
||
|
};
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// The model we use for our legs when we get blowed up.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
static const char *s_pLegsModel = "models/gibs/fast_zombie_legs.mdl";
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::Precache( void )
|
||
|
{
|
||
|
PrecacheModel("models/zombie/fast.mdl");
|
||
|
#ifdef HL2_EPISODIC
|
||
|
PrecacheModel("models/zombie/Fast_torso.mdl");
|
||
|
PrecacheScriptSound( "NPC_FastZombie.CarEnter1" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.CarEnter2" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.CarEnter3" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.CarEnter4" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.CarScream" );
|
||
|
#endif
|
||
|
PrecacheModel( "models/gibs/fast_zombie_torso.mdl" );
|
||
|
PrecacheModel( "models/gibs/fast_zombie_legs.mdl" );
|
||
|
|
||
|
PrecacheScriptSound( "NPC_FastZombie.LeapAttack" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.FootstepRight" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.FootstepLeft" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.AttackHit" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.AttackMiss" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.LeapAttack" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.Attack" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.Idle" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.AlertFar" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.AlertNear" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.GallopLeft" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.GallopRight" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.Scream" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.RangeAttack" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.Frenzy" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.NoSound" );
|
||
|
PrecacheScriptSound( "NPC_FastZombie.Die" );
|
||
|
|
||
|
PrecacheScriptSound( "NPC_FastZombie.Gurgle" );
|
||
|
|
||
|
PrecacheScriptSound( "NPC_FastZombie.Moan1" );
|
||
|
|
||
|
BaseClass::Precache();
|
||
|
}
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
//---------------------------------------------------------
|
||
|
void CFastZombie::OnScheduleChange( void )
|
||
|
{
|
||
|
if ( m_flNextMeleeAttack > gpGlobals->curtime + 1 )
|
||
|
{
|
||
|
// Allow melee attacks again.
|
||
|
m_flNextMeleeAttack = gpGlobals->curtime + 0.5;
|
||
|
}
|
||
|
|
||
|
BaseClass::OnScheduleChange();
|
||
|
}
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
//---------------------------------------------------------
|
||
|
int CFastZombie::SelectSchedule ( void )
|
||
|
{
|
||
|
|
||
|
// ========================================================
|
||
|
#ifdef HL2_EPISODIC
|
||
|
|
||
|
// Defer all decisions to the behavior if it's running
|
||
|
if ( m_PassengerBehavior.CanSelectSchedule() )
|
||
|
{
|
||
|
DeferSchedulingToBehavior( &m_PassengerBehavior );
|
||
|
return BaseClass::SelectSchedule();
|
||
|
}
|
||
|
|
||
|
#endif //HL2_EPISODIC
|
||
|
// ========================================================
|
||
|
|
||
|
if ( HasCondition( COND_ZOMBIE_RELEASECRAB ) )
|
||
|
{
|
||
|
// Death waits for no man. Or zombie. Or something.
|
||
|
return SCHED_ZOMBIE_RELEASECRAB;
|
||
|
}
|
||
|
|
||
|
if ( HasCondition( COND_FASTZOMBIE_CLIMB_TOUCH ) )
|
||
|
{
|
||
|
return SCHED_FASTZOMBIE_UNSTICK_JUMP;
|
||
|
}
|
||
|
|
||
|
switch ( m_NPCState )
|
||
|
{
|
||
|
case NPC_STATE_COMBAT:
|
||
|
if ( HasCondition( COND_LOST_ENEMY ) || ( HasCondition( COND_ENEMY_UNREACHABLE ) && MustCloseToAttack() ) )
|
||
|
{
|
||
|
// Set state to alert and recurse!
|
||
|
SetState( NPC_STATE_ALERT );
|
||
|
return SelectSchedule();
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
case NPC_STATE_ALERT:
|
||
|
if ( HasCondition( COND_LOST_ENEMY ) || ( HasCondition( COND_ENEMY_UNREACHABLE ) && MustCloseToAttack() ) )
|
||
|
{
|
||
|
ClearCondition( COND_LOST_ENEMY );
|
||
|
ClearCondition( COND_ENEMY_UNREACHABLE );
|
||
|
SetEnemy( NULL );
|
||
|
|
||
|
#ifdef DEBUG_ZOMBIES
|
||
|
DevMsg("Wandering\n");
|
||
|
#endif
|
||
|
|
||
|
// Just lost track of our enemy.
|
||
|
// Wander around a bit so we don't look like a dingus.
|
||
|
return SCHED_ZOMBIE_WANDER_MEDIUM;
|
||
|
}
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
return BaseClass::SelectSchedule();
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::PrescheduleThink( void )
|
||
|
{
|
||
|
BaseClass::PrescheduleThink();
|
||
|
|
||
|
if( GetGroundEntity() && GetGroundEntity()->Classify() == CLASS_HEADCRAB )
|
||
|
{
|
||
|
// Kill!
|
||
|
CTakeDamageInfo info;
|
||
|
info.SetDamage( GetGroundEntity()->GetHealth() );
|
||
|
info.SetAttacker( this );
|
||
|
info.SetInflictor( this );
|
||
|
info.SetDamageType( DMG_GENERIC );
|
||
|
GetGroundEntity()->TakeDamage( info );
|
||
|
}
|
||
|
|
||
|
if( m_pMoanSound && gpGlobals->curtime > m_flTimeUpdateSound )
|
||
|
{
|
||
|
// Manage the snorting sound, pitch up for closer.
|
||
|
float flDistNoBBox;
|
||
|
|
||
|
if( GetEnemy() && m_NPCState == NPC_STATE_COMBAT )
|
||
|
{
|
||
|
flDistNoBBox = ( GetEnemy()->WorldSpaceCenter() - WorldSpaceCenter() ).Length();
|
||
|
flDistNoBBox -= WorldAlignSize().x;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Calm down!
|
||
|
flDistNoBBox = FASTZOMBIE_EXCITE_DIST;
|
||
|
m_flTimeUpdateSound += 1.0;
|
||
|
}
|
||
|
|
||
|
if( flDistNoBBox >= FASTZOMBIE_EXCITE_DIST && m_flDistFactor != 1.0 )
|
||
|
{
|
||
|
// Go back to normal pitch.
|
||
|
m_flDistFactor = 1.0;
|
||
|
|
||
|
ENVELOPE_CONTROLLER.SoundChangePitch( m_pMoanSound, FASTZOMBIE_IDLE_PITCH, FASTZOMBIE_SOUND_UPDATE_FREQ );
|
||
|
}
|
||
|
else if( flDistNoBBox < FASTZOMBIE_EXCITE_DIST )
|
||
|
{
|
||
|
// Zombie is close! Recalculate pitch.
|
||
|
int iPitch;
|
||
|
|
||
|
m_flDistFactor = MIN( 1.0, 1 - flDistNoBBox / FASTZOMBIE_EXCITE_DIST );
|
||
|
iPitch = FASTZOMBIE_MIN_PITCH + ( ( FASTZOMBIE_MAX_PITCH - FASTZOMBIE_MIN_PITCH ) * m_flDistFactor);
|
||
|
ENVELOPE_CONTROLLER.SoundChangePitch( m_pMoanSound, iPitch, FASTZOMBIE_SOUND_UPDATE_FREQ );
|
||
|
}
|
||
|
|
||
|
m_flTimeUpdateSound = gpGlobals->curtime + FASTZOMBIE_SOUND_UPDATE_FREQ;
|
||
|
}
|
||
|
|
||
|
// Crudely detect the apex of our jump
|
||
|
if( IsNavJumping() && !m_fHitApex && GetAbsVelocity().z <= 0.0 )
|
||
|
{
|
||
|
OnNavJumpHitApex();
|
||
|
}
|
||
|
|
||
|
if( IsCurSchedule(SCHED_FASTZOMBIE_RANGE_ATTACK1, false) )
|
||
|
{
|
||
|
// Think more frequently when flying quickly through the
|
||
|
// air, to update the server's location more often.
|
||
|
SetNextThink(gpGlobals->curtime);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Startup all of the sound patches that the fast zombie uses.
|
||
|
//
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::SoundInit( void )
|
||
|
{
|
||
|
if( !m_pMoanSound )
|
||
|
{
|
||
|
// !!!HACKHACK - kickstart the moan sound. (sjb)
|
||
|
MoanSound( envFastZombieMoanVolume, ARRAYSIZE( envFastZombieMoanVolume ) );
|
||
|
|
||
|
// Clear the commands that the base class gave the moaning sound channel.
|
||
|
ENVELOPE_CONTROLLER.CommandClear( m_pMoanSound );
|
||
|
}
|
||
|
|
||
|
CPASAttenuationFilter filter( this );
|
||
|
|
||
|
if( !m_pLayer2 )
|
||
|
{
|
||
|
// Set up layer2
|
||
|
m_pLayer2 = ENVELOPE_CONTROLLER.SoundCreate( filter, entindex(), CHAN_VOICE, "NPC_FastZombie.Gurgle", ATTN_NORM );
|
||
|
|
||
|
// Start silent.
|
||
|
ENVELOPE_CONTROLLER.Play( m_pLayer2, 0.0, 100 );
|
||
|
}
|
||
|
|
||
|
SetIdleSoundState();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Make the zombie sound calm.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::SetIdleSoundState( void )
|
||
|
{
|
||
|
// Main looping sound
|
||
|
if ( m_pMoanSound )
|
||
|
{
|
||
|
ENVELOPE_CONTROLLER.SoundChangePitch( m_pMoanSound, FASTZOMBIE_IDLE_PITCH, 1.0 );
|
||
|
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pMoanSound, 0.75, 1.0 );
|
||
|
}
|
||
|
|
||
|
// Second Layer
|
||
|
if ( m_pLayer2 )
|
||
|
{
|
||
|
ENVELOPE_CONTROLLER.SoundChangePitch( m_pLayer2, 100, 1.0 );
|
||
|
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pLayer2, 0.0, 1.0 );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Make the zombie sound pizzled
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::SetAngrySoundState( void )
|
||
|
{
|
||
|
if (( !m_pMoanSound ) || ( !m_pLayer2 ))
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
EmitSound( "NPC_FastZombie.LeapAttack" );
|
||
|
|
||
|
// Main looping sound
|
||
|
ENVELOPE_CONTROLLER.SoundChangePitch( m_pMoanSound, FASTZOMBIE_MIN_PITCH, 0.5 );
|
||
|
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pMoanSound, 1.0, 0.5 );
|
||
|
|
||
|
// Second Layer
|
||
|
ENVELOPE_CONTROLLER.SoundChangePitch( m_pLayer2, 100, 1.0 );
|
||
|
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pLayer2, 0.0, 1.0 );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::Spawn( void )
|
||
|
{
|
||
|
Precache();
|
||
|
|
||
|
m_fJustJumped = false;
|
||
|
|
||
|
m_fIsTorso = m_fIsHeadless = false;
|
||
|
|
||
|
if( FClassnameIs( this, "npc_fastzombie" ) )
|
||
|
{
|
||
|
m_fIsTorso = false;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// This was placed as an npc_fastzombie_torso
|
||
|
m_fIsTorso = true;
|
||
|
}
|
||
|
|
||
|
#ifdef HL2_EPISODIC
|
||
|
SetBloodColor( BLOOD_COLOR_ZOMBIE );
|
||
|
#else
|
||
|
SetBloodColor( BLOOD_COLOR_YELLOW );
|
||
|
#endif // HL2_EPISODIC
|
||
|
|
||
|
m_iHealth = 50;
|
||
|
m_flFieldOfView = 0.2;
|
||
|
|
||
|
CapabilitiesClear();
|
||
|
CapabilitiesAdd( bits_CAP_MOVE_CLIMB | bits_CAP_MOVE_JUMP | bits_CAP_MOVE_GROUND | bits_CAP_INNATE_RANGE_ATTACK1 /* | bits_CAP_INNATE_MELEE_ATTACK1 */);
|
||
|
|
||
|
if ( m_fIsTorso == true )
|
||
|
{
|
||
|
CapabilitiesRemove( bits_CAP_MOVE_JUMP | bits_CAP_INNATE_RANGE_ATTACK1 );
|
||
|
}
|
||
|
|
||
|
m_flNextAttack = gpGlobals->curtime;
|
||
|
|
||
|
m_pLayer2 = NULL;
|
||
|
m_iClimbCount = 0;
|
||
|
|
||
|
EndNavJump();
|
||
|
|
||
|
m_flDistFactor = 1.0;
|
||
|
|
||
|
BaseClass::Spawn();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::PostNPCInit( void )
|
||
|
{
|
||
|
SoundInit();
|
||
|
|
||
|
m_flTimeUpdateSound = gpGlobals->curtime;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Returns the classname (ie "npc_headcrab") to spawn when our headcrab bails.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
const char *CFastZombie::GetHeadcrabClassname( void )
|
||
|
{
|
||
|
return "npc_headcrab_fast";
|
||
|
}
|
||
|
|
||
|
const char *CFastZombie::GetHeadcrabModel( void )
|
||
|
{
|
||
|
return "models/headcrab.mdl";
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
float CFastZombie::MaxYawSpeed( void )
|
||
|
{
|
||
|
switch( GetActivity() )
|
||
|
{
|
||
|
case ACT_TURN_LEFT:
|
||
|
case ACT_TURN_RIGHT:
|
||
|
return 120;
|
||
|
break;
|
||
|
|
||
|
case ACT_RUN:
|
||
|
return 160;
|
||
|
break;
|
||
|
|
||
|
case ACT_WALK:
|
||
|
case ACT_IDLE:
|
||
|
return 25;
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
return 20;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::SetZombieModel( void )
|
||
|
{
|
||
|
Hull_t lastHull = GetHullType();
|
||
|
|
||
|
if ( m_fIsTorso )
|
||
|
{
|
||
|
SetModel( "models/zombie/fast_torso.mdl" );
|
||
|
SetHullType(HULL_TINY);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
SetModel( "models/zombie/fast.mdl" );
|
||
|
SetHullType(HULL_HUMAN);
|
||
|
}
|
||
|
|
||
|
SetBodygroup( ZOMBIE_BODYGROUP_HEADCRAB, !m_fIsHeadless );
|
||
|
|
||
|
SetHullSizeNormal( true );
|
||
|
SetDefaultEyeOffset();
|
||
|
SetActivity( ACT_IDLE );
|
||
|
|
||
|
// hull changed size, notify vphysics
|
||
|
// UNDONE: Solve this generally, systematically so other
|
||
|
// NPCs can change size
|
||
|
if ( lastHull != GetHullType() )
|
||
|
{
|
||
|
if ( VPhysicsGetObject() )
|
||
|
{
|
||
|
SetupVPhysicsHull();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Returns the model to use for our legs ragdoll when we are blown in twain.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
const char *CFastZombie::GetLegsModel( void )
|
||
|
{
|
||
|
return s_pLegsModel;
|
||
|
}
|
||
|
|
||
|
const char *CFastZombie::GetTorsoModel( void )
|
||
|
{
|
||
|
return "models/gibs/fast_zombie_torso.mdl";
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: See if I can swat the player
|
||
|
//
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
int CFastZombie::MeleeAttack1Conditions( float flDot, float flDist )
|
||
|
{
|
||
|
if ( !GetEnemy() )
|
||
|
{
|
||
|
return COND_NONE;
|
||
|
}
|
||
|
|
||
|
if( !(GetFlags() & FL_ONGROUND) )
|
||
|
{
|
||
|
// Have to be on the ground!
|
||
|
return COND_NONE;
|
||
|
}
|
||
|
|
||
|
if( gpGlobals->curtime < m_flNextMeleeAttack )
|
||
|
{
|
||
|
return COND_NONE;
|
||
|
}
|
||
|
|
||
|
int baseResult = BaseClass::MeleeAttack1Conditions( flDot, flDist );
|
||
|
|
||
|
// @TODO (toml 07-21-04): follow up with Steve to find out why fz was explicitly not using these conditions
|
||
|
if ( baseResult == COND_TOO_FAR_TO_ATTACK || baseResult == COND_NOT_FACING_ATTACK )
|
||
|
{
|
||
|
return COND_NONE;
|
||
|
}
|
||
|
|
||
|
return baseResult;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Returns a moan sound for this class of zombie.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
const char *CFastZombie::GetMoanSound( int nSound )
|
||
|
{
|
||
|
return pMoanSounds[ nSound % ARRAYSIZE( pMoanSounds ) ];
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Sound of a footstep
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::FootstepSound( bool fRightFoot )
|
||
|
{
|
||
|
if( fRightFoot )
|
||
|
{
|
||
|
EmitSound( "NPC_FastZombie.FootstepRight" );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
EmitSound( "NPC_FastZombie.FootstepLeft" );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Play a random attack hit sound
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::AttackHitSound( void )
|
||
|
{
|
||
|
EmitSound( "NPC_FastZombie.AttackHit" );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Play a random attack miss sound
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::AttackMissSound( void )
|
||
|
{
|
||
|
// Play a random attack miss sound
|
||
|
EmitSound( "NPC_FastZombie.AttackMiss" );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Play a random attack sound.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::LeapAttackSound( void )
|
||
|
{
|
||
|
EmitSound( "NPC_FastZombie.LeapAttack" );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Play a random attack sound.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::AttackSound( void )
|
||
|
{
|
||
|
EmitSound( "NPC_FastZombie.Attack" );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Play a random idle sound.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::IdleSound( void )
|
||
|
{
|
||
|
EmitSound( "NPC_FastZombie.Idle" );
|
||
|
MakeAISpookySound( 360.0f );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Play a random pain sound.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::PainSound( const CTakeDamageInfo &info )
|
||
|
{
|
||
|
if ( m_pLayer2 )
|
||
|
ENVELOPE_CONTROLLER.SoundPlayEnvelope( m_pLayer2, SOUNDCTRL_CHANGE_VOLUME, envFastZombieVolumePain, ARRAYSIZE(envFastZombieVolumePain) );
|
||
|
if ( m_pMoanSound )
|
||
|
ENVELOPE_CONTROLLER.SoundPlayEnvelope( m_pMoanSound, SOUNDCTRL_CHANGE_VOLUME, envFastZombieInverseVolumePain, ARRAYSIZE(envFastZombieInverseVolumePain) );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::DeathSound( const CTakeDamageInfo &info )
|
||
|
{
|
||
|
EmitSound( "NPC_FastZombie.Die" );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Play a random alert sound.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::AlertSound( void )
|
||
|
{
|
||
|
CBaseEntity *pPlayer = AI_GetSinglePlayer();
|
||
|
|
||
|
if( pPlayer )
|
||
|
{
|
||
|
// Measure how far the player is, and play the appropriate type of alert sound.
|
||
|
// Doesn't matter if I'm getting mad at a different character, the player is the
|
||
|
// one that hears the sound.
|
||
|
float flDist;
|
||
|
|
||
|
flDist = ( GetAbsOrigin() - pPlayer->GetAbsOrigin() ).Length();
|
||
|
|
||
|
if( flDist > 512 )
|
||
|
{
|
||
|
EmitSound( "NPC_FastZombie.AlertFar" );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
EmitSound( "NPC_FastZombie.AlertNear" );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
#define FASTZOMBIE_MINLEAP 200
|
||
|
#define FASTZOMBIE_MAXLEAP 300
|
||
|
float CFastZombie::InnateRange1MaxRange( void )
|
||
|
{
|
||
|
return FASTZOMBIE_MAXLEAP;
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: See if I can make my leaping attack!!
|
||
|
//
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
int CFastZombie::RangeAttack1Conditions( float flDot, float flDist )
|
||
|
{
|
||
|
|
||
|
if (GetEnemy() == NULL)
|
||
|
{
|
||
|
return( COND_NONE );
|
||
|
}
|
||
|
|
||
|
if( !(GetFlags() & FL_ONGROUND) )
|
||
|
{
|
||
|
return COND_NONE;
|
||
|
}
|
||
|
|
||
|
if( gpGlobals->curtime < m_flNextAttack )
|
||
|
{
|
||
|
return( COND_NONE );
|
||
|
}
|
||
|
|
||
|
// make sure the enemy isn't on a roof and I'm in the streets (Ravenholm)
|
||
|
float flZDist;
|
||
|
flZDist = fabs( GetEnemy()->GetLocalOrigin().z - GetLocalOrigin().z );
|
||
|
if( flZDist > FASTZOMBIE_MAXLEAP_Z )
|
||
|
{
|
||
|
return COND_TOO_FAR_TO_ATTACK;
|
||
|
}
|
||
|
|
||
|
if( flDist > InnateRange1MaxRange() )
|
||
|
{
|
||
|
return COND_TOO_FAR_TO_ATTACK;
|
||
|
}
|
||
|
|
||
|
if( flDist < FASTZOMBIE_MINLEAP )
|
||
|
{
|
||
|
return COND_NONE;
|
||
|
}
|
||
|
|
||
|
if (flDot < 0.8)
|
||
|
{
|
||
|
return COND_NONE;
|
||
|
}
|
||
|
|
||
|
if ( !IsMoving() )
|
||
|
{
|
||
|
// I Have to be running!!!
|
||
|
return COND_NONE;
|
||
|
}
|
||
|
|
||
|
// Don't jump at the player unless he's facing me.
|
||
|
// This allows the player to get away if he turns and sprints
|
||
|
CBasePlayer *pPlayer = static_cast<CBasePlayer*>( GetEnemy() );
|
||
|
|
||
|
if( pPlayer )
|
||
|
{
|
||
|
// If the enemy is a player, don't attack from behind!
|
||
|
if( !pPlayer->FInViewCone( this ) )
|
||
|
{
|
||
|
return COND_NONE;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Drumroll please!
|
||
|
// The final check! Is the path from my position to halfway between me
|
||
|
// and the player clear?
|
||
|
trace_t tr;
|
||
|
Vector vecDirToEnemy;
|
||
|
|
||
|
vecDirToEnemy = GetEnemy()->WorldSpaceCenter() - WorldSpaceCenter();
|
||
|
Vector vecHullMin( -16, -16, -16 );
|
||
|
Vector vecHullMax( 16, 16, 16 );
|
||
|
|
||
|
// only check half the distance. (the first part of the jump)
|
||
|
vecDirToEnemy = vecDirToEnemy * 0.5;
|
||
|
|
||
|
AI_TraceHull( WorldSpaceCenter(), WorldSpaceCenter() + vecDirToEnemy, vecHullMin, vecHullMax, MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );
|
||
|
|
||
|
if( tr.fraction != 1.0 )
|
||
|
{
|
||
|
// There's some sort of obstacle pretty much right in front of me.
|
||
|
return COND_NONE;
|
||
|
}
|
||
|
|
||
|
return COND_CAN_RANGE_ATTACK1;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::HandleAnimEvent( animevent_t *pEvent )
|
||
|
{
|
||
|
if ( pEvent->event == AE_FASTZOMBIE_CLIMB_LEFT || pEvent->event == AE_FASTZOMBIE_CLIMB_RIGHT )
|
||
|
{
|
||
|
if( ++m_iClimbCount % 3 == 0 )
|
||
|
{
|
||
|
ENVELOPE_CONTROLLER.SoundChangePitch( m_pLayer2, random->RandomFloat( 100, 150 ), 0.0 );
|
||
|
ENVELOPE_CONTROLLER.SoundPlayEnvelope( m_pLayer2, SOUNDCTRL_CHANGE_VOLUME, envFastZombieVolumeClimb, ARRAYSIZE(envFastZombieVolumeClimb) );
|
||
|
}
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ( pEvent->event == AE_FASTZOMBIE_LEAP )
|
||
|
{
|
||
|
LeapAttack();
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ( pEvent->event == AE_FASTZOMBIE_GALLOP_LEFT )
|
||
|
{
|
||
|
EmitSound( "NPC_FastZombie.GallopLeft" );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ( pEvent->event == AE_FASTZOMBIE_GALLOP_RIGHT )
|
||
|
{
|
||
|
EmitSound( "NPC_FastZombie.GallopRight" );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ( pEvent->event == AE_ZOMBIE_ATTACK_RIGHT )
|
||
|
{
|
||
|
Vector right;
|
||
|
AngleVectors( GetLocalAngles(), NULL, &right, NULL );
|
||
|
right = right * -50;
|
||
|
|
||
|
QAngle angle( -3, -5, -3 );
|
||
|
ClawAttack( GetClawAttackRange(), 3, angle, right, ZOMBIE_BLOOD_RIGHT_HAND );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ( pEvent->event == AE_ZOMBIE_ATTACK_LEFT )
|
||
|
{
|
||
|
Vector right;
|
||
|
AngleVectors( GetLocalAngles(), NULL, &right, NULL );
|
||
|
right = right * 50;
|
||
|
QAngle angle( -3, 5, -3 );
|
||
|
ClawAttack( GetClawAttackRange(), 3, angle, right, ZOMBIE_BLOOD_LEFT_HAND );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
//=============================================================================
|
||
|
#ifdef HL2_EPISODIC
|
||
|
|
||
|
// Do the leap attack
|
||
|
if ( pEvent->event == AE_FASTZOMBIE_VEHICLE_LEAP )
|
||
|
{
|
||
|
VehicleLeapAttack();
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// Die while doing an SS in a vehicle
|
||
|
if ( pEvent->event == AE_FASTZOMBIE_VEHICLE_SS_DIE )
|
||
|
{
|
||
|
if ( IsInAVehicle() )
|
||
|
{
|
||
|
// Get the vehicle's present speed as a baseline
|
||
|
Vector vecVelocity = vec3_origin;
|
||
|
CBaseEntity *pVehicle = m_PassengerBehavior.GetTargetVehicle();
|
||
|
if ( pVehicle )
|
||
|
{
|
||
|
pVehicle->GetVelocity( &vecVelocity, NULL );
|
||
|
}
|
||
|
|
||
|
// TODO: We need to make this content driven -- jdw
|
||
|
Vector vecForward, vecRight, vecUp;
|
||
|
GetVectors( &vecForward, &vecRight, &vecUp );
|
||
|
|
||
|
vecVelocity += ( vecForward * -2500.0f ) + ( vecRight * 200.0f ) + ( vecUp * 300 );
|
||
|
|
||
|
// Always kill
|
||
|
float flDamage = GetMaxHealth() + 10;
|
||
|
|
||
|
// Take the damage and die
|
||
|
CTakeDamageInfo info( this, this, vecVelocity * 25.0f, WorldSpaceCenter(), flDamage, (DMG_CRUSH|DMG_VEHICLE) );
|
||
|
TakeDamage( info );
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
#endif // HL2_EPISODIC
|
||
|
//=============================================================================
|
||
|
|
||
|
BaseClass::HandleAnimEvent( pEvent );
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Jump at the enemy!! (stole this from the headcrab)
|
||
|
//
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::LeapAttack( void )
|
||
|
{
|
||
|
SetGroundEntity( NULL );
|
||
|
|
||
|
BeginAttackJump();
|
||
|
|
||
|
LeapAttackSound();
|
||
|
|
||
|
//
|
||
|
// Take him off ground so engine doesn't instantly reset FL_ONGROUND.
|
||
|
//
|
||
|
UTIL_SetOrigin( this, GetLocalOrigin() + Vector( 0 , 0 , 1 ));
|
||
|
|
||
|
Vector vecJumpDir;
|
||
|
CBaseEntity *pEnemy = GetEnemy();
|
||
|
|
||
|
if ( pEnemy )
|
||
|
{
|
||
|
Vector vecEnemyPos = pEnemy->WorldSpaceCenter();
|
||
|
|
||
|
float gravity = GetCurrentGravity();
|
||
|
if ( gravity <= 1 )
|
||
|
{
|
||
|
gravity = 1;
|
||
|
}
|
||
|
|
||
|
//
|
||
|
// How fast does the zombie need to travel to reach my enemy's eyes given gravity?
|
||
|
//
|
||
|
float height = ( vecEnemyPos.z - GetAbsOrigin().z );
|
||
|
|
||
|
if ( height < 16 )
|
||
|
{
|
||
|
height = 16;
|
||
|
}
|
||
|
else if ( height > 120 )
|
||
|
{
|
||
|
height = 120;
|
||
|
}
|
||
|
float speed = sqrt( 2 * gravity * height );
|
||
|
float time = speed / gravity;
|
||
|
|
||
|
//
|
||
|
// Scale the sideways velocity to get there at the right time
|
||
|
//
|
||
|
vecJumpDir = vecEnemyPos - GetAbsOrigin();
|
||
|
vecJumpDir = vecJumpDir / time;
|
||
|
|
||
|
//
|
||
|
// Speed to offset gravity at the desired height.
|
||
|
//
|
||
|
vecJumpDir.z = speed;
|
||
|
|
||
|
//
|
||
|
// Don't jump too far/fast.
|
||
|
//
|
||
|
#define CLAMP 1000.0
|
||
|
float distance = vecJumpDir.Length();
|
||
|
if ( distance > CLAMP )
|
||
|
{
|
||
|
vecJumpDir = vecJumpDir * ( CLAMP / distance );
|
||
|
}
|
||
|
|
||
|
// try speeding up a bit.
|
||
|
SetAbsVelocity( vecJumpDir );
|
||
|
m_flNextAttack = gpGlobals->curtime + 2;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::StartTask( const Task_t *pTask )
|
||
|
{
|
||
|
switch( pTask->iTask )
|
||
|
{
|
||
|
case TASK_FASTZOMBIE_VERIFY_ATTACK:
|
||
|
// Simply ensure that the zombie still has a valid melee attack
|
||
|
if( HasCondition( COND_CAN_MELEE_ATTACK1 ) )
|
||
|
{
|
||
|
TaskComplete();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
TaskFail("");
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
case TASK_FASTZOMBIE_JUMP_BACK:
|
||
|
{
|
||
|
SetActivity( ACT_IDLE );
|
||
|
|
||
|
SetGroundEntity( NULL );
|
||
|
|
||
|
BeginAttackJump();
|
||
|
|
||
|
Vector forward;
|
||
|
AngleVectors( GetLocalAngles(), &forward );
|
||
|
|
||
|
//
|
||
|
// Take him off ground so engine doesn't instantly reset FL_ONGROUND.
|
||
|
//
|
||
|
UTIL_SetOrigin( this, GetLocalOrigin() + Vector( 0 , 0 , 1 ));
|
||
|
|
||
|
ApplyAbsVelocityImpulse( forward * -200 + Vector( 0, 0, 200 ) );
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
case TASK_FASTZOMBIE_UNSTICK_JUMP:
|
||
|
{
|
||
|
SetGroundEntity( NULL );
|
||
|
|
||
|
// Call begin attack jump. A little bit later if we fail to pathfind, we check
|
||
|
// this value to see if we just jumped. If so, we assume we've jumped
|
||
|
// to someplace that's not pathing friendly, and so must jump again to get out.
|
||
|
BeginAttackJump();
|
||
|
|
||
|
//
|
||
|
// Take him off ground so engine doesn't instantly reset FL_ONGROUND.
|
||
|
//
|
||
|
UTIL_SetOrigin( this, GetLocalOrigin() + Vector( 0 , 0 , 1 ));
|
||
|
|
||
|
CBaseEntity *pEnemy = GetEnemy();
|
||
|
Vector vecJumpDir;
|
||
|
|
||
|
if ( GetActivity() == ACT_CLIMB_UP || GetActivity() == ACT_CLIMB_DOWN )
|
||
|
{
|
||
|
// Jump off the pipe backwards!
|
||
|
Vector forward;
|
||
|
|
||
|
GetVectors( &forward, NULL, NULL );
|
||
|
|
||
|
ApplyAbsVelocityImpulse( forward * -200 );
|
||
|
}
|
||
|
else if( pEnemy )
|
||
|
{
|
||
|
vecJumpDir = pEnemy->GetLocalOrigin() - GetLocalOrigin();
|
||
|
VectorNormalize( vecJumpDir );
|
||
|
vecJumpDir.z = 0;
|
||
|
|
||
|
ApplyAbsVelocityImpulse( vecJumpDir * 300 + Vector( 0, 0, 200 ) );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
DevMsg("UNHANDLED CASE! Stuck Fast Zombie with no enemy!\n");
|
||
|
}
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
case TASK_WAIT_FOR_MOVEMENT:
|
||
|
// If we're waiting for movement, that means that pathfinding succeeded, and
|
||
|
// we're about to be moving. So we aren't stuck. So clear this flag.
|
||
|
m_fJustJumped = false;
|
||
|
|
||
|
BaseClass::StartTask( pTask );
|
||
|
break;
|
||
|
|
||
|
case TASK_FACE_ENEMY:
|
||
|
{
|
||
|
// We don't use the base class implementation of this, because GetTurnActivity
|
||
|
// stomps our landing scrabble animations (sjb)
|
||
|
Vector flEnemyLKP = GetEnemyLKP();
|
||
|
GetMotor()->SetIdealYawToTarget( flEnemyLKP );
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
case TASK_FASTZOMBIE_LAND_RECOVER:
|
||
|
{
|
||
|
// Set the ideal yaw
|
||
|
Vector flEnemyLKP = GetEnemyLKP();
|
||
|
GetMotor()->SetIdealYawToTarget( flEnemyLKP );
|
||
|
|
||
|
// figure out which way to turn.
|
||
|
float flDeltaYaw = GetMotor()->DeltaIdealYaw();
|
||
|
|
||
|
if( flDeltaYaw < 0 )
|
||
|
{
|
||
|
SetIdealActivity( (Activity)ACT_FASTZOMBIE_LAND_RIGHT );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
SetIdealActivity( (Activity)ACT_FASTZOMBIE_LAND_LEFT );
|
||
|
}
|
||
|
|
||
|
|
||
|
TaskComplete();
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
case TASK_RANGE_ATTACK1:
|
||
|
|
||
|
// Make melee attacks impossible until we land!
|
||
|
m_flNextMeleeAttack = gpGlobals->curtime + 60;
|
||
|
|
||
|
SetTouch( &CFastZombie::LeapAttackTouch );
|
||
|
break;
|
||
|
|
||
|
case TASK_FASTZOMBIE_DO_ATTACK:
|
||
|
SetActivity( (Activity)ACT_FASTZOMBIE_LEAP_SOAR );
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
BaseClass::StartTask( pTask );
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::RunTask( const Task_t *pTask )
|
||
|
{
|
||
|
switch( pTask->iTask )
|
||
|
{
|
||
|
case TASK_FASTZOMBIE_JUMP_BACK:
|
||
|
case TASK_FASTZOMBIE_UNSTICK_JUMP:
|
||
|
if( GetFlags() & FL_ONGROUND )
|
||
|
{
|
||
|
TaskComplete();
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
case TASK_RANGE_ATTACK1:
|
||
|
if( ( GetFlags() & FL_ONGROUND ) || ( m_pfnTouch == NULL ) )
|
||
|
{
|
||
|
// All done when you touch the ground, or if our touch function has somehow cleared.
|
||
|
TaskComplete();
|
||
|
|
||
|
// Allow melee attacks again.
|
||
|
m_flNextMeleeAttack = gpGlobals->curtime + 0.5;
|
||
|
return;
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
BaseClass::RunTask( pTask );
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
//---------------------------------------------------------
|
||
|
int CFastZombie::TranslateSchedule( int scheduleType )
|
||
|
{
|
||
|
switch( scheduleType )
|
||
|
{
|
||
|
case SCHED_RANGE_ATTACK1:
|
||
|
{
|
||
|
// Scream right now, cause in half a second, we're gonna jump!!
|
||
|
|
||
|
if( !m_fHasScreamed )
|
||
|
{
|
||
|
// Only play that over-the-top attack scream once per combat state.
|
||
|
EmitSound( "NPC_FastZombie.Scream" );
|
||
|
m_fHasScreamed = true;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
EmitSound( "NPC_FastZombie.RangeAttack" );
|
||
|
}
|
||
|
|
||
|
return SCHED_FASTZOMBIE_RANGE_ATTACK1;
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
case SCHED_MELEE_ATTACK1:
|
||
|
if ( m_fIsTorso == true )
|
||
|
{
|
||
|
return SCHED_FASTZOMBIE_TORSO_MELEE_ATTACK1;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return SCHED_FASTZOMBIE_MELEE_ATTACK1;
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
case SCHED_FASTZOMBIE_UNSTICK_JUMP:
|
||
|
if ( GetActivity() == ACT_CLIMB_UP || GetActivity() == ACT_CLIMB_DOWN || GetActivity() == ACT_CLIMB_DISMOUNT )
|
||
|
{
|
||
|
return SCHED_FASTZOMBIE_CLIMBING_UNSTICK_JUMP;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return SCHED_FASTZOMBIE_UNSTICK_JUMP;
|
||
|
}
|
||
|
break;
|
||
|
case SCHED_MOVE_TO_WEAPON_RANGE:
|
||
|
{
|
||
|
float flZDist = fabs( GetEnemy()->GetLocalOrigin().z - GetLocalOrigin().z );
|
||
|
if ( flZDist > FASTZOMBIE_MAXLEAP_Z )
|
||
|
return SCHED_CHASE_ENEMY;
|
||
|
else // fall through to default
|
||
|
return BaseClass::TranslateSchedule( scheduleType );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
default:
|
||
|
return BaseClass::TranslateSchedule( scheduleType );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
//---------------------------------------------------------
|
||
|
Activity CFastZombie::NPC_TranslateActivity( Activity baseAct )
|
||
|
{
|
||
|
if ( baseAct == ACT_CLIMB_DOWN )
|
||
|
return ACT_CLIMB_UP;
|
||
|
|
||
|
return BaseClass::NPC_TranslateActivity( baseAct );
|
||
|
}
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
//---------------------------------------------------------
|
||
|
void CFastZombie::LeapAttackTouch( CBaseEntity *pOther )
|
||
|
{
|
||
|
if ( !pOther->IsSolid() )
|
||
|
{
|
||
|
// Touching a trigger or something.
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// Stop the zombie and knock the player back
|
||
|
Vector vecNewVelocity( 0, 0, GetAbsVelocity().z );
|
||
|
SetAbsVelocity( vecNewVelocity );
|
||
|
|
||
|
Vector forward;
|
||
|
AngleVectors( GetLocalAngles(), &forward );
|
||
|
forward *= 500;
|
||
|
QAngle qaPunch( 15, random->RandomInt(-5,5), random->RandomInt(-5,5) );
|
||
|
|
||
|
ClawAttack( GetClawAttackRange(), 5, qaPunch, forward, ZOMBIE_BLOOD_BOTH_HANDS );
|
||
|
|
||
|
SetTouch( NULL );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Lets us know if we touch the player while we're climbing.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::ClimbTouch( CBaseEntity *pOther )
|
||
|
{
|
||
|
if ( pOther->IsPlayer() )
|
||
|
{
|
||
|
// If I hit the player, shove him aside.
|
||
|
Vector vecDir = pOther->WorldSpaceCenter() - WorldSpaceCenter();
|
||
|
vecDir.z = 0.0; // planar
|
||
|
VectorNormalize( vecDir );
|
||
|
|
||
|
if( IsXbox() )
|
||
|
{
|
||
|
vecDir *= 400.0f;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
vecDir *= 200.0f;
|
||
|
}
|
||
|
|
||
|
pOther->VelocityPunch( vecDir );
|
||
|
|
||
|
if ( GetActivity() != ACT_CLIMB_DISMOUNT ||
|
||
|
( pOther->GetGroundEntity() == NULL &&
|
||
|
GetNavigator()->IsGoalActive() &&
|
||
|
pOther->GetAbsOrigin().z - GetNavigator()->GetCurWaypointPos().z < -1.0 ) )
|
||
|
{
|
||
|
SetCondition( COND_FASTZOMBIE_CLIMB_TOUCH );
|
||
|
}
|
||
|
|
||
|
SetTouch( NULL );
|
||
|
}
|
||
|
else if ( dynamic_cast<CPhysicsProp *>(pOther) )
|
||
|
{
|
||
|
NPCPhysics_CreateSolver( this, pOther, true, 5.0 );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Shuts down our looping sounds.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::StopLoopingSounds( void )
|
||
|
{
|
||
|
if ( m_pMoanSound )
|
||
|
{
|
||
|
ENVELOPE_CONTROLLER.SoundDestroy( m_pMoanSound );
|
||
|
m_pMoanSound = NULL;
|
||
|
}
|
||
|
|
||
|
if ( m_pLayer2 )
|
||
|
{
|
||
|
ENVELOPE_CONTROLLER.SoundDestroy( m_pLayer2 );
|
||
|
m_pLayer2 = NULL;
|
||
|
}
|
||
|
|
||
|
BaseClass::StopLoopingSounds();
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Fast zombie cannot range attack when he's a torso!
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::BecomeTorso( const Vector &vecTorsoForce, const Vector &vecLegsForce )
|
||
|
{
|
||
|
CapabilitiesRemove( bits_CAP_INNATE_RANGE_ATTACK1 );
|
||
|
CapabilitiesRemove( bits_CAP_MOVE_JUMP );
|
||
|
CapabilitiesRemove( bits_CAP_MOVE_CLIMB );
|
||
|
|
||
|
ReleaseHeadcrab( EyePosition(), vecLegsForce * 0.5, true, true, true );
|
||
|
|
||
|
BaseClass::BecomeTorso( vecTorsoForce, vecLegsForce );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Returns true if a reasonable jumping distance
|
||
|
// Input :
|
||
|
// Output :
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CFastZombie::IsJumpLegal(const Vector &startPos, const Vector &apex, const Vector &endPos) const
|
||
|
{
|
||
|
const float MAX_JUMP_RISE = 220.0f;
|
||
|
const float MAX_JUMP_DISTANCE = 512.0f;
|
||
|
const float MAX_JUMP_DROP = 384.0f;
|
||
|
|
||
|
if ( BaseClass::IsJumpLegal( startPos, apex, endPos, MAX_JUMP_RISE, MAX_JUMP_DROP, MAX_JUMP_DISTANCE ) )
|
||
|
{
|
||
|
// Hang onto the jump distance. The AI is going to want it.
|
||
|
m_flJumpDist = (startPos - endPos).Length();
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
|
||
|
bool CFastZombie::MovementCost( int moveType, const Vector &vecStart, const Vector &vecEnd, float *pCost )
|
||
|
{
|
||
|
float delta = vecEnd.z - vecStart.z;
|
||
|
|
||
|
float multiplier = 1;
|
||
|
if ( moveType == bits_CAP_MOVE_JUMP )
|
||
|
{
|
||
|
multiplier = ( delta < 0 ) ? 0.5 : 1.5;
|
||
|
}
|
||
|
else if ( moveType == bits_CAP_MOVE_CLIMB )
|
||
|
{
|
||
|
multiplier = ( delta > 0 ) ? 0.5 : 4.0;
|
||
|
}
|
||
|
|
||
|
*pCost *= multiplier;
|
||
|
|
||
|
return ( multiplier != 1 );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
|
||
|
bool CFastZombie::ShouldFailNav( bool bMovementFailed )
|
||
|
{
|
||
|
if ( !BaseClass::ShouldFailNav( bMovementFailed ) )
|
||
|
{
|
||
|
DevMsg( 2, "Fast zombie in scripted sequence probably hit bad node configuration at %s\n", VecToString( GetAbsOrigin() ) );
|
||
|
|
||
|
if ( GetNavigator()->GetPath()->CurWaypointNavType() == NAV_JUMP && GetNavigator()->RefindPathToGoal( false ) )
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
DevMsg( 2, "Fast zombie failed to get to scripted sequence\n" );
|
||
|
}
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
// Purpose: Notifier that lets us know when the fast
|
||
|
// zombie has hit the apex of a navigational jump.
|
||
|
//---------------------------------------------------------
|
||
|
void CFastZombie::OnNavJumpHitApex( void )
|
||
|
{
|
||
|
m_fHitApex = true; // stop subsequent notifications
|
||
|
}
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
// Purpose: Overridden to detect when the zombie goes into
|
||
|
// and out of his climb state and his navigation
|
||
|
// jump state.
|
||
|
//---------------------------------------------------------
|
||
|
void CFastZombie::OnChangeActivity( Activity NewActivity )
|
||
|
{
|
||
|
if ( NewActivity == ACT_FASTZOMBIE_FRENZY )
|
||
|
{
|
||
|
// Scream!!!!
|
||
|
EmitSound( "NPC_FastZombie.Frenzy" );
|
||
|
SetPlaybackRate( random->RandomFloat( .9, 1.1 ) );
|
||
|
}
|
||
|
|
||
|
if( NewActivity == ACT_JUMP )
|
||
|
{
|
||
|
BeginNavJump();
|
||
|
}
|
||
|
else if( GetActivity() == ACT_JUMP )
|
||
|
{
|
||
|
EndNavJump();
|
||
|
}
|
||
|
|
||
|
if ( NewActivity == ACT_LAND )
|
||
|
{
|
||
|
m_flNextAttack = gpGlobals->curtime + 1.0;
|
||
|
}
|
||
|
|
||
|
if ( NewActivity == ACT_GLIDE )
|
||
|
{
|
||
|
// Started a jump.
|
||
|
BeginNavJump();
|
||
|
}
|
||
|
else if ( GetActivity() == ACT_GLIDE )
|
||
|
{
|
||
|
// Landed a jump
|
||
|
EndNavJump();
|
||
|
|
||
|
if ( m_pMoanSound )
|
||
|
ENVELOPE_CONTROLLER.SoundChangePitch( m_pMoanSound, FASTZOMBIE_MIN_PITCH, 0.3 );
|
||
|
}
|
||
|
|
||
|
if ( NewActivity == ACT_CLIMB_UP )
|
||
|
{
|
||
|
// Started a climb!
|
||
|
if ( m_pMoanSound )
|
||
|
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pMoanSound, 0.0, 0.2 );
|
||
|
|
||
|
SetTouch( &CFastZombie::ClimbTouch );
|
||
|
}
|
||
|
else if ( GetActivity() == ACT_CLIMB_DISMOUNT || ( GetActivity() == ACT_CLIMB_UP && NewActivity != ACT_CLIMB_DISMOUNT ) )
|
||
|
{
|
||
|
// Ended a climb
|
||
|
if ( m_pMoanSound )
|
||
|
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pMoanSound, 1.0, 0.2 );
|
||
|
|
||
|
SetTouch( NULL );
|
||
|
}
|
||
|
|
||
|
BaseClass::OnChangeActivity( NewActivity );
|
||
|
}
|
||
|
|
||
|
|
||
|
//=========================================================
|
||
|
//
|
||
|
//=========================================================
|
||
|
int CFastZombie::SelectFailSchedule( int failedSchedule, int failedTask, AI_TaskFailureCode_t taskFailCode )
|
||
|
{
|
||
|
if ( m_fJustJumped )
|
||
|
{
|
||
|
// Assume we failed cause we jumped to a bad place.
|
||
|
m_fJustJumped = false;
|
||
|
return SCHED_FASTZOMBIE_UNSTICK_JUMP;
|
||
|
}
|
||
|
|
||
|
return BaseClass::SelectFailSchedule( failedSchedule, failedTask, taskFailCode );
|
||
|
}
|
||
|
|
||
|
//=========================================================
|
||
|
// Purpose: Do some record keeping for jumps made for
|
||
|
// navigational purposes (i.e., not attack jumps)
|
||
|
//=========================================================
|
||
|
void CFastZombie::BeginNavJump( void )
|
||
|
{
|
||
|
m_fIsNavJumping = true;
|
||
|
m_fHitApex = false;
|
||
|
|
||
|
ENVELOPE_CONTROLLER.SoundPlayEnvelope( m_pLayer2, SOUNDCTRL_CHANGE_VOLUME, envFastZombieVolumeJump, ARRAYSIZE(envFastZombieVolumeJump) );
|
||
|
}
|
||
|
|
||
|
//=========================================================
|
||
|
//
|
||
|
//=========================================================
|
||
|
void CFastZombie::EndNavJump( void )
|
||
|
{
|
||
|
m_fIsNavJumping = false;
|
||
|
m_fHitApex = false;
|
||
|
}
|
||
|
|
||
|
//=========================================================
|
||
|
//
|
||
|
//=========================================================
|
||
|
void CFastZombie::BeginAttackJump( void )
|
||
|
{
|
||
|
// Set this to true. A little bit later if we fail to pathfind, we check
|
||
|
// this value to see if we just jumped. If so, we assume we've jumped
|
||
|
// to someplace that's not pathing friendly, and so must jump again to get out.
|
||
|
m_fJustJumped = true;
|
||
|
|
||
|
m_flJumpStartAltitude = GetLocalOrigin().z;
|
||
|
}
|
||
|
|
||
|
//=========================================================
|
||
|
//
|
||
|
//=========================================================
|
||
|
void CFastZombie::EndAttackJump( void )
|
||
|
{
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::BuildScheduleTestBits( void )
|
||
|
{
|
||
|
// FIXME: This is probably the desired call to make, but it opts into an untested base class path, we'll need to
|
||
|
// revisit this and figure out if we want that. -- jdw
|
||
|
// BaseClass::BuildScheduleTestBits();
|
||
|
//
|
||
|
// For now, make sure our active behavior gets a chance to add its own bits
|
||
|
if ( GetRunningBehavior() )
|
||
|
GetRunningBehavior()->BridgeBuildScheduleTestBits();
|
||
|
|
||
|
#ifdef HL2_EPISODIC
|
||
|
SetCustomInterruptCondition( COND_PROVOKED );
|
||
|
#endif // HL2_EPISODIC
|
||
|
|
||
|
// Any schedule that makes us climb should break if we touch player
|
||
|
if ( GetActivity() == ACT_CLIMB_UP || GetActivity() == ACT_CLIMB_DOWN || GetActivity() == ACT_CLIMB_DISMOUNT)
|
||
|
{
|
||
|
SetCustomInterruptCondition( COND_FASTZOMBIE_CLIMB_TOUCH );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
ClearCustomInterruptCondition( COND_FASTZOMBIE_CLIMB_TOUCH );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//=========================================================
|
||
|
//
|
||
|
//=========================================================
|
||
|
void CFastZombie::OnStateChange( NPC_STATE OldState, NPC_STATE NewState )
|
||
|
{
|
||
|
if( NewState == NPC_STATE_COMBAT )
|
||
|
{
|
||
|
SetAngrySoundState();
|
||
|
}
|
||
|
else if( (m_pMoanSound) && ( NewState == NPC_STATE_IDLE || NewState == NPC_STATE_ALERT ) ) ///!!!HACKHACK - sjb
|
||
|
{
|
||
|
// Don't make this sound while we're slumped
|
||
|
if ( IsSlumped() == false )
|
||
|
{
|
||
|
// Set it up so that if the zombie goes into combat state sometime down the road
|
||
|
// that he'll be able to scream.
|
||
|
m_fHasScreamed = false;
|
||
|
|
||
|
SetIdleSoundState();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::Event_Killed( const CTakeDamageInfo &info )
|
||
|
{
|
||
|
// Shut up my screaming sounds.
|
||
|
CPASAttenuationFilter filter( this );
|
||
|
EmitSound( filter, entindex(), "NPC_FastZombie.NoSound" );
|
||
|
|
||
|
CTakeDamageInfo dInfo = info;
|
||
|
|
||
|
#if 0
|
||
|
|
||
|
// Become a server-side ragdoll and create a constraint at the hand
|
||
|
if ( m_PassengerBehavior.GetPassengerState() == PASSENGER_STATE_INSIDE )
|
||
|
{
|
||
|
IPhysicsObject *pVehiclePhys = m_PassengerBehavior.GetTargetVehicle()->GetServerVehicle()->GetVehicleEnt()->VPhysicsGetObject();
|
||
|
CBaseAnimating *pVehicleAnimating = m_PassengerBehavior.GetTargetVehicle()->GetServerVehicle()->GetVehicleEnt()->GetBaseAnimating();
|
||
|
int nRightHandBone = 31;//GetBaseAnimating()->LookupBone( "ValveBiped.Bip01_R_Finger2" );
|
||
|
Vector vecRightHandPos;
|
||
|
QAngle vecRightHandAngle;
|
||
|
GetAttachment( LookupAttachment( "Blood_Right" ), vecRightHandPos, vecRightHandAngle );
|
||
|
//CTakeDamageInfo dInfo( GetEnemy(), GetEnemy(), RandomVector( -200, 200 ), WorldSpaceCenter(), 50.0f, DMG_CRUSH );
|
||
|
dInfo.SetDamageType( info.GetDamageType() | DMG_REMOVENORAGDOLL );
|
||
|
dInfo.ScaleDamageForce( 10.0f );
|
||
|
CBaseEntity *pRagdoll = CreateServerRagdoll( GetBaseAnimating(), 0, info, COLLISION_GROUP_DEBRIS );
|
||
|
|
||
|
/*
|
||
|
GetBaseAnimating()->GetBonePosition( nRightHandBone, vecRightHandPos, vecRightHandAngle );
|
||
|
|
||
|
CBaseEntity *pRagdoll = CreateServerRagdollAttached( GetBaseAnimating(),
|
||
|
vec3_origin,
|
||
|
-1,
|
||
|
COLLISION_GROUP_DEBRIS,
|
||
|
pVehiclePhys,
|
||
|
pVehicleAnimating,
|
||
|
0,
|
||
|
vecRightHandPos,
|
||
|
nRightHandBone,
|
||
|
vec3_origin );*/
|
||
|
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
BaseClass::Event_Killed( dInfo );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CFastZombie::ShouldBecomeTorso( const CTakeDamageInfo &info, float flDamageThreshold )
|
||
|
{
|
||
|
if( m_fIsTorso )
|
||
|
{
|
||
|
// Already split.
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// Break in half IF:
|
||
|
//
|
||
|
// Take half or more of max health in DMG_BLAST
|
||
|
if( (info.GetDamageType() & DMG_BLAST) && m_iHealth <= 0 )
|
||
|
{
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
//=============================================================================
|
||
|
#ifdef HL2_EPISODIC
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Add the passenger behavior to our repertoire
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CFastZombie::CreateBehaviors( void )
|
||
|
{
|
||
|
AddBehavior( &m_PassengerBehavior );
|
||
|
|
||
|
return BaseClass::CreateBehaviors();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Get on the vehicle!
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::InputAttachToVehicle( inputdata_t &inputdata )
|
||
|
{
|
||
|
// Interrupt us
|
||
|
SetCondition( COND_PROVOKED );
|
||
|
|
||
|
// Find the target vehicle
|
||
|
CBaseEntity *pEntity = FindNamedEntity( inputdata.value.String() );
|
||
|
CPropJeepEpisodic *pVehicle = dynamic_cast<CPropJeepEpisodic *>(pEntity);
|
||
|
|
||
|
// Get in the car if it's valid
|
||
|
if ( pVehicle && CanEnterVehicle( pVehicle ) )
|
||
|
{
|
||
|
// Set her into a "passenger" behavior
|
||
|
m_PassengerBehavior.Enable( pVehicle );
|
||
|
m_PassengerBehavior.AttachToVehicle();
|
||
|
}
|
||
|
|
||
|
RemoveSpawnFlags( SF_NPC_GAG );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Passed along from the vehicle's callback list
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )
|
||
|
{
|
||
|
// Only do the override while riding on a vehicle
|
||
|
if ( m_PassengerBehavior.CanSelectSchedule() && m_PassengerBehavior.GetPassengerState() != PASSENGER_STATE_OUTSIDE )
|
||
|
{
|
||
|
int damageType = 0;
|
||
|
float flDamage = CalculatePhysicsImpactDamage( index, pEvent, gZombiePassengerImpactDamageTable, 1.0, true, damageType );
|
||
|
|
||
|
if ( flDamage > 0 )
|
||
|
{
|
||
|
Vector damagePos;
|
||
|
pEvent->pInternalData->GetContactPoint( damagePos );
|
||
|
Vector damageForce = pEvent->postVelocity[index] * pEvent->pObjects[index]->GetMass();
|
||
|
CTakeDamageInfo info( this, this, damageForce, damagePos, flDamage, (damageType|DMG_VEHICLE) );
|
||
|
TakeDamage( info );
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
BaseClass::VPhysicsCollision( index, pEvent );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: FIXME: Fold this into LeapAttack using different jump targets!
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::VehicleLeapAttack( void )
|
||
|
{
|
||
|
CBaseEntity *pEnemy = GetEnemy();
|
||
|
if ( pEnemy == NULL )
|
||
|
return;
|
||
|
|
||
|
Vector vecEnemyPos;
|
||
|
UTIL_PredictedPosition( pEnemy, 1.0f, &vecEnemyPos );
|
||
|
|
||
|
// Move
|
||
|
SetGroundEntity( NULL );
|
||
|
BeginAttackJump();
|
||
|
LeapAttackSound();
|
||
|
|
||
|
// Take him off ground so engine doesn't instantly reset FL_ONGROUND.
|
||
|
UTIL_SetOrigin( this, GetLocalOrigin() + Vector( 0 , 0 , 1 ));
|
||
|
|
||
|
// FIXME: This should be the exact position we'll enter at, but this approximates it generally
|
||
|
//vecEnemyPos[2] += 16;
|
||
|
|
||
|
Vector vecMins = GetHullMins();
|
||
|
Vector vecMaxs = GetHullMaxs();
|
||
|
Vector vecJumpDir = VecCheckToss( this, GetAbsOrigin(), vecEnemyPos, 0.1f, 1.0f, false, &vecMins, &vecMaxs );
|
||
|
|
||
|
SetAbsVelocity( vecJumpDir );
|
||
|
m_flNextAttack = gpGlobals->curtime + 2.0f;
|
||
|
SetTouch( &CFastZombie::VehicleLeapAttackTouch );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
// Output : Returns true on success, false on failure.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CFastZombie::CanEnterVehicle( CPropJeepEpisodic *pVehicle )
|
||
|
{
|
||
|
if ( pVehicle == NULL )
|
||
|
return false;
|
||
|
|
||
|
return pVehicle->NPC_CanEnterVehicle( this, false );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: FIXME: Move into behavior?
|
||
|
// Input : *pOther -
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::VehicleLeapAttackTouch( CBaseEntity *pOther )
|
||
|
{
|
||
|
if ( pOther->GetServerVehicle() )
|
||
|
{
|
||
|
m_PassengerBehavior.AttachToVehicle();
|
||
|
|
||
|
// HACK: Stop us cold
|
||
|
SetLocalVelocity( vec3_origin );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Determine whether we're in a vehicle or not
|
||
|
// Output : Returns true on success, false on failure.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CFastZombie::IsInAVehicle( void )
|
||
|
{
|
||
|
// Must be active and getting in/out of vehicle
|
||
|
if ( m_PassengerBehavior.IsEnabled() && m_PassengerBehavior.GetPassengerState() != PASSENGER_STATE_OUTSIDE )
|
||
|
return true;
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Override our efficiency so that we don't jitter when we're in the middle
|
||
|
// of our enter/exit animations.
|
||
|
// Input : bInPVS - Whether we're in the PVS or not
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CFastZombie::UpdateEfficiency( bool bInPVS )
|
||
|
{
|
||
|
// If we're transitioning and in the PVS, we override our efficiency
|
||
|
if ( IsInAVehicle() && bInPVS )
|
||
|
{
|
||
|
PassengerState_e nState = m_PassengerBehavior.GetPassengerState();
|
||
|
if ( nState == PASSENGER_STATE_ENTERING || nState == PASSENGER_STATE_EXITING )
|
||
|
{
|
||
|
SetEfficiency( AIE_NORMAL );
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Do the default behavior
|
||
|
BaseClass::UpdateEfficiency( bInPVS );
|
||
|
}
|
||
|
|
||
|
#endif // HL2_EPISODIC
|
||
|
//=============================================================================
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
|
||
|
AI_BEGIN_CUSTOM_NPC( npc_fastzombie, CFastZombie )
|
||
|
|
||
|
DECLARE_ACTIVITY( ACT_FASTZOMBIE_LEAP_SOAR )
|
||
|
DECLARE_ACTIVITY( ACT_FASTZOMBIE_LEAP_STRIKE )
|
||
|
DECLARE_ACTIVITY( ACT_FASTZOMBIE_LAND_RIGHT )
|
||
|
DECLARE_ACTIVITY( ACT_FASTZOMBIE_LAND_LEFT )
|
||
|
DECLARE_ACTIVITY( ACT_FASTZOMBIE_FRENZY )
|
||
|
DECLARE_ACTIVITY( ACT_FASTZOMBIE_BIG_SLASH )
|
||
|
|
||
|
DECLARE_TASK( TASK_FASTZOMBIE_DO_ATTACK )
|
||
|
DECLARE_TASK( TASK_FASTZOMBIE_LAND_RECOVER )
|
||
|
DECLARE_TASK( TASK_FASTZOMBIE_UNSTICK_JUMP )
|
||
|
DECLARE_TASK( TASK_FASTZOMBIE_JUMP_BACK )
|
||
|
DECLARE_TASK( TASK_FASTZOMBIE_VERIFY_ATTACK )
|
||
|
|
||
|
DECLARE_CONDITION( COND_FASTZOMBIE_CLIMB_TOUCH )
|
||
|
|
||
|
//Adrian: events go here
|
||
|
DECLARE_ANIMEVENT( AE_FASTZOMBIE_LEAP )
|
||
|
DECLARE_ANIMEVENT( AE_FASTZOMBIE_GALLOP_LEFT )
|
||
|
DECLARE_ANIMEVENT( AE_FASTZOMBIE_GALLOP_RIGHT )
|
||
|
DECLARE_ANIMEVENT( AE_FASTZOMBIE_CLIMB_LEFT )
|
||
|
DECLARE_ANIMEVENT( AE_FASTZOMBIE_CLIMB_RIGHT )
|
||
|
|
||
|
#ifdef HL2_EPISODIC
|
||
|
// FIXME: Move!
|
||
|
DECLARE_ANIMEVENT( AE_PASSENGER_PHYSICS_PUSH )
|
||
|
DECLARE_ANIMEVENT( AE_FASTZOMBIE_VEHICLE_LEAP )
|
||
|
DECLARE_ANIMEVENT( AE_FASTZOMBIE_VEHICLE_SS_DIE )
|
||
|
#endif // HL2_EPISODIC
|
||
|
|
||
|
//=========================================================
|
||
|
//
|
||
|
//=========================================================
|
||
|
DEFINE_SCHEDULE
|
||
|
(
|
||
|
SCHED_FASTZOMBIE_RANGE_ATTACK1,
|
||
|
|
||
|
" Tasks"
|
||
|
" TASK_PLAY_SEQUENCE ACTIVITY:ACT_RANGE_ATTACK1"
|
||
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_FASTZOMBIE_LEAP_STRIKE"
|
||
|
" TASK_RANGE_ATTACK1 0"
|
||
|
" TASK_WAIT 0.1"
|
||
|
" TASK_FASTZOMBIE_LAND_RECOVER 0" // essentially just figure out which way to turn.
|
||
|
" TASK_FACE_ENEMY 0"
|
||
|
" "
|
||
|
" Interrupts"
|
||
|
)
|
||
|
|
||
|
//=========================================================
|
||
|
// I have landed somewhere that's pathfinding-unfriendly
|
||
|
// just try to jump out.
|
||
|
//=========================================================
|
||
|
DEFINE_SCHEDULE
|
||
|
(
|
||
|
SCHED_FASTZOMBIE_UNSTICK_JUMP,
|
||
|
|
||
|
" Tasks"
|
||
|
" TASK_FASTZOMBIE_UNSTICK_JUMP 0"
|
||
|
" "
|
||
|
" Interrupts"
|
||
|
)
|
||
|
|
||
|
//=========================================================
|
||
|
//=========================================================
|
||
|
DEFINE_SCHEDULE
|
||
|
(
|
||
|
SCHED_FASTZOMBIE_CLIMBING_UNSTICK_JUMP,
|
||
|
|
||
|
" Tasks"
|
||
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
|
||
|
" TASK_FASTZOMBIE_UNSTICK_JUMP 0"
|
||
|
" "
|
||
|
" Interrupts"
|
||
|
)
|
||
|
|
||
|
//=========================================================
|
||
|
// > Melee_Attack1
|
||
|
//=========================================================
|
||
|
DEFINE_SCHEDULE
|
||
|
(
|
||
|
SCHED_FASTZOMBIE_MELEE_ATTACK1,
|
||
|
|
||
|
" Tasks"
|
||
|
" TASK_STOP_MOVING 0"
|
||
|
" TASK_FACE_ENEMY 0"
|
||
|
" TASK_MELEE_ATTACK1 0"
|
||
|
" TASK_MELEE_ATTACK1 0"
|
||
|
" TASK_PLAY_SEQUENCE ACTIVITY:ACT_FASTZOMBIE_FRENZY"
|
||
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_CHASE_ENEMY"
|
||
|
" TASK_FASTZOMBIE_VERIFY_ATTACK 0"
|
||
|
" TASK_PLAY_SEQUENCE_FACE_ENEMY ACTIVITY:ACT_FASTZOMBIE_BIG_SLASH"
|
||
|
|
||
|
""
|
||
|
" Interrupts"
|
||
|
" COND_NEW_ENEMY"
|
||
|
" COND_ENEMY_DEAD"
|
||
|
" COND_ENEMY_OCCLUDED"
|
||
|
);
|
||
|
|
||
|
//=========================================================
|
||
|
// > Melee_Attack1
|
||
|
//=========================================================
|
||
|
DEFINE_SCHEDULE
|
||
|
(
|
||
|
SCHED_FASTZOMBIE_TORSO_MELEE_ATTACK1,
|
||
|
|
||
|
" Tasks"
|
||
|
" TASK_STOP_MOVING 0"
|
||
|
" TASK_FACE_ENEMY 0"
|
||
|
" TASK_MELEE_ATTACK1 0"
|
||
|
" TASK_MELEE_ATTACK1 0"
|
||
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_CHASE_ENEMY"
|
||
|
" TASK_FASTZOMBIE_VERIFY_ATTACK 0"
|
||
|
|
||
|
""
|
||
|
" Interrupts"
|
||
|
" COND_NEW_ENEMY"
|
||
|
" COND_ENEMY_DEAD"
|
||
|
" COND_ENEMY_OCCLUDED"
|
||
|
);
|
||
|
|
||
|
AI_END_CUSTOM_NPC()
|
||
|
|
||
|
|