mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-23 06:36:54 +00:00
7765 lines
229 KiB
C++
7765 lines
229 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Small, fast version of the strider. Goes where striders cannot, such
|
|
// as into buildings. Best killed with physics objects and explosives.
|
|
//
|
|
//=============================================================================
|
|
|
|
#include "cbase.h"
|
|
#include "npc_strider.h"
|
|
#include "npc_hunter.h"
|
|
#include "ai_behavior_follow.h"
|
|
#include "ai_moveprobe.h"
|
|
#include "ai_senses.h"
|
|
#include "ai_speech.h"
|
|
#include "ai_task.h"
|
|
#include "ai_default.h"
|
|
#include "ai_schedule.h"
|
|
#include "ai_hull.h"
|
|
#include "ai_baseactor.h"
|
|
#include "ai_waypoint.h"
|
|
#include "ai_link.h"
|
|
#include "ai_hint.h"
|
|
#include "ai_squadslot.h"
|
|
#include "ai_squad.h"
|
|
#include "ai_tacticalservices.h"
|
|
#include "beam_shared.h"
|
|
#include "datacache/imdlcache.h"
|
|
#include "eventqueue.h"
|
|
#include "gib.h"
|
|
#include "globalstate.h"
|
|
#include "hierarchy.h"
|
|
#include "movevars_shared.h"
|
|
#include "npcevent.h"
|
|
#include "saverestore_utlvector.h"
|
|
#include "particle_parse.h"
|
|
#include "te_particlesystem.h"
|
|
#include "sceneentity.h"
|
|
#include "shake.h"
|
|
#include "soundenvelope.h"
|
|
#include "soundent.h"
|
|
#include "SpriteTrail.h"
|
|
#include "IEffects.h"
|
|
#include "engine/IEngineSound.h"
|
|
#include "bone_setup.h"
|
|
#include "studio.h"
|
|
#include "ai_route.h"
|
|
#include "ammodef.h"
|
|
#include "npc_bullseye.h"
|
|
#include "physobj.h"
|
|
#include "ai_memory.h"
|
|
#include "collisionutils.h"
|
|
#include "shot_manipulator.h"
|
|
#include "steamjet.h"
|
|
#include "physics_prop_ragdoll.h"
|
|
#include "vehicle_base.h"
|
|
#include "coordsize.h"
|
|
#include "hl2_shareddefs.h"
|
|
#include "te_effect_dispatch.h"
|
|
#include "beam_flags.h"
|
|
#include "prop_combine_ball.h"
|
|
#include "explode.h"
|
|
#include "weapon_physcannon.h"
|
|
#include "weapon_striderbuster.h"
|
|
#include "monstermaker.h"
|
|
#include "weapon_rpg.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
class CNPC_Hunter;
|
|
|
|
|
|
static const char *HUNTER_FLECHETTE_MODEL = "models/weapons/hunter_flechette.mdl";
|
|
|
|
// Think contexts
|
|
static const char *HUNTER_BLEED_THINK = "HunterBleed";
|
|
static const char *HUNTER_ZAP_THINK = "HunterZap";
|
|
static const char *HUNTER_JOSTLE_VEHICLE_THINK = "HunterJostle";
|
|
|
|
|
|
ConVar sk_hunter_health( "sk_hunter_health", "210" );
|
|
|
|
// Melee attacks
|
|
ConVar sk_hunter_dmg_one_slash( "sk_hunter_dmg_one_slash", "20" );
|
|
ConVar sk_hunter_dmg_charge( "sk_hunter_dmg_charge", "20" );
|
|
|
|
// Flechette volley attack
|
|
ConVar hunter_flechette_max_range( "hunter_flechette_max_range", "1200" );
|
|
ConVar hunter_flechette_min_range( "hunter_flechette_min_range", "100" );
|
|
ConVar hunter_flechette_volley_size( "hunter_flechette_volley_size", "8" );
|
|
ConVar hunter_flechette_speed( "hunter_flechette_speed", "2000" );
|
|
ConVar sk_hunter_dmg_flechette( "sk_hunter_dmg_flechette", "4.0" );
|
|
ConVar sk_hunter_flechette_explode_dmg( "sk_hunter_flechette_explode_dmg", "12.0" );
|
|
ConVar sk_hunter_flechette_explode_radius( "sk_hunter_flechette_explode_radius", "128.0" );
|
|
ConVar hunter_flechette_explode_delay( "hunter_flechette_explode_delay", "2.5" );
|
|
ConVar hunter_flechette_delay( "hunter_flechette_delay", "0.1" );
|
|
ConVar hunter_first_flechette_delay( "hunter_first_flechette_delay", "0.5" );
|
|
ConVar hunter_flechette_max_concurrent_volleys( "hunter_flechette_max_concurrent_volleys", "2" );
|
|
ConVar hunter_flechette_volley_start_min_delay( "hunter_flechette_volley_start_min_delay", ".25" );
|
|
ConVar hunter_flechette_volley_start_max_delay( "hunter_flechette_volley_start_max_delay", ".95" );
|
|
ConVar hunter_flechette_volley_end_min_delay( "hunter_flechette_volley_end_min_delay", "1" );
|
|
ConVar hunter_flechette_volley_end_max_delay( "hunter_flechette_volley_end_max_delay", "2" );
|
|
ConVar hunter_flechette_test( "hunter_flechette_test", "0" );
|
|
ConVar hunter_clamp_shots( "hunter_clamp_shots", "1" );
|
|
ConVar hunter_cheap_explosions( "hunter_cheap_explosions", "1" );
|
|
|
|
// Damage received
|
|
ConVar sk_hunter_bullet_damage_scale( "sk_hunter_bullet_damage_scale", "0.6" );
|
|
ConVar sk_hunter_charge_damage_scale( "sk_hunter_charge_damage_scale", "2.0" );
|
|
ConVar sk_hunter_buckshot_damage_scale( "sk_hunter_buckshot_damage_scale", "0.5" );
|
|
ConVar sk_hunter_vehicle_damage_scale( "sk_hunter_vehicle_damage_scale", "2.2" );
|
|
ConVar sk_hunter_dmg_from_striderbuster( "sk_hunter_dmg_from_striderbuster", "150" );
|
|
ConVar sk_hunter_citizen_damage_scale( "sk_hunter_citizen_damage_scale", "0.3" );
|
|
|
|
ConVar hunter_allow_dissolve( "hunter_allow_dissolve", "1" );
|
|
ConVar hunter_random_expressions( "hunter_random_expressions", "0" );
|
|
ConVar hunter_show_weapon_los_z( "hunter_show_weapon_los_z", "0" );
|
|
ConVar hunter_show_weapon_los_condition( "hunter_show_weapon_los_condition", "0" );
|
|
|
|
ConVar hunter_melee_delay( "hunter_melee_delay", "2.0" );
|
|
|
|
// Bullrush charge.
|
|
ConVar hunter_charge( "hunter_charge", "1" );
|
|
ConVar hunter_charge_min_delay( "hunter_charge_min_delay", "10.0" );
|
|
ConVar hunter_charge_pct( "hunter_charge_pct", "25" );
|
|
ConVar hunter_charge_test( "hunter_charge_test", "0" );
|
|
|
|
// Vehicle dodging.
|
|
ConVar hunter_dodge_warning( "hunter_dodge_warning", "1.1" );
|
|
ConVar hunter_dodge_warning_width( "hunter_dodge_warning_width", "180" );
|
|
ConVar hunter_dodge_warning_cone( "hunter_dodge_warning_cone", ".5" );
|
|
ConVar hunter_dodge_debug( "hunter_dodge_debug", "0" );
|
|
|
|
// Jostle vehicles when hit by them
|
|
ConVar hunter_jostle_car_min_speed( "hunter_jostle_car_min_speed", "100" ); // If hit by a car going at least this fast, jostle the car
|
|
ConVar hunter_jostle_car_max_speed( "hunter_jostle_car_max_speed", "600" ); // Used for determining jostle scale
|
|
|
|
ConVar hunter_free_knowledge( "hunter_free_knowledge", "10.0" );
|
|
ConVar hunter_plant_adjust_z( "hunter_plant_adjust_z", "12" );
|
|
|
|
ConVar hunter_disable_patrol( "hunter_disable_patrol", "0" );
|
|
|
|
// Dealing with striderbusters
|
|
ConVar hunter_hate_held_striderbusters( "hunter_hate_held_striderbusters", "1" );
|
|
ConVar hunter_hate_thrown_striderbusters( "hunter_hate_thrown_striderbusters", "1" );
|
|
ConVar hunter_hate_attached_striderbusters( "hunter_hate_attached_striderbusters", "1" );
|
|
ConVar hunter_hate_held_striderbusters_delay( "hunter_hate_held_striderbusters_delay", "0.5" );
|
|
ConVar hunter_hate_held_striderbusters_tolerance( "hunter_hate_held_striderbusters_tolerance", "2000.0" );
|
|
ConVar hunter_hate_thrown_striderbusters_tolerance( "hunter_hate_thrown_striderbusters_tolerance", "300.0" );
|
|
ConVar hunter_seek_thrown_striderbusters_tolerance( "hunter_seek_thrown_striderbusters_tolerance", "400.0" );
|
|
ConVar hunter_retreat_striderbusters( "hunter_retreat_striderbusters", "1", FCVAR_NONE, "If true, the hunter will retreat when a buster is glued to him." );
|
|
|
|
ConVar hunter_allow_nav_jump( "hunter_allow_nav_jump", "0" );
|
|
ConVar g_debug_hunter_charge( "g_debug_hunter_charge", "0" );
|
|
|
|
ConVar hunter_stand_still( "hunter_stand_still", "0" ); // used for debugging, keeps them rooted in place
|
|
|
|
ConVar hunter_siege_frequency( "hunter_siege_frequency", "12" );
|
|
|
|
#define HUNTER_FOV_DOT 0.0 // 180 degree field of view
|
|
#define HUNTER_CHARGE_MIN 256
|
|
#define HUNTER_CHARGE_MAX 1024
|
|
#define HUNTER_FACE_ENEMY_DIST 512.0f
|
|
#define HUNTER_MELEE_REACH 80
|
|
#define HUNTER_BLOOD_LEFT_FOOT 0
|
|
#define HUNTER_IGNORE_ENEMY_TIME 5 // How long the hunter will ignore another enemy when distracted by the player.
|
|
|
|
#define HUNTER_FACING_DOT 0.8 // The angle within which we start shooting
|
|
#define HUNTER_SHOOT_MAX_YAW_DEG 60.0f // Once shooting, clamp to +/- these degrees of yaw deflection as our target moves
|
|
#define HUNTER_SHOOT_MAX_YAW_COS 0.5f // The cosine of the above angle
|
|
|
|
#define HUNTER_FLECHETTE_WARN_TIME 1.0f
|
|
|
|
#define HUNTER_SEE_ENEMY_TIME_INVALID -1
|
|
|
|
#define NUM_FLECHETTE_VOLLEY_ON_FOLLOW 4
|
|
|
|
#define HUNTER_SIEGE_MAX_DIST_MODIFIER 2.0f
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Animation events
|
|
//-----------------------------------------------------------------------------
|
|
int AE_HUNTER_FOOTSTEP_LEFT;
|
|
int AE_HUNTER_FOOTSTEP_RIGHT;
|
|
int AE_HUNTER_FOOTSTEP_BACK;
|
|
int AE_HUNTER_MELEE_ANNOUNCE;
|
|
int AE_HUNTER_MELEE_ATTACK_LEFT;
|
|
int AE_HUNTER_MELEE_ATTACK_RIGHT;
|
|
int AE_HUNTER_DIE;
|
|
int AE_HUNTER_SPRAY_BLOOD;
|
|
int AE_HUNTER_START_EXPRESSION;
|
|
int AE_HUNTER_END_EXPRESSION;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Interactions.
|
|
//-----------------------------------------------------------------------------
|
|
int g_interactionHunterFoundEnemy = 0;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Local stuff.
|
|
//-----------------------------------------------------------------------------
|
|
static string_t s_iszStriderClassname;
|
|
static string_t s_iszStriderBusterClassname;
|
|
static string_t s_iszMagnadeClassname;
|
|
static string_t s_iszPhysPropClassname;
|
|
static string_t s_iszHuntersToRunOver;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Custom Activities
|
|
//-----------------------------------------------------------------------------
|
|
Activity ACT_HUNTER_DEPLOYRA2;
|
|
Activity ACT_HUNTER_DODGER;
|
|
Activity ACT_HUNTER_DODGEL;
|
|
Activity ACT_HUNTER_GESTURE_SHOOT;
|
|
Activity ACT_HUNTER_FLINCH_STICKYBOMB;
|
|
Activity ACT_HUNTER_STAGGER;
|
|
Activity ACT_HUNTER_MELEE_ATTACK1_VS_PLAYER;
|
|
Activity ACT_DI_HUNTER_MELEE;
|
|
Activity ACT_DI_HUNTER_THROW;
|
|
Activity ACT_HUNTER_ANGRY;
|
|
Activity ACT_HUNTER_WALK_ANGRY;
|
|
Activity ACT_HUNTER_FOUND_ENEMY;
|
|
Activity ACT_HUNTER_FOUND_ENEMY_ACK;
|
|
Activity ACT_HUNTER_CHARGE_START;
|
|
Activity ACT_HUNTER_CHARGE_RUN;
|
|
Activity ACT_HUNTER_CHARGE_STOP;
|
|
Activity ACT_HUNTER_CHARGE_CRASH;
|
|
Activity ACT_HUNTER_CHARGE_HIT;
|
|
Activity ACT_HUNTER_RANGE_ATTACK2_UNPLANTED;
|
|
Activity ACT_HUNTER_IDLE_PLANTED;
|
|
Activity ACT_HUNTER_FLINCH_N;
|
|
Activity ACT_HUNTER_FLINCH_S;
|
|
Activity ACT_HUNTER_FLINCH_E;
|
|
Activity ACT_HUNTER_FLINCH_W;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Squad slots
|
|
//-----------------------------------------------------------------------------
|
|
enum SquadSlot_t
|
|
{
|
|
SQUAD_SLOT_HUNTER_CHARGE = LAST_SHARED_SQUADSLOT,
|
|
SQUAD_SLOT_HUNTER_FLANK_FIRST,
|
|
SQUAD_SLOT_HUNTER_FLANK_LAST = SQUAD_SLOT_HUNTER_FLANK_FIRST,
|
|
SQUAD_SLOT_RUN_SHOOT,
|
|
};
|
|
|
|
#define HUNTER_FOLLOW_DISTANCE 2000.0f
|
|
#define HUNTER_FOLLOW_DISTANCE_SQR (HUNTER_FOLLOW_DISTANCE * HUNTER_FOLLOW_DISTANCE)
|
|
|
|
#define HUNTER_RUNDOWN_SQUADDATA 0
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// We're doing this quite a lot, so this makes the check a lot faster since
|
|
// we don't have to compare strings.
|
|
//-----------------------------------------------------------------------------
|
|
bool IsStriderBuster( CBaseEntity *pEntity )
|
|
{
|
|
if ( !pEntity )
|
|
return false;
|
|
|
|
if( pEntity->m_iClassname == s_iszStriderBusterClassname ||
|
|
pEntity->m_iClassname == s_iszMagnadeClassname)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool HateThisStriderBuster( CBaseEntity *pTarget )
|
|
{
|
|
if ( StriderBuster_WasKnockedOffStrider(pTarget) )
|
|
return false;
|
|
|
|
if ( pTarget->VPhysicsGetObject() )
|
|
{
|
|
if ( hunter_hate_held_striderbusters.GetBool() ||
|
|
hunter_hate_thrown_striderbusters.GetBool() ||
|
|
hunter_hate_attached_striderbusters.GetBool() )
|
|
{
|
|
if ( ( pTarget->VPhysicsGetObject()->GetGameFlags() & ( FVPHYSICS_PLAYER_HELD | FVPHYSICS_WAS_THROWN ) ) )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if ( StriderBuster_IsAttachedStriderBuster( pTarget ) )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The hunter can fire a volley of explosive flechettes.
|
|
//-----------------------------------------------------------------------------
|
|
static const char *s_szHunterFlechetteBubbles = "HunterFlechetteBubbles";
|
|
static const char *s_szHunterFlechetteSeekThink = "HunterFlechetteSeekThink";
|
|
static const char *s_szHunterFlechetteDangerSoundThink = "HunterFlechetteDangerSoundThink";
|
|
static const char *s_szHunterFlechetteSpriteTrail = "sprites/bluelaser1.vmt";
|
|
static int s_nHunterFlechetteImpact = -2;
|
|
static int s_nFlechetteFuseAttach = -1;
|
|
|
|
#define FLECHETTE_AIR_VELOCITY 2500
|
|
|
|
class CHunterFlechette : public CPhysicsProp, public IParentPropInteraction
|
|
{
|
|
DECLARE_CLASS( CHunterFlechette, CPhysicsProp );
|
|
|
|
public:
|
|
|
|
CHunterFlechette();
|
|
~CHunterFlechette();
|
|
|
|
Class_T Classify() { return CLASS_NONE; }
|
|
|
|
bool WasThrownBack()
|
|
{
|
|
return m_bThrownBack;
|
|
}
|
|
|
|
public:
|
|
|
|
void Spawn();
|
|
void Activate();
|
|
void Precache();
|
|
void Shoot( Vector &vecVelocity, bool bBright );
|
|
void SetSeekTarget( CBaseEntity *pTargetEntity );
|
|
void Explode();
|
|
|
|
bool CreateVPhysics();
|
|
|
|
unsigned int PhysicsSolidMaskForEntity() const;
|
|
static CHunterFlechette *FlechetteCreate( const Vector &vecOrigin, const QAngle &angAngles, CBaseEntity *pentOwner = NULL );
|
|
|
|
// IParentPropInteraction
|
|
void OnParentCollisionInteraction( parentCollisionInteraction_t eType, int index, gamevcollisionevent_t *pEvent );
|
|
void OnParentPhysGunDrop( CBasePlayer *pPhysGunUser, PhysGunDrop_t Reason );
|
|
|
|
protected:
|
|
|
|
void SetupGlobalModelData();
|
|
|
|
void StickTo( CBaseEntity *pOther, trace_t &tr );
|
|
|
|
void BubbleThink();
|
|
void DangerSoundThink();
|
|
void ExplodeThink();
|
|
void DopplerThink();
|
|
void SeekThink();
|
|
|
|
bool CreateSprites( bool bBright );
|
|
|
|
void FlechetteTouch( CBaseEntity *pOther );
|
|
|
|
Vector m_vecShootPosition;
|
|
EHANDLE m_hSeekTarget;
|
|
bool m_bThrownBack;
|
|
|
|
DECLARE_DATADESC();
|
|
//DECLARE_SERVERCLASS();
|
|
};
|
|
|
|
LINK_ENTITY_TO_CLASS( hunter_flechette, CHunterFlechette );
|
|
|
|
BEGIN_DATADESC( CHunterFlechette )
|
|
|
|
DEFINE_THINKFUNC( BubbleThink ),
|
|
DEFINE_THINKFUNC( DangerSoundThink ),
|
|
DEFINE_THINKFUNC( ExplodeThink ),
|
|
DEFINE_THINKFUNC( DopplerThink ),
|
|
DEFINE_THINKFUNC( SeekThink ),
|
|
|
|
DEFINE_ENTITYFUNC( FlechetteTouch ),
|
|
|
|
DEFINE_FIELD( m_vecShootPosition, FIELD_POSITION_VECTOR ),
|
|
DEFINE_FIELD( m_hSeekTarget, FIELD_EHANDLE ),
|
|
DEFINE_FIELD( m_bThrownBack, FIELD_BOOLEAN ),
|
|
|
|
END_DATADESC()
|
|
|
|
//IMPLEMENT_SERVERCLASS_ST( CHunterFlechette, DT_HunterFlechette )
|
|
//END_SEND_TABLE()
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
CHunterFlechette *CHunterFlechette::FlechetteCreate( const Vector &vecOrigin, const QAngle &angAngles, CBaseEntity *pentOwner )
|
|
{
|
|
// Create a new entity with CHunterFlechette private data
|
|
CHunterFlechette *pFlechette = (CHunterFlechette *)CreateEntityByName( "hunter_flechette" );
|
|
UTIL_SetOrigin( pFlechette, vecOrigin );
|
|
pFlechette->SetAbsAngles( angAngles );
|
|
pFlechette->Spawn();
|
|
pFlechette->Activate();
|
|
pFlechette->SetOwnerEntity( pentOwner );
|
|
|
|
return pFlechette;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------
|
|
void CC_Hunter_Shoot_Flechette( const CCommand& args )
|
|
{
|
|
MDLCACHE_CRITICAL_SECTION();
|
|
|
|
bool allowPrecache = CBaseEntity::IsPrecacheAllowed();
|
|
CBaseEntity::SetAllowPrecache( true );
|
|
|
|
CBasePlayer *pPlayer = UTIL_GetCommandClient();
|
|
|
|
QAngle angEye = pPlayer->EyeAngles();
|
|
CHunterFlechette *entity = CHunterFlechette::FlechetteCreate( pPlayer->EyePosition(), angEye, pPlayer );
|
|
if ( entity )
|
|
{
|
|
entity->Precache();
|
|
DispatchSpawn( entity );
|
|
|
|
// Shoot the flechette.
|
|
Vector forward;
|
|
pPlayer->EyeVectors( &forward );
|
|
forward *= 2000.0f;
|
|
entity->Shoot( forward, false );
|
|
}
|
|
|
|
CBaseEntity::SetAllowPrecache( allowPrecache );
|
|
}
|
|
|
|
static ConCommand ent_create("hunter_shoot_flechette", CC_Hunter_Shoot_Flechette, "Fires a hunter flechette where the player is looking.", FCVAR_GAMEDLL | FCVAR_CHEAT);
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
CHunterFlechette::CHunterFlechette()
|
|
{
|
|
UseClientSideAnimation();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
CHunterFlechette::~CHunterFlechette()
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// If set, the flechette will seek unerringly toward the target as it flies.
|
|
//-----------------------------------------------------------------------------
|
|
void CHunterFlechette::SetSeekTarget( CBaseEntity *pTargetEntity )
|
|
{
|
|
if ( pTargetEntity )
|
|
{
|
|
m_hSeekTarget = pTargetEntity;
|
|
SetContextThink( &CHunterFlechette::SeekThink, gpGlobals->curtime, s_szHunterFlechetteSeekThink );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CHunterFlechette::CreateVPhysics()
|
|
{
|
|
// Create the object in the physics system
|
|
VPhysicsInitNormal( SOLID_BBOX, FSOLID_NOT_STANDABLE, false );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
unsigned int CHunterFlechette::PhysicsSolidMaskForEntity() const
|
|
{
|
|
return ( BaseClass::PhysicsSolidMaskForEntity() | CONTENTS_HITBOX ) & ~CONTENTS_GRATE;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called from CPropPhysics code when we're attached to a physics object.
|
|
//-----------------------------------------------------------------------------
|
|
void CHunterFlechette::OnParentCollisionInteraction( parentCollisionInteraction_t eType, int index, gamevcollisionevent_t *pEvent )
|
|
{
|
|
if ( eType == COLLISIONINTER_PARENT_FIRST_IMPACT )
|
|
{
|
|
m_bThrownBack = true;
|
|
Explode();
|
|
}
|
|
}
|
|
|
|
void CHunterFlechette::OnParentPhysGunDrop( CBasePlayer *pPhysGunUser, PhysGunDrop_t Reason )
|
|
{
|
|
m_bThrownBack = true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CHunterFlechette::CreateSprites( bool bBright )
|
|
{
|
|
if ( bBright )
|
|
{
|
|
DispatchParticleEffect( "hunter_flechette_trail_striderbuster", PATTACH_ABSORIGIN_FOLLOW, this );
|
|
}
|
|
else
|
|
{
|
|
DispatchParticleEffect( "hunter_flechette_trail", PATTACH_ABSORIGIN_FOLLOW, this );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CHunterFlechette::Spawn()
|
|
{
|
|
Precache( );
|
|
|
|
SetModel( HUNTER_FLECHETTE_MODEL );
|
|
SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_CUSTOM );
|
|
UTIL_SetSize( this, -Vector(1,1,1), Vector(1,1,1) );
|
|
SetSolid( SOLID_BBOX );
|
|
SetGravity( 0.05f );
|
|
SetCollisionGroup( COLLISION_GROUP_PROJECTILE );
|
|
|
|
// Make sure we're updated if we're underwater
|
|
UpdateWaterState();
|
|
|
|
SetTouch( &CHunterFlechette::FlechetteTouch );
|
|
|
|
// Make us glow until we've hit the wall
|
|
m_nSkin = 1;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CHunterFlechette::Activate()
|
|
{
|
|
BaseClass::Activate();
|
|
SetupGlobalModelData();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CHunterFlechette::SetupGlobalModelData()
|
|
{
|
|
if ( s_nHunterFlechetteImpact == -2 )
|
|
{
|
|
s_nHunterFlechetteImpact = LookupSequence( "impact" );
|
|
s_nFlechetteFuseAttach = LookupAttachment( "attach_fuse" );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CHunterFlechette::Precache()
|
|
{
|
|
PrecacheModel( HUNTER_FLECHETTE_MODEL );
|
|
PrecacheModel( "sprites/light_glow02_noz.vmt" );
|
|
|
|
PrecacheScriptSound( "NPC_Hunter.FlechetteNearmiss" );
|
|
PrecacheScriptSound( "NPC_Hunter.FlechetteHitBody" );
|
|
PrecacheScriptSound( "NPC_Hunter.FlechetteHitWorld" );
|
|
PrecacheScriptSound( "NPC_Hunter.FlechettePreExplode" );
|
|
PrecacheScriptSound( "NPC_Hunter.FlechetteExplode" );
|
|
|
|
PrecacheParticleSystem( "hunter_flechette_trail_striderbuster" );
|
|
PrecacheParticleSystem( "hunter_flechette_trail" );
|
|
PrecacheParticleSystem( "hunter_projectile_explosion_1" );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CHunterFlechette::StickTo( CBaseEntity *pOther, trace_t &tr )
|
|
{
|
|
EmitSound( "NPC_Hunter.FlechetteHitWorld" );
|
|
|
|
SetMoveType( MOVETYPE_NONE );
|
|
|
|
if ( !pOther->IsWorld() )
|
|
{
|
|
SetParent( pOther );
|
|
SetSolid( SOLID_NONE );
|
|
SetSolidFlags( FSOLID_NOT_SOLID );
|
|
}
|
|
|
|
// Do an impact effect.
|
|
//Vector vecDir = GetAbsVelocity();
|
|
//float speed = VectorNormalize( vecDir );
|
|
|
|
//Vector vForward;
|
|
//AngleVectors( GetAbsAngles(), &vForward );
|
|
//VectorNormalize ( vForward );
|
|
|
|
//CEffectData data;
|
|
//data.m_vOrigin = tr.endpos;
|
|
//data.m_vNormal = vForward;
|
|
//data.m_nEntIndex = 0;
|
|
//DispatchEffect( "BoltImpact", data );
|
|
|
|
Vector vecVelocity = GetAbsVelocity();
|
|
bool bAttachedToBuster = StriderBuster_OnFlechetteAttach( pOther, vecVelocity );
|
|
|
|
SetTouch( NULL );
|
|
|
|
// We're no longer flying. Stop checking for water volumes.
|
|
SetContextThink( NULL, 0, s_szHunterFlechetteBubbles );
|
|
|
|
// Stop seeking.
|
|
m_hSeekTarget = NULL;
|
|
SetContextThink( NULL, 0, s_szHunterFlechetteSeekThink );
|
|
|
|
// Get ready to explode.
|
|
if ( !bAttachedToBuster )
|
|
{
|
|
SetThink( &CHunterFlechette::DangerSoundThink );
|
|
SetNextThink( gpGlobals->curtime + (hunter_flechette_explode_delay.GetFloat() - HUNTER_FLECHETTE_WARN_TIME) );
|
|
}
|
|
else
|
|
{
|
|
DangerSoundThink();
|
|
}
|
|
|
|
// Play our impact animation.
|
|
ResetSequence( s_nHunterFlechetteImpact );
|
|
|
|
static int s_nImpactCount = 0;
|
|
s_nImpactCount++;
|
|
if ( s_nImpactCount & 0x01 )
|
|
{
|
|
UTIL_ImpactTrace( &tr, DMG_BULLET );
|
|
|
|
// Shoot some sparks
|
|
if ( UTIL_PointContents( GetAbsOrigin() ) != CONTENTS_WATER)
|
|
{
|
|
g_pEffects->Sparks( GetAbsOrigin() );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CHunterFlechette::FlechetteTouch( CBaseEntity *pOther )
|
|
{
|
|
if ( pOther->IsSolidFlagSet(FSOLID_VOLUME_CONTENTS | FSOLID_TRIGGER) )
|
|
{
|
|
// Some NPCs are triggers that can take damage (like antlion grubs). We should hit them.
|
|
if ( ( pOther->m_takedamage == DAMAGE_NO ) || ( pOther->m_takedamage == DAMAGE_EVENTS_ONLY ) )
|
|
return;
|
|
}
|
|
|
|
if ( FClassnameIs( pOther, "hunter_flechette" ) )
|
|
return;
|
|
|
|
trace_t tr;
|
|
tr = BaseClass::GetTouchTrace();
|
|
|
|
if ( pOther->m_takedamage != DAMAGE_NO )
|
|
{
|
|
Vector vecNormalizedVel = GetAbsVelocity();
|
|
|
|
ClearMultiDamage();
|
|
VectorNormalize( vecNormalizedVel );
|
|
|
|
float flDamage = sk_hunter_dmg_flechette.GetFloat();
|
|
CBreakable *pBreak = dynamic_cast <CBreakable *>(pOther);
|
|
if ( pBreak && ( pBreak->GetMaterialType() == matGlass ) )
|
|
{
|
|
flDamage = MAX( pOther->GetHealth(), flDamage );
|
|
}
|
|
|
|
CTakeDamageInfo dmgInfo( this, GetOwnerEntity(), flDamage, DMG_DISSOLVE | DMG_NEVERGIB );
|
|
CalculateMeleeDamageForce( &dmgInfo, vecNormalizedVel, tr.endpos, 0.7f );
|
|
dmgInfo.SetDamagePosition( tr.endpos );
|
|
pOther->DispatchTraceAttack( dmgInfo, vecNormalizedVel, &tr );
|
|
|
|
ApplyMultiDamage();
|
|
|
|
// Keep going through breakable glass.
|
|
if ( pOther->GetCollisionGroup() == COLLISION_GROUP_BREAKABLE_GLASS )
|
|
return;
|
|
|
|
SetAbsVelocity( Vector( 0, 0, 0 ) );
|
|
|
|
// play body "thwack" sound
|
|
EmitSound( "NPC_Hunter.FlechetteHitBody" );
|
|
|
|
StopParticleEffects( this );
|
|
|
|
Vector vForward;
|
|
AngleVectors( GetAbsAngles(), &vForward );
|
|
VectorNormalize ( vForward );
|
|
|
|
trace_t tr2;
|
|
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + vForward * 128, MASK_BLOCKLOS, pOther, COLLISION_GROUP_NONE, &tr2 );
|
|
|
|
if ( tr2.fraction != 1.0f )
|
|
{
|
|
//NDebugOverlay::Box( tr2.endpos, Vector( -16, -16, -16 ), Vector( 16, 16, 16 ), 0, 255, 0, 0, 10 );
|
|
//NDebugOverlay::Box( GetAbsOrigin(), Vector( -16, -16, -16 ), Vector( 16, 16, 16 ), 0, 0, 255, 0, 10 );
|
|
|
|
if ( tr2.m_pEnt == NULL || ( tr2.m_pEnt && tr2.m_pEnt->GetMoveType() == MOVETYPE_NONE ) )
|
|
{
|
|
CEffectData data;
|
|
|
|
data.m_vOrigin = tr2.endpos;
|
|
data.m_vNormal = vForward;
|
|
data.m_nEntIndex = tr2.fraction != 1.0f;
|
|
|
|
//DispatchEffect( "BoltImpact", data );
|
|
}
|
|
}
|
|
|
|
if ( ( ( pOther->GetMoveType() == MOVETYPE_VPHYSICS ) || ( pOther->GetMoveType() == MOVETYPE_PUSH ) ) && ( ( pOther->GetHealth() > 0 ) || ( pOther->m_takedamage == DAMAGE_EVENTS_ONLY ) ) )
|
|
{
|
|
CPhysicsProp *pProp = dynamic_cast<CPhysicsProp *>( pOther );
|
|
if ( pProp )
|
|
{
|
|
pProp->SetInteraction( PROPINTER_PHYSGUN_NOTIFY_CHILDREN );
|
|
}
|
|
|
|
// We hit a physics object that survived the impact. Stick to it.
|
|
StickTo( pOther, tr );
|
|
}
|
|
else
|
|
{
|
|
SetTouch( NULL );
|
|
SetThink( NULL );
|
|
SetContextThink( NULL, 0, s_szHunterFlechetteBubbles );
|
|
|
|
UTIL_Remove( this );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// See if we struck the world
|
|
if ( pOther->GetMoveType() == MOVETYPE_NONE && !( tr.surface.flags & SURF_SKY ) )
|
|
{
|
|
// We hit a physics object that survived the impact. Stick to it.
|
|
StickTo( pOther, tr );
|
|
}
|
|
else if( pOther->GetMoveType() == MOVETYPE_PUSH && FClassnameIs(pOther, "func_breakable") )
|
|
{
|
|
// We hit a func_breakable, stick to it.
|
|
// The MOVETYPE_PUSH is a micro-optimization to cut down on the classname checks.
|
|
StickTo( pOther, tr );
|
|
}
|
|
else
|
|
{
|
|
// Put a mark unless we've hit the sky
|
|
if ( ( tr.surface.flags & SURF_SKY ) == false )
|
|
{
|
|
UTIL_ImpactTrace( &tr, DMG_BULLET );
|
|
}
|
|
|
|
UTIL_Remove( this );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Fixup flechette position when seeking towards a striderbuster.
|
|
//-----------------------------------------------------------------------------
|
|
void CHunterFlechette::SeekThink()
|
|
{
|
|
if ( m_hSeekTarget )
|
|
{
|
|
Vector vecBodyTarget = m_hSeekTarget->BodyTarget( GetAbsOrigin() );
|
|
|
|
Vector vecClosest;
|
|
CalcClosestPointOnLineSegment( GetAbsOrigin(), m_vecShootPosition, vecBodyTarget, vecClosest, NULL );
|
|
|
|
Vector vecDelta = vecBodyTarget - m_vecShootPosition;
|
|
VectorNormalize( vecDelta );
|
|
|
|
QAngle angShoot;
|
|
VectorAngles( vecDelta, angShoot );
|
|
|
|
float flSpeed = hunter_flechette_speed.GetFloat();
|
|
if ( !flSpeed )
|
|
{
|
|
flSpeed = 2500.0f;
|
|
}
|
|
|
|
Vector vecVelocity = vecDelta * flSpeed;
|
|
Teleport( &vecClosest, &angShoot, &vecVelocity );
|
|
|
|
SetNextThink( gpGlobals->curtime, s_szHunterFlechetteSeekThink );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Play a near miss sound as we travel past the player.
|
|
//-----------------------------------------------------------------------------
|
|
void CHunterFlechette::DopplerThink()
|
|
{
|
|
CBasePlayer *pPlayer = AI_GetSinglePlayer();
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
Vector vecVelocity = GetAbsVelocity();
|
|
VectorNormalize( vecVelocity );
|
|
|
|
float flMyDot = DotProduct( vecVelocity, GetAbsOrigin() );
|
|
float flPlayerDot = DotProduct( vecVelocity, pPlayer->GetAbsOrigin() );
|
|
|
|
if ( flPlayerDot <= flMyDot )
|
|
{
|
|
EmitSound( "NPC_Hunter.FlechetteNearMiss" );
|
|
|
|
// We've played the near miss sound and we're not seeking. Stop thinking.
|
|
SetThink( NULL );
|
|
}
|
|
else
|
|
{
|
|
SetNextThink( gpGlobals->curtime );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Think every 0.1 seconds to make bubbles if we're flying through water.
|
|
//-----------------------------------------------------------------------------
|
|
void CHunterFlechette::BubbleThink()
|
|
{
|
|
SetNextThink( gpGlobals->curtime + 0.1f, s_szHunterFlechetteBubbles );
|
|
|
|
if ( GetWaterLevel() == 0 )
|
|
return;
|
|
|
|
UTIL_BubbleTrail( GetAbsOrigin() - GetAbsVelocity() * 0.1f, GetAbsOrigin(), 5 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CHunterFlechette::Shoot( Vector &vecVelocity, bool bBrightFX )
|
|
{
|
|
CreateSprites( bBrightFX );
|
|
|
|
m_vecShootPosition = GetAbsOrigin();
|
|
|
|
SetAbsVelocity( vecVelocity );
|
|
|
|
SetThink( &CHunterFlechette::DopplerThink );
|
|
SetNextThink( gpGlobals->curtime );
|
|
|
|
SetContextThink( &CHunterFlechette::BubbleThink, gpGlobals->curtime + 0.1, s_szHunterFlechetteBubbles );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CHunterFlechette::DangerSoundThink()
|
|
{
|
|
EmitSound( "NPC_Hunter.FlechettePreExplode" );
|
|
|
|
CSoundEnt::InsertSound( SOUND_DANGER|SOUND_CONTEXT_EXCLUDE_COMBINE, GetAbsOrigin(), 150.0f, 0.5, this );
|
|
SetThink( &CHunterFlechette::ExplodeThink );
|
|
SetNextThink( gpGlobals->curtime + HUNTER_FLECHETTE_WARN_TIME );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CHunterFlechette::ExplodeThink()
|
|
{
|
|
Explode();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CHunterFlechette::Explode()
|
|
{
|
|
SetSolid( SOLID_NONE );
|
|
|
|
// Don't catch self in own explosion!
|
|
m_takedamage = DAMAGE_NO;
|
|
|
|
EmitSound( "NPC_Hunter.FlechetteExplode" );
|
|
|
|
// Move the explosion effect to the tip to reduce intersection with the world.
|
|
Vector vecFuse;
|
|
GetAttachment( s_nFlechetteFuseAttach, vecFuse );
|
|
DispatchParticleEffect( "hunter_projectile_explosion_1", vecFuse, GetAbsAngles(), NULL );
|
|
|
|
int nDamageType = DMG_DISSOLVE;
|
|
|
|
// Perf optimization - only every other explosion makes a physics force. This is
|
|
// hardly noticeable since flechettes usually explode in clumps.
|
|
static int s_nExplosionCount = 0;
|
|
s_nExplosionCount++;
|
|
if ( ( s_nExplosionCount & 0x01 ) && hunter_cheap_explosions.GetBool() )
|
|
{
|
|
nDamageType |= DMG_PREVENT_PHYSICS_FORCE;
|
|
}
|
|
|
|
RadiusDamage( CTakeDamageInfo( this, GetOwnerEntity(), sk_hunter_flechette_explode_dmg.GetFloat(), nDamageType ), GetAbsOrigin(), sk_hunter_flechette_explode_radius.GetFloat(), CLASS_NONE, NULL );
|
|
|
|
AddEffects( EF_NODRAW );
|
|
|
|
SetThink( &CBaseEntity::SUB_Remove );
|
|
SetNextThink( gpGlobals->curtime + 0.1f );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Calculate & apply damage & force for a charge to a target.
|
|
// Done outside of the hunter because we need to do this inside a trace filter.
|
|
//-----------------------------------------------------------------------------
|
|
void Hunter_ApplyChargeDamage( CBaseEntity *pHunter, CBaseEntity *pTarget, float flDamage )
|
|
{
|
|
Vector attackDir = ( pTarget->WorldSpaceCenter() - pHunter->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( pHunter, pHunter, vecForce, offset, flDamage, DMG_CLUB );
|
|
pTarget->TakeDamage( info );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// A simple trace filter class to skip small moveable physics objects
|
|
//-----------------------------------------------------------------------------
|
|
class CHunterTraceFilterSkipPhysics : public CTraceFilter
|
|
{
|
|
public:
|
|
// It does have a base, but we'll never network anything below here..
|
|
DECLARE_CLASS_NOBASE( CHunterTraceFilterSkipPhysics );
|
|
|
|
CHunterTraceFilterSkipPhysics( 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 )
|
|
{
|
|
float entMass = PhysGetEntityMass( pEntity ) ;
|
|
if ( entMass < m_minMass )
|
|
{
|
|
if ( entMass < m_minMass * 0.666f || pEntity->CollisionProp()->BoundingRadius() < (assert_cast<const CAI_BaseNPC *>(EntityFromEntityHandle( m_pPassEnt )))->GetHullHeight() )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we hit an antlion, don't stop, but kill it
|
|
if ( pEntity->Classify() == CLASS_ANTLION )
|
|
{
|
|
CBaseEntity *pHunter = (CBaseEntity *)EntityFromEntityHandle( m_pPassEnt );
|
|
Hunter_ApplyChargeDamage( pHunter, pEntity, pEntity->GetHealth() );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
const IHandleEntity *m_pPassEnt;
|
|
int m_collisionGroup;
|
|
float m_minMass;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
inline void HunterTraceHull_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 );
|
|
CHunterTraceFilterSkipPhysics traceFilter( ignore, collisionGroup, minMass );
|
|
enginetrace->TraceRay( ray, mask, &traceFilter, ptr );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Hunter follow behavior
|
|
//-----------------------------------------------------------------------------
|
|
class CAI_HunterEscortBehavior : public CAI_FollowBehavior
|
|
{
|
|
public:
|
|
DECLARE_CLASS( CAI_HunterEscortBehavior, CAI_FollowBehavior );
|
|
|
|
CAI_HunterEscortBehavior() :
|
|
BaseClass( AI_FollowParams_t( AIF_HUNTER, true ) ),
|
|
m_flTimeEscortReturn( 0 ),
|
|
m_bEnabled( false )
|
|
{
|
|
}
|
|
|
|
CNPC_Hunter *GetOuter() { return (CNPC_Hunter *)( BaseClass::GetOuter() ); }
|
|
|
|
void SetEscortTarget( CNPC_Strider *pLeader, bool fFinishCurSchedule = false );
|
|
CNPC_Strider * GetEscortTarget() { return (CNPC_Strider *)GetFollowTarget(); }
|
|
|
|
bool FarFromFollowTarget()
|
|
{
|
|
return ( GetFollowTarget() && (GetAbsOrigin() - GetFollowTarget()->GetAbsOrigin()).LengthSqr() > HUNTER_FOLLOW_DISTANCE_SQR );
|
|
}
|
|
|
|
void DrawDebugGeometryOverlays();
|
|
bool ShouldFollow();
|
|
void BuildScheduleTestBits();
|
|
|
|
void BeginScheduleSelection();
|
|
|
|
void GatherConditions();
|
|
void GatherConditionsNotActive();
|
|
int SelectSchedule();
|
|
int FollowCallBaseSelectSchedule();
|
|
void StartTask( const Task_t *pTask );
|
|
void RunTask( const Task_t *pTask );
|
|
|
|
void CheckBreakEscort();
|
|
|
|
void OnDamage( const CTakeDamageInfo &info );
|
|
static void DistributeFreeHunters();
|
|
static void FindFreeHunters( CUtlVector<CNPC_Hunter *> *pFreeHunters );
|
|
|
|
float m_flTimeEscortReturn;
|
|
CSimpleSimTimer m_FollowAttackTimer;
|
|
bool m_bEnabled;
|
|
|
|
static float gm_flLastDefendSound; // not saved and loaded, it's okay to yell again after a load
|
|
|
|
//---------------------------------
|
|
|
|
DECLARE_DATADESC();
|
|
};
|
|
|
|
|
|
BEGIN_DATADESC( CAI_HunterEscortBehavior )
|
|
DEFINE_FIELD( m_flTimeEscortReturn, FIELD_TIME ),
|
|
DEFINE_EMBEDDED( m_FollowAttackTimer ),
|
|
DEFINE_FIELD( m_bEnabled, FIELD_BOOLEAN ),
|
|
END_DATADESC();
|
|
|
|
float CAI_HunterEscortBehavior::gm_flLastDefendSound;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Hunter PHYSICS DAMAGE TABLE
|
|
//-----------------------------------------------------------------------------
|
|
#define HUNTER_MIN_PHYSICS_DAMAGE 10
|
|
|
|
static impactentry_t s_HunterLinearTable[] =
|
|
{
|
|
{ 150*150, 75 },
|
|
{ 350*350, 105 },
|
|
{ 1000*1000, 300 },
|
|
};
|
|
|
|
static impactentry_t s_HunterAngularTable[] =
|
|
{
|
|
{ 100*100, 75 },
|
|
{ 200*200, 105 },
|
|
{ 300*300, 300 },
|
|
};
|
|
|
|
impactdamagetable_t s_HunterImpactDamageTable =
|
|
{
|
|
s_HunterLinearTable,
|
|
s_HunterAngularTable,
|
|
|
|
ARRAYSIZE(s_HunterLinearTable),
|
|
ARRAYSIZE(s_HunterAngularTable),
|
|
|
|
24*24, // minimum linear speed squared
|
|
360*360, // minimum angular speed squared (360 deg/s to cause spin/slice damage)
|
|
5, // can't take damage from anything under 5kg
|
|
|
|
10, // anything less than 10kg is "small"
|
|
HUNTER_MIN_PHYSICS_DAMAGE, // never take more than 10 pts of damage from anything under 10kg
|
|
36*36, // <10kg objects must go faster than 36 in/s to do damage
|
|
|
|
VPHYSICS_LARGE_OBJECT_MASS, // large mass in kg
|
|
4, // large mass scale (anything over 500kg does 4X as much energy to read from damage table)
|
|
5, // large mass falling scale (emphasize falling/crushing damage over sideways impacts since the stress will kill you anyway)
|
|
0.0f, // min vel
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
class CNPC_Hunter : public CAI_BaseActor
|
|
{
|
|
DECLARE_CLASS( CNPC_Hunter, CAI_BaseActor );
|
|
|
|
public:
|
|
CNPC_Hunter();
|
|
~CNPC_Hunter();
|
|
|
|
//---------------------------------
|
|
|
|
void Precache();
|
|
void Spawn();
|
|
void PostNPCInit();
|
|
void Activate();
|
|
void UpdateOnRemove();
|
|
void OnRestore();
|
|
bool CreateBehaviors();
|
|
void IdleSound();
|
|
bool ShouldPlayIdleSound();
|
|
bool CanBecomeRagdoll();
|
|
Activity GetDeathActivity();
|
|
void StopLoopingSounds();
|
|
|
|
const impactdamagetable_t &GetPhysicsImpactDamageTable();
|
|
|
|
Class_T Classify();
|
|
Vector BodyTarget( const Vector &posSrc, bool bNoisy /*= true*/ );
|
|
|
|
int DrawDebugTextOverlays();
|
|
void DrawDebugGeometryOverlays();
|
|
|
|
void UpdateEfficiency( bool bInPVS );
|
|
|
|
//---------------------------------
|
|
|
|
virtual Vector GetNodeViewOffset() { return BaseClass::GetDefaultEyeOffset(); }
|
|
|
|
int GetSoundInterests();
|
|
|
|
bool IsInLargeOutdoorMap();
|
|
|
|
//---------------------------------
|
|
// CAI_BaseActor
|
|
//---------------------------------
|
|
const char *SelectRandomExpressionForState( NPC_STATE state );
|
|
void PlayExpressionForState( NPC_STATE state );
|
|
|
|
//---------------------------------
|
|
// CBaseAnimating
|
|
//---------------------------------
|
|
float GetIdealAccel() const { return GetIdealSpeed(); }
|
|
|
|
//---------------------------------
|
|
// Behavior
|
|
//---------------------------------
|
|
void NPCThink();
|
|
void PrescheduleThink();
|
|
void GatherConditions();
|
|
void CollectSiegeTargets();
|
|
void ManageSiegeTargets();
|
|
void KillCurrentSiegeTarget();
|
|
bool QueryHearSound( CSound *pSound );
|
|
void OnSeeEntity( CBaseEntity *pEntity );
|
|
void CheckFlinches() {} // Hunter handles on own
|
|
void BuildScheduleTestBits();
|
|
NPC_STATE SelectIdealState();
|
|
int SelectSchedule();
|
|
int SelectCombatSchedule();
|
|
int SelectSiegeSchedule();
|
|
int TranslateSchedule( int scheduleType );
|
|
void StartTask( const Task_t *pTask );
|
|
void RunTask( const Task_t *pTask );
|
|
Activity NPC_TranslateActivity( Activity baseAct );
|
|
void OnChangeActivity( Activity eNewActivity );
|
|
|
|
void HandleAnimEvent( animevent_t *pEvent );
|
|
bool HandleInteraction(int interactionType, void *data, CBaseCombatCharacter *pSourceEnt);
|
|
|
|
void PlayerHasIlluminatedNPC( CBasePlayer *pPlayer, float flDot );
|
|
|
|
void AddEntityRelationship( CBaseEntity *pEntity, Disposition_t nDisposition, int nPriority );
|
|
float EnemyDistTolerance() { return 100.0f; }
|
|
|
|
bool ScheduledMoveToGoalEntity( int scheduleType, CBaseEntity *pGoalEntity, Activity movementActivity );
|
|
|
|
void OnChangeHintGroup( string_t oldGroup, string_t newGroup );
|
|
|
|
bool IsUsingSiegeTargets() { return m_iszSiegeTargetName != NULL_STRING; }
|
|
|
|
//---------------------------------
|
|
// Inputs
|
|
//---------------------------------
|
|
void InputDodge( inputdata_t &inputdata );
|
|
void InputFlankEnemy( inputdata_t &inputdata );
|
|
void InputDisableShooting( inputdata_t &inputdata );
|
|
void InputEnableShooting( inputdata_t &inputdata );
|
|
void InputFollowStrider( inputdata_t &inputdata );
|
|
void InputUseSiegeTargets( inputdata_t &inputdata );
|
|
void InputEnableSquadShootDelay( inputdata_t &inputdata );
|
|
void InputDisableSquadShootDelay( inputdata_t &inputdata );
|
|
void InputEnableUnplantedShooting( inputdata_t &inputdata );
|
|
void InputDisableUnplantedShooting( inputdata_t &inputdata );
|
|
|
|
//---------------------------------
|
|
// Combat
|
|
//---------------------------------
|
|
bool FVisible( CBaseEntity *pEntity, int traceMask = MASK_BLOCKLOS, CBaseEntity **ppBlocker = NULL );
|
|
bool IsValidEnemy( CBaseEntity *pEnemy );
|
|
|
|
Disposition_t IRelationType( CBaseEntity *pTarget );
|
|
int IRelationPriority( CBaseEntity *pTarget );
|
|
|
|
void SetSquad( CAI_Squad *pSquad );
|
|
|
|
bool UpdateEnemyMemory( CBaseEntity *pEnemy, const Vector &position, CBaseEntity *pInformer = NULL );
|
|
|
|
int RangeAttack1Conditions( float flDot, float flDist );
|
|
int RangeAttack2Conditions( float flDot, float flDist );
|
|
|
|
int MeleeAttack1Conditions ( float flDot, float flDist );
|
|
int MeleeAttack1ConditionsVsEnemyInVehicle( CBaseCombatCharacter *pEnemy, float flDot );
|
|
|
|
int MeleeAttack2Conditions( float flDot, float flDist );
|
|
|
|
bool WeaponLOSCondition(const Vector &ownerPos, const Vector &targetPos, bool bSetConditions);
|
|
bool TestShootPosition(const Vector &vecShootPos, const Vector &targetPos );
|
|
|
|
Vector Weapon_ShootPosition();
|
|
|
|
CBaseEntity * MeleeAttack( float flDist, int iDamage, QAngle &qaViewPunch, Vector &vecVelocityPunch, int BloodOrigin );
|
|
|
|
void MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType );
|
|
void DoMuzzleFlash( int nAttachment );
|
|
|
|
bool CanShootThrough( const trace_t &tr, const Vector &vecTarget );
|
|
|
|
int CountRangedAttackers();
|
|
void DelayRangedAttackers( float minDelay, float maxDelay, bool bForced = false );
|
|
|
|
//---------------------------------
|
|
// Sounds & speech
|
|
//---------------------------------
|
|
void AlertSound();
|
|
void PainSound( const CTakeDamageInfo &info );
|
|
void DeathSound( const CTakeDamageInfo &info );
|
|
|
|
//---------------------------------
|
|
// Damage handling
|
|
//---------------------------------
|
|
void TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator );
|
|
bool IsHeavyDamage( const CTakeDamageInfo &info );
|
|
int OnTakeDamage( const CTakeDamageInfo &info );
|
|
int OnTakeDamage_Alive( const CTakeDamageInfo &info );
|
|
void Event_Killed( const CTakeDamageInfo &info );
|
|
|
|
void StartBleeding();
|
|
inline bool IsBleeding() { return m_bIsBleeding; }
|
|
void Explode();
|
|
|
|
void SetupGlobalModelData();
|
|
|
|
//---------------------------------
|
|
// Navigation & Movement
|
|
//---------------------------------
|
|
bool OverrideMoveFacing( const AILocalMoveGoal_t &move, float flInterval );
|
|
float MaxYawSpeed();
|
|
bool IsJumpLegal(const Vector &startPos, const Vector &apex, const Vector &endPos) const;
|
|
float GetJumpGravity() const { return 3.0f; }
|
|
bool ShouldProbeCollideAgainstEntity( CBaseEntity *pEntity );
|
|
void TaskFail( AI_TaskFailureCode_t code );
|
|
void TaskFail( const char *pszGeneralFailText ) { TaskFail( MakeFailCode( pszGeneralFailText ) ); }
|
|
|
|
CAI_BaseNPC * GetEntity() { return this; }
|
|
|
|
//---------------------------------
|
|
// Magnade
|
|
//---------------------------------
|
|
void StriderBusterAttached( CBaseEntity *pAttached );
|
|
void StriderBusterDetached( CBaseEntity *pAttached );
|
|
|
|
private:
|
|
|
|
void ConsiderFlinching( const CTakeDamageInfo &info );
|
|
|
|
void TaskFindDodgeActivity();
|
|
|
|
void GatherChargeConditions();
|
|
void GatherIndoorOutdoorConditions();
|
|
|
|
// Charge attack.
|
|
bool ShouldCharge( const Vector &startPos, const Vector &endPos, bool useTime, bool bCheckForCancel );
|
|
void ChargeLookAhead();
|
|
float ChargeSteer();
|
|
bool EnemyIsRightInFrontOfMe( CBaseEntity **pEntity );
|
|
void ChargeDamage( CBaseEntity *pTarget );
|
|
bool HandleChargeImpact( Vector vecImpact, CBaseEntity *pEntity );
|
|
|
|
void BeginVolley( int nNum, float flStartTime );
|
|
bool ShootFlechette( CBaseEntity *pTargetEntity, bool bSingleShot );
|
|
bool ShouldSeekTarget( CBaseEntity *pTargetEntity, bool bStriderBuster );
|
|
void GetShootDir( Vector &vecDir, const Vector &vecSrc, CBaseEntity *pTargetEntity, bool bStriderbuster, int nShotNum, bool bSingleShot );
|
|
bool ClampShootDir( Vector &vecDir );
|
|
|
|
void SetAim( const Vector &aimDir, float flInterval );
|
|
void RelaxAim( float flInterval );
|
|
void UpdateAim();
|
|
void UpdateEyes();
|
|
void LockBothEyes( float flDuration );
|
|
void UnlockBothEyes( float flDuration );
|
|
|
|
void TeslaThink();
|
|
void BleedThink();
|
|
void JostleVehicleThink();
|
|
|
|
void FollowStrider( const char *szStrider );
|
|
void FollowStrider( CNPC_Strider * pStrider );
|
|
int NumHuntersInMySquad();
|
|
|
|
bool CanPlantHere( const Vector &vecPos );
|
|
|
|
//---------------------------------
|
|
// Foot handling
|
|
//---------------------------------
|
|
Vector LeftFootHit( float eventtime );
|
|
Vector RightFootHit( float eventtime );
|
|
Vector BackFootHit( float eventtime );
|
|
|
|
void FootFX( const Vector &origin );
|
|
|
|
CBaseEntity *GetEnemyVehicle();
|
|
bool IsCorporealEnemy( CBaseEntity *pEnemy );
|
|
|
|
void PhysicsDamageEffect( const Vector &vecPos, const Vector &vecDir );
|
|
bool PlayerFlashlightOnMyEyes( CBasePlayer *pPlayer );
|
|
|
|
//-----------------------------------------------------
|
|
// Conditions, Schedules, Tasks
|
|
//-----------------------------------------------------
|
|
enum
|
|
{
|
|
SCHED_HUNTER_RANGE_ATTACK1 = BaseClass::NEXT_SCHEDULE,
|
|
SCHED_HUNTER_RANGE_ATTACK2,
|
|
SCHED_HUNTER_MELEE_ATTACK1,
|
|
SCHED_HUNTER_DODGE,
|
|
SCHED_HUNTER_CHASE_ENEMY,
|
|
SCHED_HUNTER_CHASE_ENEMY_MELEE,
|
|
SCHED_HUNTER_COMBAT_FACE,
|
|
SCHED_HUNTER_FLANK_ENEMY,
|
|
SCHED_HUNTER_CHANGE_POSITION,
|
|
SCHED_HUNTER_CHANGE_POSITION_FINISH,
|
|
SCHED_HUNTER_SIDESTEP,
|
|
SCHED_HUNTER_PATROL,
|
|
SCHED_HUNTER_FLINCH_STICKYBOMB,
|
|
SCHED_HUNTER_STAGGER,
|
|
SCHED_HUNTER_PATROL_RUN,
|
|
SCHED_HUNTER_TAKE_COVER_FROM_ENEMY,
|
|
SCHED_HUNTER_HIDE_UNDER_COVER,
|
|
SCHED_HUNTER_FAIL_IMMEDIATE, // instant fail without waiting
|
|
SCHED_HUNTER_CHARGE_ENEMY,
|
|
SCHED_HUNTER_FAIL_CHARGE_ENEMY,
|
|
SCHED_HUNTER_FOUND_ENEMY,
|
|
SCHED_HUNTER_FOUND_ENEMY_ACK,
|
|
SCHED_HUNTER_RANGE_ATTACK2_VS_STRIDERBUSTER,
|
|
SCHED_HUNTER_RANGE_ATTACK2_VS_STRIDERBUSTER_LATENT,
|
|
SCHED_HUNTER_GOTO_HINT,
|
|
SCHED_HUNTER_CLEAR_HINTNODE,
|
|
SCHED_HUNTER_FAIL_DODGE,
|
|
SCHED_HUNTER_SIEGE_STAND,
|
|
SCHED_HUNTER_CHANGE_POSITION_SIEGE,
|
|
|
|
TASK_HUNTER_AIM = BaseClass::NEXT_TASK,
|
|
TASK_HUNTER_FIND_DODGE_POSITION,
|
|
TASK_HUNTER_DODGE,
|
|
TASK_HUNTER_PRE_RANGE_ATTACK2,
|
|
TASK_HUNTER_SHOOT_COMMIT,
|
|
TASK_HUNTER_BEGIN_FLANK,
|
|
TASK_HUNTER_ANNOUNCE_FLANK,
|
|
TASK_HUNTER_STAGGER,
|
|
TASK_HUNTER_CORNERED_TIMER,
|
|
TASK_HUNTER_FIND_SIDESTEP_POSITION,
|
|
TASK_HUNTER_CHARGE,
|
|
TASK_HUNTER_CHARGE_DELAY,
|
|
TASK_HUNTER_FINISH_RANGE_ATTACK,
|
|
TASK_HUNTER_WAIT_FOR_MOVEMENT_FACING_ENEMY,
|
|
|
|
COND_HUNTER_SHOULD_PATROL = BaseClass::NEXT_CONDITION,
|
|
COND_HUNTER_FORCED_FLANK_ENEMY,
|
|
COND_HUNTER_FORCED_DODGE,
|
|
COND_HUNTER_CAN_CHARGE_ENEMY,
|
|
COND_HUNTER_HIT_BY_STICKYBOMB,
|
|
COND_HUNTER_STAGGERED,
|
|
COND_HUNTER_IS_INDOORS,
|
|
COND_HUNTER_SEE_STRIDERBUSTER,
|
|
COND_HUNTER_INCOMING_VEHICLE,
|
|
COND_HUNTER_NEW_HINTGROUP,
|
|
COND_HUNTER_CANT_PLANT,
|
|
COND_HUNTER_SQUADMATE_FOUND_ENEMY,
|
|
};
|
|
|
|
enum HunterEyeStates_t
|
|
{
|
|
HUNTER_EYE_STATE_TOP_LOCKED = 0,
|
|
HUNTER_EYE_STATE_BOTTOM_LOCKED,
|
|
HUNTER_EYE_STATE_BOTH_LOCKED,
|
|
HUNTER_EYE_STATE_BOTH_UNLOCKED,
|
|
};
|
|
|
|
string_t m_iszFollowTarget; // Name of the strider we should follow.
|
|
CSimpleStopwatch m_BeginFollowDelay;
|
|
|
|
int m_nKillingDamageType;
|
|
HunterEyeStates_t m_eEyeState;
|
|
|
|
float m_aimYaw;
|
|
float m_aimPitch;
|
|
|
|
float m_flShootAllowInterruptTime;
|
|
float m_flNextChargeTime; // Prevents us from doing our threat display too often.
|
|
float m_flNextDamageTime;
|
|
float m_flNextSideStepTime;
|
|
|
|
CSimpleSimTimer m_HeavyDamageDelay;
|
|
CSimpleSimTimer m_FlinchTimer;
|
|
CSimpleSimTimer m_EyeSwitchTimer; // Controls how often we switch which eye is focusing on our enemy.
|
|
|
|
bool m_bTopMuzzle; // Used to alternate between top muzzle FX and bottom muzzle FX.
|
|
bool m_bEnableSquadShootDelay;
|
|
bool m_bIsBleeding;
|
|
|
|
Activity m_eDodgeActivity;
|
|
CSimpleSimTimer m_RundownDelay;
|
|
CSimpleSimTimer m_IgnoreVehicleTimer;
|
|
|
|
bool m_bDisableShooting; // Range attack disabled via an input. Used for scripting melee attacks.
|
|
|
|
bool m_bFlashlightInEyes; // The player is shining the flashlight on our eyes.
|
|
float m_flPupilDilateTime; // When to dilate our pupils if the flashlight is no longer on our eyes.
|
|
|
|
Vector m_vecEnemyLastSeen;
|
|
Vector m_vecLastCanPlantHerePos;
|
|
Vector m_vecStaggerDir;
|
|
|
|
bool m_bPlanted;
|
|
bool m_bLastCanPlantHere;
|
|
bool m_bMissLeft;
|
|
bool m_bEnableUnplantedShooting;
|
|
|
|
static float gm_flMinigunDistZ;
|
|
static Vector gm_vecLocalRelativePositionMinigun;
|
|
|
|
static int gm_nTopGunAttachment;
|
|
static int gm_nBottomGunAttachment;
|
|
static int gm_nAimYawPoseParam;
|
|
static int gm_nAimPitchPoseParam;
|
|
static int gm_nBodyYawPoseParam;
|
|
static int gm_nBodyPitchPoseParam;
|
|
static int gm_nStaggerYawPoseParam;
|
|
static int gm_nHeadCenterAttachment;
|
|
static int gm_nHeadBottomAttachment;
|
|
static float gm_flHeadRadius;
|
|
|
|
static int gm_nUnplantedNode;
|
|
static int gm_nPlantedNode;
|
|
|
|
CAI_HunterEscortBehavior m_EscortBehavior;
|
|
|
|
int m_nFlechettesQueued;
|
|
int m_nClampedShots; // The number of consecutive shots fired at an out-of-max yaw target.
|
|
|
|
float m_flNextRangeAttack2Time; // Time when we can fire another volley of flechettes.
|
|
float m_flNextFlechetteTime; // Time to fire the next flechette in this volley.
|
|
|
|
float m_flNextMeleeTime;
|
|
float m_flTeslaStopTime;
|
|
|
|
string_t m_iszCurrentExpression;
|
|
|
|
// buster fu
|
|
CUtlVector< EHANDLE > m_hAttachedBusters; // List of busters attached to us
|
|
float m_fCorneredTimer; ///< hunter was cornered when fleeing player; it won't flee again until this time
|
|
|
|
CSimpleSimTimer m_CheckHintGroupTimer;
|
|
|
|
DEFINE_CUSTOM_AI;
|
|
|
|
DECLARE_DATADESC();
|
|
|
|
friend class CAI_HunterEscortBehavior;
|
|
friend class CHunterMaker;
|
|
|
|
bool m_bInLargeOutdoorMap;
|
|
float m_flTimeSawEnemyAgain;
|
|
|
|
// Sounds
|
|
//CSoundPatch *m_pGunFiringSound;
|
|
|
|
CUtlVector<EHANDLE> m_pSiegeTargets;
|
|
string_t m_iszSiegeTargetName;
|
|
float m_flTimeNextSiegeTargetAttack;
|
|
EHANDLE m_hCurrentSiegeTarget;
|
|
|
|
EHANDLE m_hHitByVehicle;
|
|
};
|
|
|
|
|
|
LINK_ENTITY_TO_CLASS( npc_hunter, CNPC_Hunter );
|
|
|
|
|
|
BEGIN_DATADESC( CNPC_Hunter )
|
|
|
|
DEFINE_KEYFIELD( m_iszFollowTarget, FIELD_STRING, "FollowTarget" ),
|
|
|
|
DEFINE_FIELD( m_aimYaw, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_aimPitch, FIELD_FLOAT ),
|
|
|
|
DEFINE_FIELD( m_flShootAllowInterruptTime, FIELD_TIME ),
|
|
DEFINE_FIELD( m_flNextChargeTime, FIELD_TIME ),
|
|
//DEFINE_FIELD( m_flNextDamageTime, FIELD_TIME ),
|
|
DEFINE_FIELD( m_flNextSideStepTime, FIELD_TIME ),
|
|
|
|
DEFINE_EMBEDDED( m_HeavyDamageDelay ),
|
|
DEFINE_EMBEDDED( m_FlinchTimer ),
|
|
|
|
DEFINE_FIELD( m_eEyeState, FIELD_INTEGER ),
|
|
|
|
DEFINE_FIELD( m_bTopMuzzle, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_bEnableSquadShootDelay, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_bIsBleeding, FIELD_BOOLEAN ),
|
|
|
|
DEFINE_FIELD( m_bDisableShooting, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_bFlashlightInEyes, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_flPupilDilateTime, FIELD_TIME ),
|
|
|
|
DEFINE_FIELD( m_vecEnemyLastSeen, FIELD_POSITION_VECTOR ),
|
|
DEFINE_FIELD( m_vecLastCanPlantHerePos, FIELD_POSITION_VECTOR ),
|
|
DEFINE_FIELD( m_vecStaggerDir, FIELD_VECTOR ),
|
|
|
|
DEFINE_FIELD( m_bPlanted, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_bLastCanPlantHere, FIELD_BOOLEAN ),
|
|
//DEFINE_FIELD( m_bMissLeft, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_bEnableUnplantedShooting, FIELD_BOOLEAN ),
|
|
|
|
DEFINE_FIELD( m_nKillingDamageType, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_eDodgeActivity, FIELD_INTEGER ),
|
|
DEFINE_EMBEDDED( m_RundownDelay ),
|
|
DEFINE_EMBEDDED( m_IgnoreVehicleTimer ),
|
|
|
|
DEFINE_FIELD( m_flNextMeleeTime, FIELD_TIME ),
|
|
DEFINE_FIELD( m_flTeslaStopTime, FIELD_TIME ),
|
|
|
|
// (auto saved by AI)
|
|
//DEFINE_FIELD( m_EscortBehavior, FIELD_EMBEDDED ),
|
|
|
|
DEFINE_FIELD( m_iszCurrentExpression, FIELD_STRING ),
|
|
|
|
DEFINE_FIELD( m_fCorneredTimer, FIELD_TIME),
|
|
|
|
DEFINE_EMBEDDED( m_CheckHintGroupTimer ),
|
|
|
|
// (Recomputed in Precache())
|
|
//DEFINE_FIELD( m_bInLargeOutdoorMap, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_flTimeSawEnemyAgain, FIELD_TIME ),
|
|
|
|
//DEFINE_SOUNDPATCH( m_pGunFiringSound ),
|
|
|
|
//DEFINE_UTLVECTOR( m_pSiegeTarget, FIELD_EHANDLE ),
|
|
DEFINE_FIELD( m_iszSiegeTargetName, FIELD_STRING ),
|
|
DEFINE_FIELD( m_flTimeNextSiegeTargetAttack, FIELD_TIME ),
|
|
DEFINE_FIELD( m_hCurrentSiegeTarget, FIELD_EHANDLE ),
|
|
DEFINE_FIELD( m_hHitByVehicle, FIELD_EHANDLE ),
|
|
|
|
DEFINE_EMBEDDED( m_BeginFollowDelay ),
|
|
DEFINE_EMBEDDED( m_EyeSwitchTimer ),
|
|
|
|
DEFINE_FIELD( m_nFlechettesQueued, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_nClampedShots, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_flNextRangeAttack2Time, FIELD_TIME ),
|
|
DEFINE_FIELD( m_flNextFlechetteTime, FIELD_TIME ),
|
|
DEFINE_UTLVECTOR( m_hAttachedBusters, FIELD_EHANDLE ),
|
|
DEFINE_UTLVECTOR( m_pSiegeTargets, FIELD_EHANDLE ),
|
|
|
|
// inputs
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "Dodge", InputDodge ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "FlankEnemy", InputFlankEnemy ),
|
|
DEFINE_INPUTFUNC( FIELD_STRING, "DisableShooting", InputDisableShooting ),
|
|
DEFINE_INPUTFUNC( FIELD_STRING, "EnableShooting", InputEnableShooting ),
|
|
DEFINE_INPUTFUNC( FIELD_STRING, "FollowStrider", InputFollowStrider ),
|
|
DEFINE_INPUTFUNC( FIELD_STRING, "UseSiegeTargets", InputUseSiegeTargets ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "EnableSquadShootDelay", InputEnableSquadShootDelay ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "DisableSquadShootDelay", InputDisableSquadShootDelay ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "EnableUnplantedShooting", InputEnableUnplantedShooting ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "DisableUnplantedShooting", InputDisableUnplantedShooting ),
|
|
|
|
// Function Pointers
|
|
DEFINE_THINKFUNC( TeslaThink ),
|
|
DEFINE_THINKFUNC( BleedThink ),
|
|
DEFINE_THINKFUNC( JostleVehicleThink ),
|
|
|
|
END_DATADESC()
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int CNPC_Hunter::gm_nUnplantedNode = 0;
|
|
int CNPC_Hunter::gm_nPlantedNode = 0;
|
|
|
|
int CNPC_Hunter::gm_nAimYawPoseParam = -1;
|
|
int CNPC_Hunter::gm_nAimPitchPoseParam = -1;
|
|
int CNPC_Hunter::gm_nBodyYawPoseParam = -1;
|
|
int CNPC_Hunter::gm_nBodyPitchPoseParam = -1;
|
|
int CNPC_Hunter::gm_nStaggerYawPoseParam = -1;
|
|
int CNPC_Hunter::gm_nHeadCenterAttachment = -1;
|
|
int CNPC_Hunter::gm_nHeadBottomAttachment = -1;
|
|
float CNPC_Hunter::gm_flHeadRadius = 0;
|
|
|
|
int CNPC_Hunter::gm_nTopGunAttachment = -1;
|
|
int CNPC_Hunter::gm_nBottomGunAttachment = -1;
|
|
|
|
float CNPC_Hunter::gm_flMinigunDistZ;
|
|
Vector CNPC_Hunter::gm_vecLocalRelativePositionMinigun;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
static CUtlVector<CNPC_Hunter *> g_Hunters;
|
|
float g_TimeLastDistributeFreeHunters = -1;
|
|
const float FREE_HUNTER_DISTRIBUTE_INTERVAL = 2;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
CNPC_Hunter::CNPC_Hunter()
|
|
{
|
|
g_Hunters.AddToTail( this );
|
|
g_TimeLastDistributeFreeHunters = -1;
|
|
m_flTimeSawEnemyAgain = HUNTER_SEE_ENEMY_TIME_INVALID;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
CNPC_Hunter::~CNPC_Hunter()
|
|
{
|
|
g_Hunters.FindAndRemove( this );
|
|
g_TimeLastDistributeFreeHunters = -1;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::Precache()
|
|
{
|
|
PrecacheModel( "models/hunter.mdl" );
|
|
PropBreakablePrecacheAll( MAKE_STRING("models/hunter.mdl") );
|
|
|
|
PrecacheScriptSound( "NPC_Hunter.Idle" );
|
|
PrecacheScriptSound( "NPC_Hunter.Scan" );
|
|
PrecacheScriptSound( "NPC_Hunter.Alert" );
|
|
PrecacheScriptSound( "NPC_Hunter.Pain" );
|
|
PrecacheScriptSound( "NPC_Hunter.PreCharge" );
|
|
PrecacheScriptSound( "NPC_Hunter.Angry" );
|
|
PrecacheScriptSound( "NPC_Hunter.Death" );
|
|
PrecacheScriptSound( "NPC_Hunter.FireMinigun" );
|
|
PrecacheScriptSound( "NPC_Hunter.Footstep" );
|
|
PrecacheScriptSound( "NPC_Hunter.BackFootstep" );
|
|
PrecacheScriptSound( "NPC_Hunter.FlechetteVolleyWarn" );
|
|
PrecacheScriptSound( "NPC_Hunter.FlechetteShoot" );
|
|
PrecacheScriptSound( "NPC_Hunter.FlechetteShootLoop" );
|
|
PrecacheScriptSound( "NPC_Hunter.FlankAnnounce" );
|
|
PrecacheScriptSound( "NPC_Hunter.MeleeAnnounce" );
|
|
PrecacheScriptSound( "NPC_Hunter.MeleeHit" );
|
|
PrecacheScriptSound( "NPC_Hunter.TackleAnnounce" );
|
|
PrecacheScriptSound( "NPC_Hunter.TackleHit" );
|
|
PrecacheScriptSound( "NPC_Hunter.ChargeHitEnemy" );
|
|
PrecacheScriptSound( "NPC_Hunter.ChargeHitWorld" );
|
|
PrecacheScriptSound( "NPC_Hunter.FoundEnemy" );
|
|
PrecacheScriptSound( "NPC_Hunter.FoundEnemyAck" );
|
|
PrecacheScriptSound( "NPC_Hunter.DefendStrider" );
|
|
PrecacheScriptSound( "NPC_Hunter.HitByVehicle" );
|
|
|
|
PrecacheParticleSystem( "hunter_muzzle_flash" );
|
|
PrecacheParticleSystem( "blood_impact_synth_01" );
|
|
PrecacheParticleSystem( "blood_impact_synth_01_arc_parent" );
|
|
PrecacheParticleSystem( "blood_spurt_synth_01" );
|
|
PrecacheParticleSystem( "blood_drip_synth_01" );
|
|
|
|
PrecacheInstancedScene( "scenes/npc/hunter/hunter_scan.vcd" );
|
|
PrecacheInstancedScene( "scenes/npc/hunter/hunter_eyeclose.vcd" );
|
|
PrecacheInstancedScene( "scenes/npc/hunter/hunter_roar.vcd" );
|
|
PrecacheInstancedScene( "scenes/npc/hunter/hunter_pain.vcd" );
|
|
PrecacheInstancedScene( "scenes/npc/hunter/hunter_eyedarts_top.vcd" );
|
|
PrecacheInstancedScene( "scenes/npc/hunter/hunter_eyedarts_bottom.vcd" );
|
|
|
|
PrecacheMaterial( "effects/water_highlight" );
|
|
|
|
UTIL_PrecacheOther( "hunter_flechette" );
|
|
UTIL_PrecacheOther( "sparktrail" );
|
|
|
|
m_bInLargeOutdoorMap = false;
|
|
if( !Q_strnicmp( STRING(gpGlobals->mapname), "ep2_outland_12", 14) )
|
|
{
|
|
m_bInLargeOutdoorMap = true;
|
|
}
|
|
|
|
BaseClass::Precache();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::Spawn()
|
|
{
|
|
Precache();
|
|
|
|
SetModel( "models/hunter.mdl" );
|
|
BaseClass::Spawn();
|
|
|
|
//m_debugOverlays |= OVERLAY_NPC_ROUTE_BIT | OVERLAY_BBOX_BIT | OVERLAY_PIVOT_BIT;
|
|
|
|
SetHullType( HULL_MEDIUM_TALL );
|
|
SetHullSizeNormal();
|
|
SetDefaultEyeOffset();
|
|
|
|
SetNavType( NAV_GROUND );
|
|
m_flGroundSpeed = 500;
|
|
m_NPCState = NPC_STATE_NONE;
|
|
|
|
SetBloodColor( DONT_BLEED );
|
|
|
|
m_iHealth = m_iMaxHealth = sk_hunter_health.GetInt();
|
|
|
|
m_flFieldOfView = HUNTER_FOV_DOT;
|
|
|
|
SetSolid( SOLID_BBOX );
|
|
AddSolidFlags( FSOLID_NOT_STANDABLE );
|
|
SetMoveType( MOVETYPE_STEP );
|
|
|
|
SetupGlobalModelData();
|
|
|
|
CapabilitiesAdd( bits_CAP_MOVE_GROUND | bits_CAP_SQUAD | bits_CAP_ANIMATEDFACE );
|
|
CapabilitiesAdd( bits_CAP_INNATE_RANGE_ATTACK1 | bits_CAP_INNATE_RANGE_ATTACK2 | bits_CAP_INNATE_MELEE_ATTACK1 );
|
|
CapabilitiesAdd( bits_CAP_SKIP_NAV_GROUND_CHECK );
|
|
|
|
if ( !hunter_allow_dissolve.GetBool() )
|
|
{
|
|
AddEFlags( EFL_NO_DISSOLVE );
|
|
}
|
|
|
|
if( hunter_allow_nav_jump.GetBool() )
|
|
{
|
|
CapabilitiesAdd( bits_CAP_MOVE_JUMP );
|
|
}
|
|
|
|
NPCInit();
|
|
|
|
m_bEnableSquadShootDelay = true;
|
|
|
|
m_flDistTooFar = hunter_flechette_max_range.GetFloat();
|
|
|
|
// Discard time must be greater than free knowledge duration. Make it double.
|
|
float freeKnowledge = hunter_free_knowledge.GetFloat();
|
|
if ( freeKnowledge < GetEnemies()->GetEnemyDiscardTime() )
|
|
{
|
|
GetEnemies()->SetEnemyDiscardTime( MAX( freeKnowledge + 0.1, AI_DEF_ENEMY_DISCARD_TIME ) );
|
|
}
|
|
GetEnemies()->SetFreeKnowledgeDuration( freeKnowledge );
|
|
|
|
// Find out what strider we should follow, if any.
|
|
if ( m_iszFollowTarget != NULL_STRING )
|
|
{
|
|
m_BeginFollowDelay.Set( .1 ); // Allow time for strider to spawn
|
|
}
|
|
|
|
//if ( !m_pGunFiringSound )
|
|
//{
|
|
// CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
|
// CPASAttenuationFilter filter( this );
|
|
//
|
|
// m_pGunFiringSound = controller.SoundCreate( filter, entindex(), "NPC_Hunter.FlechetteShootLoop" );
|
|
// controller.Play( m_pGunFiringSound, 0.0, 100 );
|
|
//}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::UpdateEfficiency( bool bInPVS )
|
|
{
|
|
SetEfficiency( ( GetSleepState() != AISS_AWAKE ) ? AIE_DORMANT : AIE_NORMAL );
|
|
SetMoveEfficiency( AIME_NORMAL );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::CreateBehaviors()
|
|
{
|
|
AddBehavior( &m_EscortBehavior );
|
|
|
|
return BaseClass::CreateBehaviors();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::SetupGlobalModelData()
|
|
{
|
|
if ( gm_nBodyYawPoseParam != -1 )
|
|
return;
|
|
|
|
gm_nAimYawPoseParam = LookupPoseParameter( "aim_yaw" );
|
|
gm_nAimPitchPoseParam = LookupPoseParameter( "aim_pitch" );
|
|
|
|
gm_nBodyYawPoseParam = LookupPoseParameter( "body_yaw" );
|
|
gm_nBodyPitchPoseParam = LookupPoseParameter( "body_pitch" );
|
|
|
|
gm_nTopGunAttachment = LookupAttachment( "top_eye" );
|
|
gm_nBottomGunAttachment = LookupAttachment( "bottom_eye" );
|
|
gm_nStaggerYawPoseParam = LookupAttachment( "stagger_yaw" );
|
|
|
|
gm_nHeadCenterAttachment = LookupAttachment( "head_center" );
|
|
gm_nHeadBottomAttachment = LookupAttachment( "head_radius_measure" );
|
|
|
|
// Measure the radius of the head.
|
|
Vector vecHeadCenter;
|
|
Vector vecHeadBottom;
|
|
GetAttachment( gm_nHeadCenterAttachment, vecHeadCenter );
|
|
GetAttachment( gm_nHeadBottomAttachment, vecHeadBottom );
|
|
gm_flHeadRadius = ( vecHeadCenter - vecHeadBottom ).Length();
|
|
|
|
int nSequence = SelectWeightedSequence( ACT_HUNTER_RANGE_ATTACK2_UNPLANTED );
|
|
gm_nUnplantedNode = GetEntryNode( nSequence );
|
|
|
|
nSequence = SelectWeightedSequence( ACT_RANGE_ATTACK2 );
|
|
gm_nPlantedNode = GetEntryNode( nSequence );
|
|
|
|
CollisionProp()->SetSurroundingBoundsType( USE_HITBOXES );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Shuts down looping sounds when we are killed in combat or deleted.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::StopLoopingSounds()
|
|
{
|
|
BaseClass::StopLoopingSounds();
|
|
|
|
//if ( m_pGunFiringSound )
|
|
//{
|
|
// CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
|
// controller.SoundDestroy( m_pGunFiringSound );
|
|
// m_pGunFiringSound = NULL;
|
|
//}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::OnRestore()
|
|
{
|
|
BaseClass::OnRestore();
|
|
SetupGlobalModelData();
|
|
CreateVPhysics();
|
|
|
|
if ( IsBleeding() )
|
|
{
|
|
StartBleeding();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::IdleSound()
|
|
{
|
|
if ( HasCondition( COND_LOST_ENEMY ) )
|
|
{
|
|
EmitSound( "NPC_Hunter.Scan" );
|
|
}
|
|
else
|
|
{
|
|
EmitSound( "NPC_Hunter.Idle" );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::ShouldPlayIdleSound()
|
|
{
|
|
if ( random->RandomInt(0, 99) == 0 && !HasSpawnFlags( SF_NPC_GAG ) )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Stay facing our enemy when close enough.
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::OverrideMoveFacing( const AILocalMoveGoal_t &move, float flInterval )
|
|
{
|
|
if ( GetActivity() == ACT_TRANSITION )
|
|
{
|
|
// No turning while in transitions.
|
|
return true;
|
|
}
|
|
|
|
bool bSideStepping = IsCurSchedule( SCHED_HUNTER_SIDESTEP, false );
|
|
|
|
// FIXME: this will break scripted sequences that walk when they have an enemy
|
|
if ( GetEnemy() &&
|
|
( bSideStepping ||
|
|
( ( ( GetNavigator()->GetMovementActivity() == ACT_RUN ) || ( GetNavigator()->GetMovementActivity() == ACT_WALK ) ) &&
|
|
!IsCurSchedule( SCHED_HUNTER_TAKE_COVER_FROM_ENEMY, false ) ) ) )
|
|
{
|
|
Vector vecEnemyLKP = GetEnemyLKP();
|
|
|
|
// Face my enemy if we're close enough
|
|
if ( bSideStepping || UTIL_DistApprox( vecEnemyLKP, GetAbsOrigin() ) < HUNTER_FACE_ENEMY_DIST )
|
|
{
|
|
AddFacingTarget( GetEnemy(), vecEnemyLKP, 1.0, 0.2 );
|
|
}
|
|
}
|
|
|
|
return BaseClass::OverrideMoveFacing( move, flInterval );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::PostNPCInit()
|
|
{
|
|
BaseClass::PostNPCInit();
|
|
|
|
IPhysicsObject *pPhysObject = VPhysicsGetObject();
|
|
Assert( pPhysObject );
|
|
if ( pPhysObject )
|
|
{
|
|
pPhysObject->SetMass( 600.0 );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::Activate()
|
|
{
|
|
BaseClass::Activate();
|
|
|
|
s_iszStriderBusterClassname = AllocPooledString( "weapon_striderbuster" );
|
|
s_iszStriderClassname = AllocPooledString( "npc_strider" );
|
|
s_iszMagnadeClassname = AllocPooledString( "npc_grenade_magna" );
|
|
s_iszPhysPropClassname = AllocPooledString( "prop_physics" );
|
|
s_iszHuntersToRunOver = AllocPooledString( "hunters_to_run_over" );
|
|
|
|
// If no one has initialized the hunters to run over counter, just zero it out.
|
|
if ( !GlobalEntity_IsInTable( s_iszHuntersToRunOver ) )
|
|
{
|
|
GlobalEntity_Add( s_iszHuntersToRunOver, gpGlobals->mapname, GLOBAL_ON );
|
|
GlobalEntity_SetCounter( s_iszHuntersToRunOver, 0 );
|
|
}
|
|
|
|
CMissile::AddCustomDetonator( this, ( GetHullMaxs().AsVector2D() - GetHullMins().AsVector2D() ).Length() * 0.5, GetHullHeight() );
|
|
|
|
SetupGlobalModelData();
|
|
|
|
if ( gm_flMinigunDistZ == 0 )
|
|
{
|
|
// Have to create a virgin hunter to ensure proper pose
|
|
CNPC_Hunter *pHunter = (CNPC_Hunter *)CreateEntityByName( "npc_hunter" );
|
|
Assert(pHunter);
|
|
pHunter->Spawn();
|
|
|
|
pHunter->SetActivity( ACT_WALK );
|
|
pHunter->InvalidateBoneCache();
|
|
|
|
// Currently just using the gun for the vertical component!
|
|
Vector defEyePos;
|
|
pHunter->GetAttachment( "minigunbase", defEyePos );
|
|
gm_flMinigunDistZ = defEyePos.z - pHunter->GetAbsOrigin().z;
|
|
|
|
Vector position;
|
|
pHunter->GetAttachment( gm_nTopGunAttachment, position );
|
|
VectorITransform( position, pHunter->EntityToWorldTransform(), gm_vecLocalRelativePositionMinigun );
|
|
UTIL_Remove( pHunter );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::UpdateOnRemove()
|
|
{
|
|
CMissile::RemoveCustomDetonator( this );
|
|
BaseClass::UpdateOnRemove();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
Class_T CNPC_Hunter::Classify()
|
|
{
|
|
return CLASS_COMBINE_HUNTER;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compensate for the hunter's long legs by moving the bodytarget up to his head.
|
|
//-----------------------------------------------------------------------------
|
|
Vector CNPC_Hunter::BodyTarget( const Vector &posSrc, bool bNoisy /*= true*/ )
|
|
{
|
|
Vector vecResult;
|
|
QAngle vecAngle;
|
|
GetAttachment( gm_nHeadCenterAttachment, vecResult, vecAngle );
|
|
|
|
if ( bNoisy )
|
|
{
|
|
float rand1 = random->RandomFloat( 0, gm_flHeadRadius ) + random->RandomFloat( 0, gm_flHeadRadius );
|
|
return vecResult + RandomVector( -rand1, rand1 );
|
|
}
|
|
|
|
return vecResult;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Hunter::DrawDebugTextOverlays()
|
|
{
|
|
int text_offset = BaseClass::DrawDebugTextOverlays();
|
|
|
|
if (m_debugOverlays & OVERLAY_TEXT_BIT)
|
|
{
|
|
EntityText( text_offset, CFmtStr("%s", m_bPlanted ? "Planted" : "Unplanted" ), 0 );
|
|
text_offset++;
|
|
|
|
EntityText( text_offset, CFmtStr("Eye state: %d", m_eEyeState ), 0 );
|
|
text_offset++;
|
|
|
|
if( IsUsingSiegeTargets() )
|
|
{
|
|
EntityText( text_offset, CFmtStr("Next Siege Attempt:%f", m_flTimeNextSiegeTargetAttack - gpGlobals->curtime ), 0 );
|
|
text_offset++;
|
|
}
|
|
}
|
|
|
|
return text_offset;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::LockBothEyes( float flDuration )
|
|
{
|
|
m_eEyeState = HUNTER_EYE_STATE_BOTH_LOCKED;
|
|
m_EyeSwitchTimer.Set( flDuration );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::UnlockBothEyes( float flDuration )
|
|
{
|
|
m_eEyeState = HUNTER_EYE_STATE_BOTH_UNLOCKED;
|
|
m_EyeSwitchTimer.Set( flDuration );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::OnChangeActivity( Activity eNewActivity )
|
|
{
|
|
m_EyeSwitchTimer.Force();
|
|
|
|
BaseClass::OnChangeActivity( eNewActivity );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::UpdateEyes()
|
|
{
|
|
// If the eyes are controlled by a script, do nothing.
|
|
if ( GetState() == NPC_STATE_SCRIPT )
|
|
return;
|
|
|
|
if ( m_EyeSwitchTimer.Expired() )
|
|
{
|
|
RemoveActorFromScriptedScenes( this, false );
|
|
|
|
if ( GetActivity() == ACT_IDLE )
|
|
{
|
|
// Idles have eye motion baked in.
|
|
m_eEyeState = HUNTER_EYE_STATE_BOTH_LOCKED;
|
|
}
|
|
else if ( GetEnemy() == NULL )
|
|
{
|
|
m_eEyeState = HUNTER_EYE_STATE_BOTH_UNLOCKED;
|
|
}
|
|
else if ( m_eEyeState == HUNTER_EYE_STATE_BOTH_LOCKED )
|
|
{
|
|
if ( random->RandomInt( 0, 1 ) == 0 )
|
|
{
|
|
m_eEyeState = HUNTER_EYE_STATE_TOP_LOCKED;
|
|
}
|
|
else
|
|
{
|
|
m_eEyeState = HUNTER_EYE_STATE_BOTTOM_LOCKED;
|
|
}
|
|
}
|
|
else if ( m_eEyeState == HUNTER_EYE_STATE_TOP_LOCKED )
|
|
{
|
|
m_eEyeState = HUNTER_EYE_STATE_BOTTOM_LOCKED;
|
|
}
|
|
else if ( m_eEyeState == HUNTER_EYE_STATE_BOTTOM_LOCKED )
|
|
{
|
|
m_eEyeState = HUNTER_EYE_STATE_TOP_LOCKED;
|
|
}
|
|
|
|
if ( ( m_eEyeState == HUNTER_EYE_STATE_BOTTOM_LOCKED ) || ( m_eEyeState == HUNTER_EYE_STATE_BOTH_UNLOCKED ) )
|
|
{
|
|
SetExpression( "scenes/npc/hunter/hunter_eyedarts_top.vcd" );
|
|
}
|
|
|
|
if ( ( m_eEyeState == HUNTER_EYE_STATE_TOP_LOCKED ) || ( m_eEyeState == HUNTER_EYE_STATE_BOTH_UNLOCKED ) )
|
|
{
|
|
SetExpression( "scenes/npc/hunter/hunter_eyedarts_bottom.vcd" );
|
|
}
|
|
|
|
m_EyeSwitchTimer.Set( random->RandomFloat( 1.0f, 3.0f ) );
|
|
}
|
|
|
|
/*Vector vecEyePos;
|
|
Vector vecEyeDir;
|
|
|
|
GetAttachment( gm_nTopGunAttachment, vecEyePos, &vecEyeDir );
|
|
NDebugOverlay::Line( vecEyePos, vecEyePos + vecEyeDir * 36, 255, 0, 0, 0, 0.1 );
|
|
|
|
GetAttachment( gm_nBottomGunAttachment, vecEyePos, &vecEyeDir );
|
|
NDebugOverlay::Line( vecEyePos, vecEyePos + vecEyeDir * 36, 255, 0, 0, 0, 0.1 );*/
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::NPCThink()
|
|
{
|
|
BaseClass::NPCThink();
|
|
|
|
// Update our planted/unplanted state.
|
|
m_bPlanted = ( GetEntryNode( GetSequence() ) == gm_nPlantedNode );
|
|
|
|
UpdateAim();
|
|
UpdateEyes();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::PrescheduleThink()
|
|
{
|
|
BaseClass::PrescheduleThink();
|
|
|
|
if ( m_BeginFollowDelay.Expired() )
|
|
{
|
|
FollowStrider( STRING( m_iszFollowTarget ) );
|
|
m_BeginFollowDelay.Stop();
|
|
}
|
|
|
|
m_EscortBehavior.CheckBreakEscort();
|
|
|
|
// If we're being blinded by the flashlight, see if we should stop
|
|
if ( m_bFlashlightInEyes )
|
|
{
|
|
if ( m_flPupilDilateTime < gpGlobals->curtime )
|
|
{
|
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( 1 );
|
|
if ( ( pPlayer && !pPlayer->IsIlluminatedByFlashlight( this, NULL ) ) || !PlayerFlashlightOnMyEyes( pPlayer ) )
|
|
{
|
|
//Msg( "NOT SHINING FLASHLIGHT ON ME\n" );
|
|
|
|
// Remove the actor from the flashlight scene
|
|
RemoveActorFromScriptedScenes( this, true, false, "scenes/npc/hunter/hunter_eyeclose.vcd" );
|
|
m_bFlashlightInEyes = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::GatherChargeConditions()
|
|
{
|
|
ClearCondition( COND_HUNTER_CAN_CHARGE_ENEMY );
|
|
|
|
if ( !hunter_charge.GetBool() )
|
|
return;
|
|
|
|
if ( !GetEnemy() )
|
|
return;
|
|
|
|
if ( GetHintGroup() != NULL_STRING )
|
|
return;
|
|
|
|
if ( !HasCondition( COND_SEE_ENEMY ) )
|
|
return;
|
|
|
|
if ( !hunter_charge_test.GetBool() && gpGlobals->curtime < m_flNextChargeTime )
|
|
return;
|
|
|
|
// No charging Alyx or Barney
|
|
if( GetEnemy()->Classify() == CLASS_PLAYER_ALLY_VITAL )
|
|
return;
|
|
|
|
if ( m_EscortBehavior.GetEscortTarget() && GetEnemy()->MyCombatCharacterPointer() && !GetEnemy()->MyCombatCharacterPointer()->FInViewCone( this ) )
|
|
return;
|
|
|
|
if ( ShouldCharge( GetAbsOrigin(), GetEnemy()->GetAbsOrigin(), true, false ) )
|
|
{
|
|
SetCondition( COND_HUNTER_CAN_CHARGE_ENEMY );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::GatherConditions()
|
|
{
|
|
GatherIndoorOutdoorConditions();
|
|
GatherChargeConditions();
|
|
|
|
BaseClass::GatherConditions();
|
|
|
|
// Enemy LKP that doesn't get updated by the free knowledge code.
|
|
// Used for shooting at where our enemy was when we can't see them.
|
|
ClearCondition( COND_HUNTER_INCOMING_VEHICLE );
|
|
if ( m_IgnoreVehicleTimer.Expired() && GetEnemy() && HasCondition( COND_SEE_ENEMY ) )
|
|
{
|
|
CBaseEntity *pVehicle = GetEnemyVehicle();
|
|
if ( ( pVehicle ) && ( GlobalEntity_GetCounter( s_iszHuntersToRunOver ) <= 0 ) )
|
|
{
|
|
static float timeDrawnArrow;
|
|
|
|
// Extrapolate the position of the vehicle and see if it's heading toward us.
|
|
float predictTime = hunter_dodge_warning.GetFloat();
|
|
Vector2D vecFuturePos = pVehicle->GetAbsOrigin().AsVector2D() + pVehicle->GetSmoothedVelocity().AsVector2D() * predictTime;
|
|
if ( pVehicle->GetSmoothedVelocity().LengthSqr() > Square( 200 ) )
|
|
{
|
|
float t = 0;
|
|
Vector2D vDirMovement = pVehicle->GetSmoothedVelocity().AsVector2D();
|
|
if ( hunter_dodge_debug.GetBool() )
|
|
{
|
|
NDebugOverlay::Line( pVehicle->GetAbsOrigin(), pVehicle->GetAbsOrigin() + pVehicle->GetSmoothedVelocity(), 255, 255, 255, true, .1 );
|
|
}
|
|
vDirMovement.NormalizeInPlace();
|
|
Vector2D vDirToHunter = GetAbsOrigin().AsVector2D() - pVehicle->GetAbsOrigin().AsVector2D();
|
|
vDirToHunter.NormalizeInPlace();
|
|
if ( DotProduct2D( vDirMovement, vDirToHunter ) > hunter_dodge_warning_cone.GetFloat() &&
|
|
CalcDistanceSqrToLine2D( GetAbsOrigin().AsVector2D(), pVehicle->GetAbsOrigin().AsVector2D(), vecFuturePos, &t ) < Square( hunter_dodge_warning_width.GetFloat() * .5 ) &&
|
|
t > 0.0 && t < 1.0 )
|
|
{
|
|
if ( fabs( predictTime - hunter_dodge_warning.GetFloat() ) < .05 || random->RandomInt( 0, 3 ) )
|
|
{
|
|
SetCondition( COND_HUNTER_INCOMING_VEHICLE );
|
|
}
|
|
else
|
|
{
|
|
if ( hunter_dodge_debug. GetBool() )
|
|
{
|
|
Msg( "Hunter %d failing dodge (ignore)\n", entindex() );
|
|
}
|
|
}
|
|
|
|
if ( hunter_dodge_debug. GetBool() )
|
|
{
|
|
NDebugOverlay::Cross3D( EyePosition(), 100, 255, 255, 255, true, .1 );
|
|
if ( timeDrawnArrow != gpGlobals->curtime )
|
|
{
|
|
timeDrawnArrow = gpGlobals->curtime;
|
|
Vector vEndpoint( vecFuturePos.x, vecFuturePos.y, UTIL_GetLocalPlayer()->WorldSpaceCenter().z - 24 );
|
|
NDebugOverlay::HorzArrow( UTIL_GetLocalPlayer()->WorldSpaceCenter() - Vector(0, 0, 24), vEndpoint, hunter_dodge_warning_width.GetFloat(), 255, 0, 0, 64, true, .1 );
|
|
}
|
|
}
|
|
}
|
|
else if ( hunter_dodge_debug.GetBool() )
|
|
{
|
|
if ( t <= 0 )
|
|
{
|
|
NDebugOverlay::Cross3D( EyePosition(), 100, 0, 0, 255, true, .1 );
|
|
}
|
|
else
|
|
{
|
|
NDebugOverlay::Cross3D( EyePosition(), 100, 0, 255, 255, true, .1 );
|
|
}
|
|
}
|
|
}
|
|
else if ( hunter_dodge_debug.GetBool() )
|
|
{
|
|
NDebugOverlay::Cross3D( EyePosition(), 100, 0, 255, 0, true, .1 );
|
|
}
|
|
if ( hunter_dodge_debug. GetBool() )
|
|
{
|
|
if ( timeDrawnArrow != gpGlobals->curtime )
|
|
{
|
|
timeDrawnArrow = gpGlobals->curtime;
|
|
Vector vEndpoint( vecFuturePos.x, vecFuturePos.y, UTIL_GetLocalPlayer()->WorldSpaceCenter().z - 24 );
|
|
NDebugOverlay::HorzArrow( UTIL_GetLocalPlayer()->WorldSpaceCenter() - Vector(0, 0, 24), vEndpoint, hunter_dodge_warning_width.GetFloat(), 127, 127, 127, 64, true, .1 );
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
m_vecEnemyLastSeen = GetEnemy()->GetAbsOrigin();
|
|
}
|
|
|
|
if( !HasCondition(COND_ENEMY_OCCLUDED) )
|
|
{
|
|
// m_flTimeSawEnemyAgain always tells us what time I first saw this
|
|
// enemy again after some period of not seeing them. This is used to
|
|
// compute how long the enemy has been visible to me THIS TIME.
|
|
// Every time I lose sight of the enemy this time is set invalid until
|
|
// I see the enemy again and record that time.
|
|
if( m_flTimeSawEnemyAgain == HUNTER_SEE_ENEMY_TIME_INVALID )
|
|
{
|
|
m_flTimeSawEnemyAgain = gpGlobals->curtime;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_flTimeSawEnemyAgain = HUNTER_SEE_ENEMY_TIME_INVALID;
|
|
}
|
|
|
|
ManageSiegeTargets();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Search all entities in the map
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::CollectSiegeTargets()
|
|
{
|
|
CBaseEntity *pTarget = gEntList.FindEntityByName( NULL, m_iszSiegeTargetName );
|
|
|
|
while( pTarget != NULL )
|
|
{
|
|
if( pTarget->Classify() == CLASS_BULLSEYE )
|
|
{
|
|
m_pSiegeTargets.AddToTail( pTarget );
|
|
}
|
|
|
|
pTarget = gEntList.FindEntityByName( pTarget, m_iszSiegeTargetName );
|
|
};
|
|
|
|
if( m_pSiegeTargets.Count() < 1 )
|
|
{
|
|
m_iszSiegeTargetName = NULL_STRING; // And stop trying!
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// For use when Hunters are outside and the player is inside a structure
|
|
// Create a temporary bullseye in a location that makes it seem like
|
|
// I am aware of the location of a player I cannot see. (Then fire at
|
|
// at this bullseye, thus laying 'siege' to the part of the building he
|
|
// is in.) The locations are copied from suitable info_target entities.
|
|
// (these should be placed in exterior windows and doorways so that
|
|
// the Hunter fires into the building through these apertures)
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::ManageSiegeTargets()
|
|
{
|
|
if( gpGlobals->curtime < m_flTimeNextSiegeTargetAttack )
|
|
return;
|
|
|
|
if( m_pSiegeTargets.Count() == 0 )
|
|
{
|
|
// If my list of siege targets is empty, go and cache all of them now
|
|
// so that I don't have to search the world every time.
|
|
CollectSiegeTargets();
|
|
|
|
if( m_pSiegeTargets.Count() == 0 )
|
|
return;
|
|
}
|
|
|
|
m_flTimeNextSiegeTargetAttack = gpGlobals->curtime + (hunter_siege_frequency.GetFloat() * RandomFloat( 0.8f, 1.2f) );
|
|
CBasePlayer *pPlayer = AI_GetSinglePlayer();
|
|
|
|
// Start by assuming we are not going to create a siege target
|
|
bool bCreateSiegeTarget = false;
|
|
if( GetEnemy() == NULL )
|
|
{
|
|
// If I have no enemy at all, give it a try.
|
|
bCreateSiegeTarget = true;
|
|
}
|
|
|
|
if( bCreateSiegeTarget )
|
|
{
|
|
// We've decided that the situation calls for a siege target. So, we dig through all of my siege targets and
|
|
// take the closest one to the player that the player can see! (Obey they bullseye's FOV)
|
|
float flClosestDistSqr = Square( 1200.0f ); // Only use siege targets within 100 feet of player
|
|
CBaseEntity *pSiegeTargetLocation = NULL;
|
|
int iTraces = 0;
|
|
for( int i = 0 ; i < m_pSiegeTargets.Count() ; i++ )
|
|
{
|
|
CBaseEntity *pCandidate = m_pSiegeTargets[i];
|
|
if ( pCandidate == NULL )
|
|
continue;
|
|
|
|
float flDistSqr = pCandidate->GetAbsOrigin().DistToSqr(pPlayer->GetAbsOrigin());
|
|
|
|
if( flDistSqr < flClosestDistSqr )
|
|
{
|
|
// CollectSiegeTargets() guarantees my list is populated only with bullseye entities.
|
|
CNPC_Bullseye *pBullseye = dynamic_cast<CNPC_Bullseye*>(pCandidate);
|
|
if( !pBullseye->FInViewCone(this) )
|
|
continue;
|
|
|
|
if( pPlayer->FVisible(pCandidate) )
|
|
{
|
|
iTraces++;// Only counting these as a loose perf measurement
|
|
flClosestDistSqr = flDistSqr;
|
|
pSiegeTargetLocation = pCandidate;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( pSiegeTargetLocation != NULL )
|
|
{
|
|
// Ditch any leftover siege target.
|
|
KillCurrentSiegeTarget();
|
|
|
|
// Create a bullseye that will live for 20 seconds. If we can't attack it within 20 seconds, it's probably
|
|
// out of reach anyone, so have it clean itself up after that long.
|
|
CBaseEntity *pSiegeTarget = CreateCustomTarget( pSiegeTargetLocation->GetAbsOrigin(), 20.0f );
|
|
pSiegeTarget->SetName( MAKE_STRING("siegetarget") );
|
|
|
|
m_hCurrentSiegeTarget.Set( pSiegeTarget );
|
|
|
|
AddEntityRelationship( pSiegeTarget, D_HT, 1 );
|
|
GetEnemies()->UpdateMemory( GetNavigator()->GetNetwork(), pSiegeTarget, pSiegeTarget->GetAbsOrigin(), 0.0f, true );
|
|
AI_EnemyInfo_t *pMemory = GetEnemies()->Find( pSiegeTarget );
|
|
|
|
if( pMemory )
|
|
{
|
|
// Pretend we've known about this target longer than we really have so that our AI doesn't waste time running ALERT schedules.
|
|
pMemory->timeFirstSeen = gpGlobals->curtime - 5.0f;
|
|
pMemory->timeLastSeen = gpGlobals->curtime - 1.0f;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Destroy the bullseye that we're using as a temporary target
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::KillCurrentSiegeTarget()
|
|
{
|
|
if ( m_hCurrentSiegeTarget )
|
|
{
|
|
GetEnemies()->ClearMemory( m_hCurrentSiegeTarget );
|
|
|
|
UTIL_Remove( m_hCurrentSiegeTarget );
|
|
m_hCurrentSiegeTarget.Set( NULL );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Return true if this NPC can hear the specified sound
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::QueryHearSound( CSound *pSound )
|
|
{
|
|
if ( pSound->SoundContext() & SOUND_CONTEXT_EXCLUDE_COMBINE )
|
|
return false;
|
|
|
|
if ( pSound->SoundContext() & SOUND_CONTEXT_PLAYER_VEHICLE )
|
|
return false;
|
|
|
|
return BaseClass::QueryHearSound( pSound );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// This is a fairly bogus heuristic right now, but it works on 06a and 12 (sjb)
|
|
//
|
|
// Better options: Trace infinitely and check the material we hit for sky
|
|
// Put some leaf info in the BSP
|
|
// Use volumes in the levels? (yucky for designers)
|
|
//-----------------------------------------------------------------------------
|
|
// TODO: use this or nuke it!
|
|
void CNPC_Hunter::GatherIndoorOutdoorConditions()
|
|
{
|
|
// Check indoor/outdoor before calling base class, since base class calls our
|
|
// RangeAttackConditions() functions, and we want those functions to know
|
|
// whether we're indoors or out.
|
|
trace_t tr;
|
|
|
|
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + Vector( 0, 0, 40.0f * 12.0f ), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
|
|
if( tr.fraction < 1.0f )
|
|
{
|
|
SetCondition( COND_HUNTER_IS_INDOORS );
|
|
}
|
|
else
|
|
{
|
|
ClearCondition( COND_HUNTER_IS_INDOORS );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::BuildScheduleTestBits()
|
|
{
|
|
BaseClass::BuildScheduleTestBits();
|
|
|
|
if ( m_lifeState != LIFE_ALIVE )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Our range attack is uninterruptable for the first few seconds.
|
|
if ( IsCurSchedule( SCHED_HUNTER_RANGE_ATTACK2, false ) && ( gpGlobals->curtime < m_flShootAllowInterruptTime ) )
|
|
{
|
|
ClearCustomInterruptConditions();
|
|
SetCustomInterruptCondition( COND_HEAVY_DAMAGE );
|
|
}
|
|
else if ( IsCurSchedule( SCHED_HUNTER_RANGE_ATTACK2, false ) && ( GetActivity() == ACT_TRANSITION ) )
|
|
{
|
|
// Don't stop unplanting just because we can range attack again.
|
|
ClearCustomInterruptCondition( COND_CAN_RANGE_ATTACK1 );
|
|
ClearCustomInterruptCondition( COND_CAN_RANGE_ATTACK2 );
|
|
}
|
|
else if ( !IsInLargeOutdoorMap() && IsCurSchedule( SCHED_HUNTER_FLANK_ENEMY, false ) && GetEnemy() != NULL )
|
|
{
|
|
if( HasCondition(COND_CAN_RANGE_ATTACK2) && m_flTimeSawEnemyAgain != HUNTER_SEE_ENEMY_TIME_INVALID )
|
|
{
|
|
if( (gpGlobals->curtime - m_flTimeSawEnemyAgain) >= 2.0f )
|
|
{
|
|
// When we're running flank behavior, wait a moment AFTER being able to see the enemy before
|
|
// breaking my schedule to range attack. This helps assure that the hunter gets well inside
|
|
// the room before stopping to attack. Otherwise the Hunter may stop immediately in the doorway
|
|
// and stop the progress of any hunters behind it.
|
|
SetCustomInterruptCondition( COND_CAN_RANGE_ATTACK2 );
|
|
}
|
|
}
|
|
}
|
|
|
|
// If our enemy is anything but a striderbuster, drop everything if we see one.
|
|
if ( !IsStriderBuster( GetEnemy() ) )
|
|
{
|
|
SetCustomInterruptCondition( COND_HUNTER_SEE_STRIDERBUSTER );
|
|
}
|
|
|
|
// If we're not too busy, allow ourselves to ACK found enemy signals.
|
|
if ( !GetEnemy() )
|
|
{
|
|
SetCustomInterruptCondition( COND_HUNTER_SQUADMATE_FOUND_ENEMY );
|
|
}
|
|
|
|
// Interrupt everything if we need to dodge.
|
|
if ( !IsCurSchedule( SCHED_HUNTER_DODGE, false ) &&
|
|
!IsCurSchedule( SCHED_HUNTER_STAGGER, false ) &&
|
|
!IsCurSchedule( SCHED_ALERT_FACE_BESTSOUND, false ) )
|
|
{
|
|
SetCustomInterruptCondition( COND_HUNTER_INCOMING_VEHICLE );
|
|
SetCustomInterruptCondition( COND_HEAR_PHYSICS_DANGER );
|
|
SetCustomInterruptCondition( COND_HUNTER_FORCED_DODGE );
|
|
}
|
|
|
|
// Always interrupt on a flank command.
|
|
SetCustomInterruptCondition( COND_HUNTER_FORCED_FLANK_ENEMY );
|
|
|
|
// Always interrupt if staggered.
|
|
SetCustomInterruptCondition( COND_HUNTER_STAGGERED );
|
|
|
|
// Always interrupt if hit by a sticky bomb.
|
|
SetCustomInterruptCondition( COND_HUNTER_HIT_BY_STICKYBOMB );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
static bool IsMovablePhysicsObject( CBaseEntity *pEntity )
|
|
{
|
|
return pEntity && pEntity->GetMoveType() == MOVETYPE_VPHYSICS && pEntity->VPhysicsGetObject() && pEntity->VPhysicsGetObject()->IsMoveable();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
NPC_STATE CNPC_Hunter::SelectIdealState()
|
|
{
|
|
switch ( m_NPCState )
|
|
{
|
|
case NPC_STATE_COMBAT:
|
|
{
|
|
if ( GetEnemy() == NULL )
|
|
{
|
|
if ( !HasCondition( COND_ENEMY_DEAD ) && !hunter_disable_patrol.GetBool() )
|
|
{
|
|
// Lost track of my enemy. Patrol.
|
|
SetCondition( COND_HUNTER_SHOULD_PATROL );
|
|
}
|
|
|
|
return NPC_STATE_ALERT;
|
|
}
|
|
else if ( HasCondition( COND_ENEMY_DEAD ) )
|
|
{
|
|
// dvs: TODO: announce enemy kills?
|
|
//AnnounceEnemyKill(GetEnemy());
|
|
}
|
|
}
|
|
|
|
default:
|
|
{
|
|
return BaseClass::SelectIdealState();
|
|
}
|
|
}
|
|
|
|
return GetIdealState();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::ShouldCharge( const Vector &startPos, const Vector &endPos, bool useTime, bool bCheckForCancel )
|
|
{
|
|
// Must have a target
|
|
if ( !GetEnemy() )
|
|
return false;
|
|
|
|
// Don't check the distance once we start charging
|
|
if ( !bCheckForCancel && !hunter_charge_test.GetBool() )
|
|
{
|
|
float distance = ( startPos.AsVector2D() - endPos.AsVector2D() ).LengthSqr();
|
|
|
|
// Must be within our tolerance range
|
|
if ( ( distance < Square(HUNTER_CHARGE_MIN) ) || ( distance > Square(HUNTER_CHARGE_MAX) ) )
|
|
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_hunter_charge.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 ) < HUNTER_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;
|
|
}
|
|
|
|
float zDelta = endPos.z - moveTrace.vEndPosition.z;
|
|
if ( fabsf(zDelta) > GetHullHeight() * 0.7)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::HandleInteraction(int interactionType, void *data, CBaseCombatCharacter *pSourceEnt)
|
|
{
|
|
if ( ( pSourceEnt != this ) && ( interactionType == g_interactionHunterFoundEnemy ) )
|
|
{
|
|
SetCondition( COND_HUNTER_SQUADMATE_FOUND_ENEMY );
|
|
return true;
|
|
}
|
|
|
|
return BaseClass::HandleInteraction( interactionType, data, pSourceEnt );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Hunter::SelectCombatSchedule()
|
|
{
|
|
// If we're here with no enemy, patrol and hope we find one.
|
|
CBaseEntity *pEnemy = GetEnemy();
|
|
if ( pEnemy == NULL )
|
|
{
|
|
if ( !hunter_disable_patrol.GetBool() )
|
|
return SCHED_HUNTER_PATROL_RUN;
|
|
else
|
|
return SCHED_ALERT_STAND;
|
|
}
|
|
|
|
if ( hunter_flechette_test.GetBool() )
|
|
{
|
|
if ( HasCondition( COND_CAN_RANGE_ATTACK2 ) )
|
|
{
|
|
return SCHED_HUNTER_RANGE_ATTACK2;
|
|
}
|
|
return SCHED_COMBAT_FACE;
|
|
}
|
|
|
|
bool bStriderBuster = IsStriderBuster( pEnemy );
|
|
if ( bStriderBuster )
|
|
{
|
|
if ( gpGlobals->curtime - CAI_HunterEscortBehavior::gm_flLastDefendSound > 10.0 )
|
|
{
|
|
EmitSound( "NPC_Hunter.DefendStrider" );
|
|
CAI_HunterEscortBehavior::gm_flLastDefendSound = gpGlobals->curtime;
|
|
}
|
|
|
|
if ( HasCondition( COND_CAN_RANGE_ATTACK2 ) || HasCondition( COND_NOT_FACING_ATTACK ) )
|
|
{
|
|
return SCHED_HUNTER_RANGE_ATTACK2;
|
|
}
|
|
return SCHED_ESTABLISH_LINE_OF_FIRE;
|
|
}
|
|
|
|
// Certain behaviors, like flanking and melee attacks, only make sense on visible,
|
|
// corporeal enemies (NOT bullseyes).
|
|
bool bIsCorporealEnemy = IsCorporealEnemy( pEnemy );
|
|
|
|
// Take a quick swipe at our enemy if able to do so.
|
|
if ( bIsCorporealEnemy && HasCondition( COND_CAN_MELEE_ATTACK1 ) )
|
|
{
|
|
return SCHED_HUNTER_MELEE_ATTACK1;
|
|
}
|
|
|
|
// React to newly acquired enemies.
|
|
if ( bIsCorporealEnemy && HasCondition( COND_NEW_ENEMY ) )
|
|
{
|
|
AI_EnemyInfo_t *pEnemyInfo = GetEnemies()->Find( pEnemy );
|
|
|
|
if ( GetSquad() && pEnemyInfo && ( pEnemyInfo->timeFirstSeen == pEnemyInfo->timeAtFirstHand ) )
|
|
{
|
|
GetSquad()->BroadcastInteraction( g_interactionHunterFoundEnemy, NULL, this );
|
|
|
|
// First contact for my squad.
|
|
return SCHED_HUNTER_FOUND_ENEMY;
|
|
}
|
|
}
|
|
|
|
if ( HasCondition( COND_HUNTER_SQUADMATE_FOUND_ENEMY ) )
|
|
{
|
|
// A squadmate found an enemy. Respond to their call.
|
|
return SCHED_HUNTER_FOUND_ENEMY_ACK;
|
|
}
|
|
|
|
// Fire a flechette volley. Ignore squad slots if we're attacking a striderbuster.
|
|
// See if there is an opportunity to charge.
|
|
if ( !bStriderBuster && bIsCorporealEnemy && HasCondition( COND_HUNTER_CAN_CHARGE_ENEMY ) )
|
|
{
|
|
if ( hunter_charge_test.GetBool() || random->RandomInt( 1, 100 ) < hunter_charge_pct.GetInt() )
|
|
{
|
|
if ( hunter_charge_test.GetBool() || OccupyStrategySlot( SQUAD_SLOT_HUNTER_CHARGE ) )
|
|
{
|
|
return SCHED_HUNTER_CHARGE_ENEMY;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( HasCondition( COND_CAN_RANGE_ATTACK2 ) )
|
|
{
|
|
if ( bStriderBuster || CountRangedAttackers() < hunter_flechette_max_concurrent_volleys.GetInt() )
|
|
{
|
|
DelayRangedAttackers( hunter_flechette_volley_start_min_delay.GetFloat(), hunter_flechette_volley_start_max_delay.GetFloat(), true );
|
|
return SCHED_HUNTER_RANGE_ATTACK2;
|
|
}
|
|
}
|
|
|
|
if ( pEnemy->GetGroundEntity() == this )
|
|
{
|
|
return SCHED_HUNTER_MELEE_ATTACK1;
|
|
}
|
|
|
|
if ( HasCondition( COND_TOO_CLOSE_TO_ATTACK ) )
|
|
{
|
|
return SCHED_MOVE_AWAY_FROM_ENEMY;
|
|
}
|
|
|
|
// Sidestep every so often if my enemy is nearby and facing me.
|
|
/*
|
|
if ( gpGlobals->curtime > m_flNextSideStepTime )
|
|
{
|
|
if ( HasCondition( COND_ENEMY_FACING_ME ) && ( UTIL_DistApprox( GetEnemy()->GetAbsOrigin(), GetAbsOrigin() ) < HUNTER_FACE_ENEMY_DIST ) )
|
|
{
|
|
m_flNextSideStepTime = gpGlobals->curtime + random->RandomFloat( 1.0f, 3.0f );
|
|
return SCHED_HUNTER_SIDESTEP;
|
|
}
|
|
}
|
|
*/
|
|
if ( HasCondition( COND_HEAVY_DAMAGE ) && ( gpGlobals->curtime > m_flNextSideStepTime ) )
|
|
{
|
|
m_flNextSideStepTime = gpGlobals->curtime + random->RandomFloat( 1.0f, 3.0f );
|
|
return SCHED_HUNTER_SIDESTEP;
|
|
}
|
|
|
|
if ( !bStriderBuster && bIsCorporealEnemy )
|
|
{
|
|
if ( HasCondition( COND_HUNTER_CAN_CHARGE_ENEMY ) )
|
|
{
|
|
if ( OccupyStrategySlot( SQUAD_SLOT_HUNTER_CHARGE ) )
|
|
{
|
|
return SCHED_HUNTER_CHARGE_ENEMY;
|
|
}
|
|
/*
|
|
else
|
|
{
|
|
return SCHED_HUNTER_SIDESTEP;
|
|
}
|
|
*/
|
|
}
|
|
|
|
// Try to be a flanker.
|
|
if ( ( NumHuntersInMySquad() > 1 ) && OccupyStrategySlotRange( SQUAD_SLOT_HUNTER_FLANK_FIRST, SQUAD_SLOT_HUNTER_FLANK_LAST ) )
|
|
{
|
|
return SCHED_HUNTER_FLANK_ENEMY;
|
|
}
|
|
}
|
|
|
|
// Can't see my enemy.
|
|
if ( HasCondition( COND_ENEMY_OCCLUDED ) || HasCondition( COND_ENEMY_TOO_FAR ) || HasCondition( COND_TOO_FAR_TO_ATTACK ) || HasCondition( COND_NOT_FACING_ATTACK ) )
|
|
{
|
|
return SCHED_HUNTER_CHASE_ENEMY;
|
|
}
|
|
|
|
if ( HasCondition( COND_HUNTER_CANT_PLANT ) )
|
|
{
|
|
return SCHED_ESTABLISH_LINE_OF_FIRE;
|
|
}
|
|
|
|
//if ( HasCondition( COND_ENEMY_OCCLUDED ) && IsCurSchedule( SCHED_RANGE_ATTACK1, false ) )
|
|
//{
|
|
// return SCHED_HUNTER_COMBAT_FACE;
|
|
//}
|
|
|
|
return SCHED_HUNTER_CHANGE_POSITION;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Hunter::SelectSiegeSchedule()
|
|
{
|
|
bool bHasEnemy = (GetEnemy() != NULL);
|
|
|
|
if( bHasEnemy )
|
|
{
|
|
// We have an enemy, so we should be making every effort to attack it.
|
|
if( !HasCondition(COND_SEE_ENEMY) || !HasCondition(COND_CAN_RANGE_ATTACK2) )
|
|
return SCHED_ESTABLISH_LINE_OF_FIRE;
|
|
|
|
if( HasCondition(COND_CAN_RANGE_ATTACK2) )
|
|
return SCHED_HUNTER_RANGE_ATTACK2;
|
|
|
|
return SCHED_HUNTER_SIEGE_STAND;
|
|
}
|
|
else
|
|
{
|
|
// Otherwise we are loitering in siege mode. Break line of sight with the player
|
|
// if they expose our position.
|
|
if( HasCondition( COND_SEE_PLAYER ) )
|
|
return SCHED_HUNTER_CHANGE_POSITION_SIEGE;
|
|
}
|
|
|
|
return SCHED_HUNTER_SIEGE_STAND;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Hunter::SelectSchedule()
|
|
{
|
|
if ( hunter_stand_still.GetBool() )
|
|
{
|
|
m_bPlanted = false;
|
|
return SCHED_IDLE_STAND;
|
|
}
|
|
|
|
if ( HasCondition( COND_HUNTER_FORCED_DODGE ) )
|
|
return SCHED_HUNTER_DODGE;
|
|
|
|
if ( HasCondition( COND_HUNTER_NEW_HINTGROUP ) || ( GetHintGroup() != NULL_STRING && m_CheckHintGroupTimer.Expired() ) )
|
|
{
|
|
CAI_Hint *pHint;
|
|
CHintCriteria criteria;
|
|
criteria.SetGroup( GetHintGroup() );
|
|
criteria.SetFlag( bits_HINT_NODE_NEAREST );
|
|
|
|
if ( HasCondition( COND_HUNTER_NEW_HINTGROUP ) )
|
|
{
|
|
ClearCondition( COND_HUNTER_NEW_HINTGROUP );
|
|
if ( GetEnemy() )
|
|
{
|
|
pHint = CAI_HintManager::FindHint( NULL, GetEnemy()->GetAbsOrigin(), criteria );
|
|
}
|
|
else
|
|
{
|
|
pHint = CAI_HintManager::FindHint( GetAbsOrigin(), criteria );
|
|
}
|
|
|
|
if ( pHint )
|
|
{
|
|
pHint->Lock( this );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pHint = CAI_HintManager::FindHint( GetAbsOrigin(), criteria );
|
|
if ( pHint )
|
|
{
|
|
if ( (pHint->GetAbsOrigin() - GetAbsOrigin()).Length2DSqr() < Square( 20*12 ) )
|
|
{
|
|
m_CheckHintGroupTimer.Set( 5 );
|
|
pHint = NULL;
|
|
}
|
|
else
|
|
{
|
|
m_CheckHintGroupTimer.Set( 15 );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( pHint )
|
|
{
|
|
SetHintNode( pHint );
|
|
return SCHED_HUNTER_GOTO_HINT;
|
|
}
|
|
}
|
|
|
|
if ( HasCondition( COND_HUNTER_INCOMING_VEHICLE ) )
|
|
{
|
|
if ( m_RundownDelay.Expired() )
|
|
{
|
|
int iRundownCounter = 0;
|
|
if ( GetSquad() )
|
|
{
|
|
GetSquad()->GetSquadData( HUNTER_RUNDOWN_SQUADDATA, &iRundownCounter );
|
|
}
|
|
|
|
if ( iRundownCounter % 2 == 0 )
|
|
{
|
|
for ( int i = 0; i < g_Hunters.Count(); i++ )
|
|
{
|
|
if ( g_Hunters[i] != this )
|
|
{
|
|
g_Hunters[i]->m_RundownDelay.Set( 3 );
|
|
g_Hunters[i]->m_IgnoreVehicleTimer.Force();
|
|
}
|
|
}
|
|
m_IgnoreVehicleTimer.Set( hunter_dodge_warning.GetFloat() * 4 );
|
|
if ( hunter_dodge_debug.GetBool() )
|
|
{
|
|
Msg( "Hunter %d rundown\n", entindex() );
|
|
}
|
|
|
|
if ( HasCondition( COND_SEE_ENEMY ) )
|
|
{
|
|
if ( m_bPlanted && HasCondition( COND_CAN_RANGE_ATTACK2 ) )
|
|
{
|
|
return SCHED_HUNTER_RANGE_ATTACK2;
|
|
}
|
|
else if ( random->RandomInt( 0, 1 ) )
|
|
{
|
|
return SCHED_HUNTER_CHARGE_ENEMY;
|
|
}
|
|
else
|
|
{
|
|
return SCHED_MOVE_AWAY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetTarget( UTIL_GetLocalPlayer() );
|
|
return SCHED_TARGET_FACE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( hunter_dodge_debug.GetBool() )
|
|
{
|
|
Msg( "Hunter %d safe from rundown\n", entindex() );
|
|
}
|
|
for ( int i = 0; i < g_Hunters.Count(); i++ )
|
|
{
|
|
g_Hunters[i]->m_RundownDelay.Set( 4 );
|
|
g_Hunters[i]->m_IgnoreVehicleTimer.Force();
|
|
}
|
|
if ( GetSquad() )
|
|
{
|
|
GetSquad()->SetSquadData( HUNTER_RUNDOWN_SQUADDATA, iRundownCounter + 1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( HasCondition( COND_SEE_ENEMY ) )
|
|
{
|
|
if ( hunter_dodge_debug.GetBool() )
|
|
{
|
|
Msg( "Hunter %d try dodge\n", entindex() );
|
|
}
|
|
return SCHED_HUNTER_DODGE;
|
|
}
|
|
else
|
|
{
|
|
SetTarget( UTIL_GetLocalPlayer() );
|
|
return SCHED_TARGET_FACE;
|
|
}
|
|
|
|
CSound *pBestSound = GetBestSound( SOUND_PHYSICS_DANGER );
|
|
if ( pBestSound && ( pBestSound->SoundContext() & SOUND_CONTEXT_PLAYER_VEHICLE ) )
|
|
{
|
|
return SCHED_ALERT_FACE_BESTSOUND;
|
|
}
|
|
}
|
|
|
|
if ( HasCondition( COND_HUNTER_FORCED_FLANK_ENEMY ) )
|
|
{
|
|
return SCHED_HUNTER_FLANK_ENEMY;
|
|
}
|
|
|
|
if ( HasCondition( COND_HUNTER_STAGGERED ) /*|| HasCondition( COND_HUNTER_HIT_BY_STICKYBOMB )*/ )
|
|
{
|
|
return SCHED_HUNTER_STAGGER;
|
|
}
|
|
|
|
// Now that we're past all of the forced reactions to things, if we're running the siege
|
|
// behavior, go pick an appropriate siege schedule UNLESS we have an enemy. If we have
|
|
// an enemy, we should focus on attacking that enemy.
|
|
if( IsUsingSiegeTargets() )
|
|
{
|
|
return SelectSiegeSchedule();
|
|
}
|
|
|
|
// back away if there's a magnade glued to my head.
|
|
if ( hunter_retreat_striderbusters.GetBool() /*&& GetEnemy() && ( GetEnemy()->IsPlayer() )*/
|
|
&& (m_hAttachedBusters.Count() > 0)
|
|
&& m_fCorneredTimer < gpGlobals->curtime)
|
|
{
|
|
return SCHED_HUNTER_TAKE_COVER_FROM_ENEMY;
|
|
}
|
|
|
|
if ( !BehaviorSelectSchedule() )
|
|
{
|
|
switch ( GetState() )
|
|
{
|
|
case NPC_STATE_IDLE:
|
|
{
|
|
return SCHED_HUNTER_PATROL;
|
|
}
|
|
|
|
case NPC_STATE_ALERT:
|
|
{
|
|
if ( HasCondition( COND_HUNTER_SHOULD_PATROL ) )
|
|
return SCHED_HUNTER_PATROL;
|
|
|
|
break;
|
|
}
|
|
|
|
case NPC_STATE_COMBAT:
|
|
{
|
|
return SelectCombatSchedule();
|
|
}
|
|
}
|
|
}
|
|
|
|
return BaseClass::SelectSchedule();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Hunter::TranslateSchedule( int scheduleType )
|
|
{
|
|
switch ( scheduleType )
|
|
{
|
|
case SCHED_RANGE_ATTACK1:
|
|
{
|
|
return SCHED_HUNTER_RANGE_ATTACK1;
|
|
}
|
|
|
|
case SCHED_RANGE_ATTACK2:
|
|
case SCHED_HUNTER_RANGE_ATTACK2:
|
|
{
|
|
if ( scheduleType == SCHED_RANGE_ATTACK2 )
|
|
{
|
|
Msg( "HUNTER IGNORING SQUAD SLOTS\n" );
|
|
}
|
|
|
|
if ( IsStriderBuster( GetEnemy() ) )
|
|
{
|
|
// Attack as FAST as possible. The point is to shoot down the buster.
|
|
return SCHED_HUNTER_RANGE_ATTACK2_VS_STRIDERBUSTER;
|
|
}
|
|
|
|
return SCHED_HUNTER_RANGE_ATTACK2;
|
|
}
|
|
|
|
case SCHED_MELEE_ATTACK1:
|
|
{
|
|
return SCHED_HUNTER_MELEE_ATTACK1;
|
|
}
|
|
|
|
case SCHED_ESTABLISH_LINE_OF_FIRE_FALLBACK:
|
|
{
|
|
return SCHED_HUNTER_CHANGE_POSITION;
|
|
}
|
|
|
|
case SCHED_ALERT_STAND:
|
|
{
|
|
if ( !hunter_disable_patrol.GetBool() )
|
|
return SCHED_HUNTER_PATROL_RUN;
|
|
break;
|
|
}
|
|
|
|
case SCHED_COMBAT_FACE:
|
|
{
|
|
return SCHED_HUNTER_COMBAT_FACE;
|
|
}
|
|
|
|
case SCHED_HUNTER_PATROL:
|
|
{
|
|
if ( hunter_disable_patrol.GetBool() )
|
|
{
|
|
return SCHED_IDLE_STAND;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return BaseClass::TranslateSchedule( scheduleType );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// catch blockage while escaping magnade
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::TaskFail( AI_TaskFailureCode_t code )
|
|
{
|
|
if ( IsCurSchedule( SCHED_HUNTER_TAKE_COVER_FROM_ENEMY, false ) && ( code == FAIL_NO_ROUTE_BLOCKED ) )
|
|
{
|
|
// cornered!
|
|
if ( m_fCorneredTimer < gpGlobals->curtime )
|
|
{
|
|
m_fCorneredTimer = gpGlobals->curtime + 6.0f;
|
|
}
|
|
}
|
|
|
|
BaseClass::TaskFail( code );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The player is speeding toward us in a vehicle! Find a good activity for dodging.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::TaskFindDodgeActivity()
|
|
{
|
|
if ( GetEnemy() == NULL )
|
|
{
|
|
TaskFail( "No enemy to dodge" );
|
|
return;
|
|
}
|
|
|
|
Vector vecUp;
|
|
Vector vecRight;
|
|
GetVectors( NULL, &vecRight, &vecUp );
|
|
|
|
// TODO: find most perpendicular 8-way dodge when we get the anims
|
|
Vector vecEnemyDir = GetEnemy()->GetAbsOrigin() - GetAbsOrigin();
|
|
//Vector vecDir = CrossProduct( vecEnemyDir, vecUp );
|
|
VectorNormalize( vecEnemyDir );
|
|
if ( fabs( DotProduct( vecEnemyDir, vecRight ) ) > 0.7 )
|
|
{
|
|
TaskFail( "Can't dodge, enemy approaching perpendicularly" );
|
|
return;
|
|
}
|
|
|
|
// Check left or right randomly first.
|
|
bool bDodgeLeft = false;
|
|
CBaseEntity *pVehicle = GetEnemyVehicle();
|
|
if ( pVehicle )
|
|
{
|
|
Ray_t enemyRay;
|
|
Ray_t perpendicularRay;
|
|
enemyRay.Init( pVehicle->GetAbsOrigin(), pVehicle->GetAbsOrigin() + pVehicle->GetSmoothedVelocity() );
|
|
Vector vPerpendicularPt = vecEnemyDir;
|
|
vPerpendicularPt.y = -vPerpendicularPt.y;
|
|
perpendicularRay.Init( GetAbsOrigin(), GetAbsOrigin() + vPerpendicularPt );
|
|
|
|
enemyRay.m_Start.z = enemyRay.m_Delta.z = enemyRay.m_StartOffset.z;
|
|
perpendicularRay.m_Start.z = perpendicularRay.m_Delta.z = perpendicularRay.m_StartOffset.z;
|
|
|
|
float t, s;
|
|
|
|
IntersectRayWithRay( perpendicularRay, enemyRay, t, s );
|
|
|
|
if ( t > 0 )
|
|
{
|
|
bDodgeLeft = true;
|
|
}
|
|
}
|
|
else if ( random->RandomInt( 0, 1 ) == 0 )
|
|
{
|
|
bDodgeLeft = true;
|
|
}
|
|
|
|
bool bFoundDir = false;
|
|
int nTries = 0;
|
|
|
|
while ( !bFoundDir && ( nTries < 2 ) )
|
|
{
|
|
// Pick a dodge activity to try.
|
|
if ( bDodgeLeft )
|
|
{
|
|
m_eDodgeActivity = ACT_HUNTER_DODGEL;
|
|
}
|
|
else
|
|
{
|
|
m_eDodgeActivity = ACT_HUNTER_DODGER;
|
|
}
|
|
|
|
// See where the dodge will put us.
|
|
Vector vecLocalDelta;
|
|
int nSeq = SelectWeightedSequence( m_eDodgeActivity );
|
|
GetSequenceLinearMotion( nSeq, &vecLocalDelta );
|
|
|
|
// Transform the sequence delta into local space.
|
|
matrix3x4_t fRotateMatrix;
|
|
AngleMatrix( GetLocalAngles(), fRotateMatrix );
|
|
Vector vecDelta;
|
|
VectorRotate( vecLocalDelta, fRotateMatrix, vecDelta );
|
|
|
|
// Trace a bit high so this works better on uneven terrain.
|
|
Vector testHullMins = GetHullMins();
|
|
testHullMins.z += ( StepHeight() * 2 );
|
|
|
|
// See if all is clear in that direction.
|
|
trace_t tr;
|
|
HunterTraceHull_SkipPhysics( GetAbsOrigin(), GetAbsOrigin() + vecDelta, testHullMins, GetHullMaxs(), MASK_NPCSOLID, this, GetCollisionGroup(), &tr, VPhysicsGetObject()->GetMass() * 0.5f );
|
|
|
|
// TODO: dodge anyway if we'll make it a certain percentage of the way through the dodge?
|
|
if ( tr.fraction == 1.0f )
|
|
{
|
|
//NDebugOverlay::SweptBox( GetAbsOrigin(), GetAbsOrigin() + vecDelta, testHullMins, GetHullMaxs(), QAngle( 0, 0, 0 ), 0, 255, 0, 128, 5 );
|
|
bFoundDir = true;
|
|
TaskComplete();
|
|
}
|
|
else
|
|
{
|
|
//NDebugOverlay::SweptBox( GetAbsOrigin(), GetAbsOrigin() + vecDelta, testHullMins, GetHullMaxs(), QAngle( 0, 0, 0 ), 255, 0, 0, 128, 5 );
|
|
nTries++;
|
|
bDodgeLeft = !bDodgeLeft;
|
|
}
|
|
}
|
|
|
|
if ( nTries < 2 )
|
|
{
|
|
TaskComplete();
|
|
}
|
|
else
|
|
{
|
|
TaskFail( "Couldn't find dodge position\n" );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::StartTask( const Task_t *pTask )
|
|
{
|
|
switch ( pTask->iTask )
|
|
{
|
|
case TASK_HUNTER_FINISH_RANGE_ATTACK:
|
|
{
|
|
if( GetEnemy() != NULL && GetEnemy()->Classify() == CLASS_PLAYER_ALLY_VITAL )
|
|
{
|
|
// Just finished shooting at Alyx! So forget her for a little while and get back on the player
|
|
// !!!LATER - make sure there's someone else in enemy memory to go bother.
|
|
GetEnemies()->SetTimeValidEnemy( GetEnemy(), gpGlobals->curtime + 10.0f );
|
|
}
|
|
|
|
if( m_hCurrentSiegeTarget )
|
|
{
|
|
// We probably just fired at our siege target, so dump it.
|
|
KillCurrentSiegeTarget();
|
|
}
|
|
|
|
TaskComplete();
|
|
}
|
|
|
|
case TASK_HUNTER_WAIT_FOR_MOVEMENT_FACING_ENEMY:
|
|
{
|
|
ChainStartTask( TASK_WAIT_FOR_MOVEMENT, pTask->flTaskData );
|
|
break;
|
|
}
|
|
|
|
case TASK_HUNTER_BEGIN_FLANK:
|
|
{
|
|
if ( IsInSquad() && GetSquad()->NumMembers() > 1 )
|
|
{
|
|
// Flank relative to the other shooter in our squad.
|
|
// If there's no other shooter, just flank relative to any squad member.
|
|
AISquadIter_t iter;
|
|
CAI_BaseNPC *pNPC = GetSquad()->GetFirstMember( &iter );
|
|
while ( pNPC == this )
|
|
{
|
|
pNPC = GetSquad()->GetNextMember( &iter );
|
|
}
|
|
|
|
m_vSavePosition = pNPC->GetAbsOrigin();
|
|
}
|
|
else
|
|
{
|
|
// Flank relative to our current position.
|
|
m_vSavePosition = GetAbsOrigin();
|
|
}
|
|
|
|
TaskComplete();
|
|
break;
|
|
}
|
|
|
|
case TASK_HUNTER_ANNOUNCE_FLANK:
|
|
{
|
|
EmitSound( "NPC_Hunter.FlankAnnounce" );
|
|
TaskComplete();
|
|
break;
|
|
}
|
|
|
|
case TASK_HUNTER_DODGE:
|
|
{
|
|
if ( hunter_dodge_debug. GetBool() )
|
|
{
|
|
Msg( "Hunter %d dodging\n", entindex() );
|
|
}
|
|
SetIdealActivity( m_eDodgeActivity );
|
|
break;
|
|
}
|
|
|
|
// Guarantee a certain delay between volleys. If we aren't already planted,
|
|
// the plant transition animation will take care of that.
|
|
case TASK_HUNTER_PRE_RANGE_ATTACK2:
|
|
{
|
|
if ( !m_bPlanted || ( GetEnemy() && IsStriderBuster( GetEnemy() ) ) )
|
|
{
|
|
TaskComplete();
|
|
}
|
|
else
|
|
{
|
|
SetIdealActivity( ACT_HUNTER_ANGRY );
|
|
}
|
|
break;
|
|
}
|
|
|
|
case TASK_HUNTER_SHOOT_COMMIT:
|
|
{
|
|
// We're committing to shooting. Don't allow interrupts until after we've shot a bit (see TASK_RANGE_ATTACK1).
|
|
m_flShootAllowInterruptTime = gpGlobals->curtime + 100.0f;
|
|
TaskComplete();
|
|
break;
|
|
}
|
|
|
|
case TASK_RANGE_ATTACK2:
|
|
{
|
|
if ( GetEnemy() )
|
|
{
|
|
bool bIsBuster = IsStriderBuster( GetEnemy() );
|
|
if ( bIsBuster )
|
|
{
|
|
AddFacingTarget( GetEnemy(), GetEnemy()->GetAbsOrigin() + GetEnemy()->GetSmoothedVelocity() * .5, 1.0, 0.8 );
|
|
}
|
|
|
|
// Start the firing sound.
|
|
//CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
|
//controller.SoundChangeVolume( m_pGunFiringSound, 1.0, hunter_first_flechette_delay.GetFloat() );
|
|
|
|
SetIdealActivity( ACT_RANGE_ATTACK2 );
|
|
|
|
// Decide how many shots to fire.
|
|
int nShots = hunter_flechette_volley_size.GetInt();
|
|
if ( g_pGameRules->IsSkillLevel( SKILL_EASY ) )
|
|
{
|
|
nShots--;
|
|
}
|
|
|
|
// Decide when to fire the first shot.
|
|
float initialDelay = hunter_first_flechette_delay.GetFloat();
|
|
if ( bIsBuster )
|
|
{
|
|
initialDelay = 0; //*= 0.5;
|
|
}
|
|
|
|
BeginVolley( nShots, gpGlobals->curtime + initialDelay );
|
|
|
|
// In case we need to miss on purpose, pick a direction now.
|
|
m_bMissLeft = false;
|
|
if ( random->RandomInt( 0, 1 ) == 0 )
|
|
{
|
|
m_bMissLeft = true;
|
|
}
|
|
|
|
LockBothEyes( initialDelay + ( nShots * hunter_flechette_delay.GetFloat() ) );
|
|
}
|
|
else
|
|
{
|
|
TaskFail( FAIL_NO_ENEMY );
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case TASK_HUNTER_STAGGER:
|
|
{
|
|
// Stagger in the direction the impact force would push us.
|
|
VMatrix worldToLocalRotation = EntityToWorldTransform();
|
|
Vector vecLocalStaggerDir = worldToLocalRotation.InverseTR().ApplyRotation( m_vecStaggerDir );
|
|
|
|
float flStaggerYaw = VecToYaw( vecLocalStaggerDir );
|
|
SetPoseParameter( gm_nStaggerYawPoseParam, flStaggerYaw );
|
|
|
|
// Go straight there!
|
|
SetActivity( ACT_RESET );
|
|
SetActivity( ( Activity )ACT_HUNTER_STAGGER );
|
|
break;
|
|
}
|
|
|
|
case TASK_MELEE_ATTACK1:
|
|
{
|
|
SetLastAttackTime( gpGlobals->curtime );
|
|
|
|
if ( GetEnemy() && GetEnemy()->IsPlayer() )
|
|
{
|
|
ResetIdealActivity( ( Activity )ACT_HUNTER_MELEE_ATTACK1_VS_PLAYER );
|
|
}
|
|
else
|
|
{
|
|
ResetIdealActivity( ACT_MELEE_ATTACK1 );
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case TASK_HUNTER_CORNERED_TIMER:
|
|
{
|
|
m_fCorneredTimer = gpGlobals->curtime + pTask->flTaskData;
|
|
|
|
break;
|
|
}
|
|
|
|
case TASK_HUNTER_FIND_SIDESTEP_POSITION:
|
|
{
|
|
if ( GetEnemy() == NULL )
|
|
{
|
|
TaskFail( "No enemy to sidestep" );
|
|
}
|
|
else
|
|
{
|
|
Vector vecUp;
|
|
GetVectors( NULL, NULL, &vecUp );
|
|
|
|
Vector vecEnemyDir = GetEnemy()->GetAbsOrigin() - GetAbsOrigin();
|
|
Vector vecDir = CrossProduct( vecEnemyDir, vecUp );
|
|
VectorNormalize( vecDir );
|
|
|
|
// Sidestep left or right randomly.
|
|
if ( random->RandomInt( 0, 1 ) == 0 )
|
|
{
|
|
vecDir *= -1;
|
|
}
|
|
|
|
// Start high and then trace down so that it works on uneven terrain.
|
|
Vector vecPos = GetAbsOrigin() + Vector( 0, 0, 64 ) + random->RandomFloat( 120, 200 ) * vecDir;
|
|
|
|
// Try to find the ground at the sidestep position.
|
|
trace_t tr;
|
|
UTIL_TraceLine( vecPos, vecPos + Vector( 0, 0, -128 ), MASK_NPCSOLID, NULL, COLLISION_GROUP_NONE, &tr );
|
|
if ( tr.fraction < 1.0f )
|
|
{
|
|
//NDebugOverlay::Line( vecPos, tr.endpos, 0, 255, 0, true, 10 );
|
|
|
|
m_vSavePosition = tr.endpos;
|
|
|
|
TaskComplete();
|
|
}
|
|
else
|
|
{
|
|
TaskFail( "Couldn't find sidestep position\n" );
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case TASK_HUNTER_FIND_DODGE_POSITION:
|
|
{
|
|
TaskFindDodgeActivity();
|
|
break;
|
|
}
|
|
|
|
case TASK_HUNTER_CHARGE:
|
|
{
|
|
SetIdealActivity( ( Activity )ACT_HUNTER_CHARGE_START );
|
|
break;
|
|
}
|
|
|
|
case TASK_HUNTER_CHARGE_DELAY:
|
|
{
|
|
m_flNextChargeTime = gpGlobals->curtime + pTask->flTaskData;
|
|
TaskComplete();
|
|
break;
|
|
}
|
|
|
|
case TASK_DIE:
|
|
{
|
|
GetNavigator()->StopMoving();
|
|
ResetActivity();
|
|
SetIdealActivity( GetDeathActivity() );
|
|
m_lifeState = LIFE_DYING;
|
|
|
|
break;
|
|
}
|
|
|
|
//case TASK_HUNTER_END_FLANK:
|
|
//{
|
|
//
|
|
//}
|
|
|
|
default:
|
|
{
|
|
BaseClass::StartTask( pTask );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::RunTask( const Task_t *pTask )
|
|
{
|
|
switch ( pTask->iTask )
|
|
{
|
|
case TASK_HUNTER_PRE_RANGE_ATTACK2:
|
|
{
|
|
if ( IsActivityFinished() )
|
|
{
|
|
TaskComplete();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case TASK_RANGE_ATTACK2:
|
|
{
|
|
if( !hunter_hate_thrown_striderbusters.GetBool() && GetEnemy() != NULL && IsStriderBuster( GetEnemy() ) )
|
|
{
|
|
if( !IsValidEnemy(GetEnemy()) )
|
|
{
|
|
TaskFail("No longer hate this StriderBuster");
|
|
}
|
|
}
|
|
|
|
bool bIsBuster = IsStriderBuster( GetEnemy() );
|
|
if ( bIsBuster )
|
|
{
|
|
Vector vFuturePosition = GetEnemy()->GetAbsOrigin() + GetEnemy()->GetSmoothedVelocity() * .3;
|
|
AddFacingTarget( GetEnemy(), vFuturePosition, 1.0, 0.8 );
|
|
|
|
Vector2D vToFuturePositon = ( vFuturePosition.AsVector2D() - GetAbsOrigin().AsVector2D() );
|
|
vToFuturePositon.NormalizeInPlace();
|
|
Vector2D facingDir = BodyDirection2D().AsVector2D();
|
|
|
|
float flDot = DotProduct2D( vToFuturePositon, facingDir );
|
|
|
|
if ( flDot < .4 )
|
|
{
|
|
GetMotor()->SetIdealYawToTarget( vFuturePosition );
|
|
GetMotor()->UpdateYaw();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( gpGlobals->curtime >= m_flNextFlechetteTime )
|
|
{
|
|
// Must have an enemy and a shot queued up.
|
|
bool bDone = false;
|
|
if ( GetEnemy() != NULL && m_nFlechettesQueued > 0 )
|
|
{
|
|
if ( ShootFlechette( GetEnemy(), false ) )
|
|
{
|
|
m_nClampedShots++;
|
|
}
|
|
else
|
|
{
|
|
m_nClampedShots = 0;
|
|
}
|
|
|
|
m_nFlechettesQueued--;
|
|
|
|
// If we fired three or more clamped shots in a row, call it quits so we don't look dumb.
|
|
if ( ( m_nClampedShots >= 3 ) || ( m_nFlechettesQueued == 0 ) )
|
|
{
|
|
bDone = true;
|
|
}
|
|
else
|
|
{
|
|
// More shooting to do. Schedule our next flechette.
|
|
m_flNextFlechetteTime = gpGlobals->curtime + hunter_flechette_delay.GetFloat();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bDone = true;
|
|
}
|
|
|
|
if ( bDone )
|
|
{
|
|
// Stop the firing sound.
|
|
//CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
|
//controller.SoundChangeVolume( m_pGunFiringSound, 0.0f, 0.1f );
|
|
|
|
DelayRangedAttackers( hunter_flechette_volley_end_min_delay.GetFloat(), hunter_flechette_volley_end_max_delay.GetFloat(), true );
|
|
TaskComplete();
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case TASK_GET_PATH_TO_ENEMY_LOS:
|
|
{
|
|
ChainRunTask( TASK_GET_PATH_TO_ENEMY_LKP_LOS, pTask->flTaskData );
|
|
break;
|
|
}
|
|
|
|
case TASK_HUNTER_DODGE:
|
|
{
|
|
AutoMovement();
|
|
|
|
if ( IsActivityFinished() )
|
|
{
|
|
TaskComplete();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case TASK_HUNTER_CORNERED_TIMER:
|
|
{
|
|
TaskComplete();
|
|
break;
|
|
}
|
|
|
|
case TASK_HUNTER_STAGGER:
|
|
{
|
|
if ( IsActivityFinished() )
|
|
{
|
|
TaskComplete();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case TASK_HUNTER_CHARGE:
|
|
{
|
|
Activity eActivity = GetActivity();
|
|
|
|
// See if we're trying to stop after hitting/missing our target
|
|
if ( eActivity == ACT_HUNTER_CHARGE_STOP || eActivity == ACT_HUNTER_CHARGE_CRASH )
|
|
{
|
|
if ( IsActivityFinished() )
|
|
{
|
|
m_flNextChargeTime = gpGlobals->curtime + hunter_charge_min_delay.GetFloat() + random->RandomFloat( 0, 2.5 ) + random->RandomFloat( 0, 2.5 );
|
|
float delayMultiplier = ( g_pGameRules->IsSkillLevel( SKILL_EASY ) ) ? 1.5 : 1.0;
|
|
float groupDelay = gpGlobals->curtime + ( 2.0 + random->RandomFloat( 0, 2 ) ) * delayMultiplier;
|
|
for ( int i = 0; i < g_Hunters.Count(); i++ )
|
|
{
|
|
if ( g_Hunters[i] != this && g_Hunters[i]->m_flNextChargeTime < groupDelay )
|
|
{
|
|
g_Hunters[i]->m_flNextChargeTime = groupDelay;
|
|
}
|
|
}
|
|
TaskComplete();
|
|
return;
|
|
}
|
|
|
|
// Still in the process of slowing down. Run movement until it's done.
|
|
AutoMovement();
|
|
return;
|
|
}
|
|
|
|
// Check for manual transition
|
|
if ( ( eActivity == ACT_HUNTER_CHARGE_START ) && ( IsActivityFinished() ) )
|
|
{
|
|
SetIdealActivity( ACT_HUNTER_CHARGE_RUN );
|
|
}
|
|
|
|
// See if we're still running
|
|
if ( eActivity == ACT_HUNTER_CHARGE_RUN || eActivity == ACT_HUNTER_CHARGE_START )
|
|
{
|
|
if ( HasCondition( COND_NEW_ENEMY ) || HasCondition( COND_LOST_ENEMY ) || HasCondition( COND_ENEMY_DEAD ) )
|
|
{
|
|
SetIdealActivity( ACT_HUNTER_CHARGE_STOP );
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if ( GetEnemy() != NULL )
|
|
{
|
|
Vector goalDir = ( GetEnemy()->GetAbsOrigin() - GetAbsOrigin() );
|
|
VectorNormalize( goalDir );
|
|
|
|
if ( DotProduct( BodyDirection2D(), goalDir ) < 0.25f )
|
|
{
|
|
SetIdealActivity( ACT_HUNTER_CHARGE_STOP );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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_HUNTER_CHARGE_START )
|
|
{
|
|
TaskFail( "Unable to make initial movement of charge\n" );
|
|
return;
|
|
}
|
|
|
|
// Crash unless we're trying to stop already
|
|
if ( eActivity != ACT_HUNTER_CHARGE_STOP )
|
|
{
|
|
if ( moveTrace.fStatus == AIMR_BLOCKED_WORLD && moveTrace.vHitNormal == vec3_origin )
|
|
{
|
|
SetIdealActivity( ACT_HUNTER_CHARGE_STOP );
|
|
}
|
|
else
|
|
{
|
|
// Shake the screen
|
|
if ( moveTrace.fStatus != AIMR_BLOCKED_NPC )
|
|
{
|
|
EmitSound( "NPC_Hunter.ChargeHitWorld" );
|
|
UTIL_ScreenShake( GetAbsOrigin(), 16.0f, 4.0f, 1.0f, 400.0f, SHAKE_START );
|
|
}
|
|
SetIdealActivity( ACT_HUNTER_CHARGE_CRASH );
|
|
}
|
|
}
|
|
}
|
|
else if ( moveTrace.pObstruction )
|
|
{
|
|
// If we hit another hunter, stop
|
|
if ( moveTrace.pObstruction->Classify() == CLASS_COMBINE_HUNTER )
|
|
{
|
|
// Crash unless we're trying to stop already
|
|
if ( eActivity != ACT_HUNTER_CHARGE_STOP )
|
|
{
|
|
SetIdealActivity( ACT_HUNTER_CHARGE_STOP );
|
|
}
|
|
}
|
|
// If we hit an antlion, don't stop, but kill it
|
|
// We never have hunters and antlions together, but you never know.
|
|
else if (moveTrace.pObstruction->Classify() == CLASS_ANTLION )
|
|
{
|
|
if ( FClassnameIs( moveTrace.pObstruction, "npc_antlionguard" ) )
|
|
{
|
|
// Crash unless we're trying to stop already
|
|
if ( eActivity != ACT_HUNTER_CHARGE_STOP )
|
|
{
|
|
SetIdealActivity( ACT_HUNTER_CHARGE_STOP );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Hunter_ApplyChargeDamage( this, moveTrace.pObstruction, moveTrace.pObstruction->GetHealth() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case TASK_HUNTER_WAIT_FOR_MOVEMENT_FACING_ENEMY:
|
|
{
|
|
if ( GetEnemy() )
|
|
{
|
|
Vector vecEnemyLKP = GetEnemyLKP();
|
|
AddFacingTarget( GetEnemy(), vecEnemyLKP, 1.0, 0.8 );
|
|
}
|
|
ChainRunTask( TASK_WAIT_FOR_MOVEMENT, pTask->flTaskData );
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
BaseClass::RunTask( pTask );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Return true if our charge target is right in front of the hunter.
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::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_TraceHull( WorldSpaceCenter(), GetEnemy()->WorldSpaceCenter(), GetHullMins() * 0.5, GetHullMaxs() * 0.5, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
|
|
if ( tr.m_pEnt == GetEnemy() )
|
|
{
|
|
*pEntity = tr.m_pEnt;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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_Hunter::ChargeLookAhead( void )
|
|
{
|
|
#if 0
|
|
trace_t tr;
|
|
Vector vecForward;
|
|
GetVectors( &vecForward, NULL, NULL );
|
|
Vector vecTestPos = GetAbsOrigin() + ( vecForward * m_flGroundSpeed * 0.75 );
|
|
Vector testHullMins = GetHullMins();
|
|
testHullMins.z += (StepHeight() * 2);
|
|
HunterTraceHull_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 )
|
|
{
|
|
// dvs: TODO:
|
|
// Start playing the hit animation
|
|
//AddGesture( ACT_HUNTER_CHARGE_ANTICIPATION );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
float CNPC_Hunter::ChargeSteer()
|
|
{
|
|
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
|
|
HunterTraceHull_SkipPhysics( GetAbsOrigin(), testPos, testHullMins, GetHullMaxs(), MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr, VPhysicsGetObject()->GetMass() * 0.5f );
|
|
|
|
// Debug info
|
|
if ( g_debug_hunter_charge.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 );
|
|
HunterTraceHull_SkipPhysics( GetAbsOrigin(), testPos, testHullMins, GetHullMaxs(), MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr, VPhysicsGetObject()->GetMass() * 0.5f );
|
|
|
|
// Debug
|
|
if ( g_debug_hunter_charge.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_hunter_charge.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 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::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_hunter_dmg_charge.GetFloat();
|
|
|
|
// If it's being held by the player, break that bond
|
|
Pickup_ForcePlayerToDropThisObject( pTarget );
|
|
|
|
// Calculate the physics force
|
|
Hunter_ApplyChargeDamage( this, pTarget, flDamage );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Handles the hunter charging into something. Returns true if it hit the world.
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::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 hunter 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 hunter 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() )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Hit anything we don't like
|
|
if ( IRelationType( pEntity ) == D_HT && ( GetNextAttack() < gpGlobals->curtime ) )
|
|
{
|
|
EmitSound( "NPC_Hunter.ChargeHitEnemy" );
|
|
|
|
// dvs: TODO:
|
|
//if ( !IsPlayingGesture( ACT_HUNTER_CHARGE_HIT ) )
|
|
//{
|
|
// RestartGesture( ACT_HUNTER_CHARGE_HIT );
|
|
//}
|
|
|
|
ChargeDamage( pEntity );
|
|
|
|
if ( !pEntity->IsNPC() )
|
|
{
|
|
pEntity->ApplyAbsVelocityImpulse( ( BodyDirection2D() * 400 ) + Vector( 0, 0, 200 ) );
|
|
}
|
|
|
|
if ( !pEntity->IsAlive() && GetEnemy() == pEntity )
|
|
{
|
|
SetEnemy( NULL );
|
|
}
|
|
|
|
SetNextAttack( gpGlobals->curtime + 2.0f );
|
|
|
|
if ( !pEntity->IsAlive() || !pEntity->IsNPC() )
|
|
{
|
|
SetIdealActivity( ACT_HUNTER_CHARGE_STOP );
|
|
return false;
|
|
}
|
|
else
|
|
return true;
|
|
|
|
}
|
|
|
|
// Hit something we don't hate. If it's not moveable, crash into it.
|
|
if ( pEntity->GetMoveType() == MOVETYPE_NONE || pEntity->GetMoveType() == MOVETYPE_PUSH )
|
|
{
|
|
CBreakable *pBreakable = dynamic_cast<CBreakable *>(pEntity);
|
|
if ( pBreakable && pBreakable->IsBreakable() && pBreakable->m_takedamage == DAMAGE_YES && pBreakable->GetHealth() > 0 )
|
|
{
|
|
ChargeDamage( pEntity );
|
|
}
|
|
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() )
|
|
return true;
|
|
|
|
float entMass = PhysGetEntityMass( pEntity ) ;
|
|
float minMass = VPhysicsGetObject()->GetMass() * 0.5f;
|
|
if ( entMass < minMass )
|
|
{
|
|
if ( entMass < minMass * 0.666f || pEntity->CollisionProp()->BoundingRadius() < GetHullHeight() )
|
|
{
|
|
if ( pEntity->GetHealth() > 0 )
|
|
{
|
|
CBreakableProp *pBreakable = dynamic_cast<CBreakableProp *>(pEntity);
|
|
if ( pBreakable && pBreakable->m_takedamage == DAMAGE_YES && pBreakable->GetHealth() > 0 && pBreakable->GetHealth() <= 50 )
|
|
{
|
|
ChargeDamage( pEntity );
|
|
}
|
|
}
|
|
pEntity->SetNavIgnore( 2.0 );
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
//-------------------------------------------------------------------------------------------------
|
|
void CNPC_Hunter::Explode()
|
|
{
|
|
Vector velocity = vec3_origin;
|
|
AngularImpulse angVelocity = RandomAngularImpulse( -150, 150 );
|
|
|
|
PropBreakableCreateAll( GetModelIndex(), NULL, EyePosition(), GetAbsAngles(), velocity, angVelocity, 1.0, 150, COLLISION_GROUP_NPC, this );
|
|
|
|
ExplosionCreate( EyePosition(), GetAbsAngles(), this, 500, 256, (SF_ENVEXPLOSION_NOPARTICLES|SF_ENVEXPLOSION_NOSPARKS|SF_ENVEXPLOSION_NODLIGHTS|SF_ENVEXPLOSION_NODAMAGE|SF_ENVEXPLOSION_NOSMOKE), false );
|
|
|
|
// Create liquid fountain gushtacular effect here!
|
|
CEffectData data;
|
|
|
|
data.m_vOrigin = EyePosition();
|
|
data.m_vNormal = Vector( 0, 0, 1 );
|
|
data.m_flScale = 4.0f;
|
|
|
|
DispatchEffect( "StriderBlood", data );
|
|
|
|
// Go away
|
|
m_lifeState = LIFE_DEAD;
|
|
|
|
SetThink( &CNPC_Hunter::SUB_Remove );
|
|
SetNextThink( gpGlobals->curtime + 0.1f );
|
|
|
|
AddEffects( EF_NODRAW );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
Activity CNPC_Hunter::NPC_TranslateActivity( Activity baseAct )
|
|
{
|
|
if ( ( baseAct == ACT_WALK ) || ( baseAct == ACT_RUN ) )
|
|
{
|
|
if ( GetEnemy() )
|
|
{
|
|
Vector vecEnemyLKP = GetEnemyLKP();
|
|
|
|
// Only start facing when we're close enough
|
|
if ( UTIL_DistApprox( vecEnemyLKP, GetAbsOrigin() ) < HUNTER_FACE_ENEMY_DIST )
|
|
{
|
|
return (Activity)ACT_HUNTER_WALK_ANGRY;
|
|
}
|
|
}
|
|
}
|
|
else if ( ( baseAct == ACT_IDLE ) && m_bPlanted )
|
|
{
|
|
return ( Activity )ACT_HUNTER_IDLE_PLANTED;
|
|
}
|
|
else if ( baseAct == ACT_RANGE_ATTACK2 )
|
|
{
|
|
if ( !m_bPlanted && ( m_bEnableUnplantedShooting || IsStriderBuster( GetEnemy() ) ) )
|
|
{
|
|
return (Activity)ACT_HUNTER_RANGE_ATTACK2_UNPLANTED;
|
|
}
|
|
}
|
|
|
|
return BaseClass::NPC_TranslateActivity( baseAct );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::HandleAnimEvent( animevent_t *pEvent )
|
|
{
|
|
Vector footPosition;
|
|
QAngle angles;
|
|
|
|
if ( pEvent->event == AE_HUNTER_FOOTSTEP_LEFT )
|
|
{
|
|
LeftFootHit( pEvent->eventtime );
|
|
return;
|
|
}
|
|
|
|
if ( pEvent->event == AE_HUNTER_FOOTSTEP_RIGHT )
|
|
{
|
|
RightFootHit( pEvent->eventtime );
|
|
return;
|
|
}
|
|
|
|
if ( pEvent->event == AE_HUNTER_FOOTSTEP_BACK )
|
|
{
|
|
BackFootHit( pEvent->eventtime );
|
|
return;
|
|
}
|
|
|
|
if ( pEvent->event == AE_HUNTER_START_EXPRESSION )
|
|
{
|
|
if ( pEvent->options && Q_strlen( pEvent->options ) )
|
|
{
|
|
//m_iszCurrentExpression = AllocPooledString( pEvent->options );
|
|
//SetExpression( pEvent->options );
|
|
}
|
|
return;
|
|
}
|
|
|
|
if ( pEvent->event == AE_HUNTER_END_EXPRESSION )
|
|
{
|
|
if ( pEvent->options && Q_strlen( pEvent->options ) )
|
|
{
|
|
//m_iszCurrentExpression = NULL_STRING;
|
|
//RemoveActorFromScriptedScenes( this, true, false, pEvent->options );
|
|
}
|
|
return;
|
|
}
|
|
|
|
if ( pEvent->event == AE_HUNTER_MELEE_ANNOUNCE )
|
|
{
|
|
EmitSound( "NPC_Hunter.MeleeAnnounce" );
|
|
return;
|
|
}
|
|
|
|
if ( pEvent->event == AE_HUNTER_MELEE_ATTACK_LEFT )
|
|
{
|
|
Vector right, forward, dir;
|
|
AngleVectors( GetLocalAngles(), &forward, &right, NULL );
|
|
|
|
right = right * -100;
|
|
forward = forward * 600;
|
|
dir = right + forward;
|
|
QAngle angle( 25, 30, -20 );
|
|
|
|
MeleeAttack( HUNTER_MELEE_REACH, sk_hunter_dmg_one_slash.GetFloat(), angle, dir, HUNTER_BLOOD_LEFT_FOOT );
|
|
return;
|
|
}
|
|
|
|
if ( pEvent->event == AE_HUNTER_MELEE_ATTACK_RIGHT )
|
|
{
|
|
Vector right, forward,dir;
|
|
AngleVectors( GetLocalAngles(), &forward, &right, NULL );
|
|
|
|
right = right * 100;
|
|
forward = forward * 600;
|
|
dir = right + forward;
|
|
|
|
QAngle angle( 25, -30, 20 );
|
|
|
|
MeleeAttack( HUNTER_MELEE_REACH, sk_hunter_dmg_one_slash.GetFloat(), angle, dir, HUNTER_BLOOD_LEFT_FOOT );
|
|
return;
|
|
}
|
|
|
|
if ( pEvent->event == AE_HUNTER_SPRAY_BLOOD )
|
|
{
|
|
Vector vecOrigin;
|
|
Vector vecDir;
|
|
|
|
// spray blood from the attachment point
|
|
bool bGotAttachment = false;
|
|
if ( pEvent->options )
|
|
{
|
|
QAngle angDir;
|
|
if ( GetAttachment( pEvent->options, vecOrigin, angDir ) )
|
|
{
|
|
bGotAttachment = true;
|
|
AngleVectors( angDir, &vecDir, NULL, NULL );
|
|
}
|
|
}
|
|
|
|
// fall back to our center, tracing forward
|
|
if ( !bGotAttachment )
|
|
{
|
|
vecOrigin = WorldSpaceCenter();
|
|
GetVectors( &vecDir, NULL, NULL );
|
|
}
|
|
|
|
UTIL_BloodSpray( vecOrigin, vecDir, BLOOD_COLOR_RED, 4, FX_BLOODSPRAY_ALL );
|
|
|
|
for ( int i = 0 ; i < 3 ; i++ )
|
|
{
|
|
Vector vecTraceDir = vecDir;
|
|
vecTraceDir.x += random->RandomFloat( -0.1, 0.1 );
|
|
vecTraceDir.y += random->RandomFloat( -0.1, 0.1 );
|
|
vecTraceDir.z += random->RandomFloat( -0.1, 0.1 );
|
|
|
|
trace_t tr;
|
|
AI_TraceLine( vecOrigin, vecOrigin + ( vecTraceDir * 192.0f ), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
|
|
if ( tr.fraction != 1.0 )
|
|
{
|
|
UTIL_BloodDecalTrace( &tr, BLOOD_COLOR_RED );
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
BaseClass::HandleAnimEvent( pEvent );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::AddEntityRelationship( CBaseEntity *pEntity, Disposition_t nDisposition, int nPriority )
|
|
{
|
|
if ( nDisposition == D_HT && pEntity->ClassMatches("npc_bullseye") )
|
|
UpdateEnemyMemory( pEntity, pEntity->GetAbsOrigin() );
|
|
BaseClass::AddEntityRelationship( pEntity, nDisposition, nPriority );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::ScheduledMoveToGoalEntity( int scheduleType, CBaseEntity *pGoalEntity, Activity movementActivity )
|
|
{
|
|
if ( IsCurSchedule( SCHED_HUNTER_RANGE_ATTACK1, false ) )
|
|
{
|
|
SetGoalEnt( pGoalEntity );
|
|
return true;
|
|
}
|
|
return BaseClass::ScheduledMoveToGoalEntity( scheduleType, pGoalEntity, movementActivity );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::OnChangeHintGroup( string_t oldGroup, string_t newGroup )
|
|
{
|
|
SetCondition( COND_HUNTER_NEW_HINTGROUP );
|
|
m_CheckHintGroupTimer.Set( 10 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Tells whether any given hunter is in a squad that contains other hunters.
|
|
// This is useful for preventing timid behavior for Hunters that are not
|
|
// supported by other hunters.
|
|
//
|
|
// NOTE: This counts the self! So a hunter that is alone in his squad
|
|
// receives a result of 1.
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Hunter::NumHuntersInMySquad()
|
|
{
|
|
AISquadIter_t iter;
|
|
CAI_BaseNPC *pSquadmate = m_pSquad ? m_pSquad->GetFirstMember( &iter ) : NULL;
|
|
|
|
if( !pSquadmate )
|
|
{
|
|
// Not in a squad at all, but the caller is not concerned with that. Just
|
|
// tell them that we're in a squad of one (ourself)
|
|
return 1;
|
|
}
|
|
|
|
int count = 0;
|
|
|
|
while ( pSquadmate )
|
|
{
|
|
if( pSquadmate->m_iClassname == m_iClassname )
|
|
count++;
|
|
|
|
pSquadmate = m_pSquad->GetNextMember( &iter );
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::FollowStrider( const char *szStrider )
|
|
{
|
|
if ( !szStrider )
|
|
return;
|
|
|
|
CBaseEntity *pEnt = gEntList.FindEntityByName( NULL, szStrider, this );
|
|
CNPC_Strider *pStrider = dynamic_cast <CNPC_Strider *>( pEnt );
|
|
FollowStrider(pStrider);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::FollowStrider( CNPC_Strider * pStrider )
|
|
{
|
|
if ( !IsAlive() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( pStrider )
|
|
{
|
|
if ( m_EscortBehavior.GetFollowTarget() != pStrider )
|
|
{
|
|
m_iszFollowTarget = pStrider->GetEntityName();
|
|
if ( m_iszFollowTarget == NULL_STRING )
|
|
{
|
|
m_iszFollowTarget = AllocPooledString( "unnamed_strider" );
|
|
}
|
|
m_EscortBehavior.SetEscortTarget( pStrider );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DevWarning("Hunter set to follow entity %s that is not a strider\n", STRING( m_iszFollowTarget ) );
|
|
m_iszFollowTarget = AllocPooledString( "unknown_strider" );
|
|
}
|
|
}
|
|
|
|
void CAI_HunterEscortBehavior::SetEscortTarget( CNPC_Strider *pStrider, bool fFinishCurSchedule )
|
|
{
|
|
m_bEnabled = true;
|
|
|
|
if ( GetOuter()->GetSquad() )
|
|
{
|
|
GetOuter()->GetSquad()->RemoveFromSquad( GetOuter() );
|
|
}
|
|
|
|
for ( int i = 0; i < g_Hunters.Count(); i++ )
|
|
{
|
|
if ( g_Hunters[i]->m_EscortBehavior.GetFollowTarget() == pStrider )
|
|
{
|
|
Assert( g_Hunters[i]->GetSquad() );
|
|
g_Hunters[i]->GetSquad()->AddToSquad( GetOuter() );
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( !GetOuter()->GetSquad() )
|
|
{
|
|
GetOuter()->AddToSquad( AllocPooledString( CFmtStr( "%s_hunter_squad", STRING( pStrider->GetEntityName() ) ) ) );
|
|
}
|
|
|
|
BaseClass::SetFollowTarget( pStrider );
|
|
m_flTimeEscortReturn = gpGlobals->curtime;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::InputEnableUnplantedShooting( inputdata_t &inputdata )
|
|
{
|
|
m_bEnableUnplantedShooting = true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::InputDisableUnplantedShooting( inputdata_t &inputdata )
|
|
{
|
|
m_bEnableUnplantedShooting = false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::InputFollowStrider( inputdata_t &inputdata )
|
|
{
|
|
m_iszFollowTarget = inputdata.value.StringID();
|
|
if ( m_iszFollowTarget == s_iszStriderClassname )
|
|
{
|
|
m_EscortBehavior.m_bEnabled = true;
|
|
m_iszFollowTarget = NULL_STRING;
|
|
}
|
|
m_BeginFollowDelay.Start( .1 ); // Allow time for strider to spawn
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::InputUseSiegeTargets( inputdata_t &inputdata )
|
|
{
|
|
m_iszSiegeTargetName = inputdata.value.StringID();
|
|
m_flTimeNextSiegeTargetAttack = gpGlobals->curtime + random->RandomFloat( 1, hunter_siege_frequency.GetFloat() );
|
|
|
|
if( m_iszSiegeTargetName == NULL_STRING )
|
|
{
|
|
// Turning the feature off. Restore m_flDistTooFar to default.
|
|
m_flDistTooFar = hunter_flechette_max_range.GetFloat();
|
|
m_pSiegeTargets.RemoveAll();
|
|
}
|
|
else
|
|
{
|
|
// We're going into siege mode. Adjust range accordingly.
|
|
m_flDistTooFar = hunter_flechette_max_range.GetFloat() * HUNTER_SIEGE_MAX_DIST_MODIFIER;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::InputDodge( inputdata_t &inputdata )
|
|
{
|
|
SetCondition( COND_HUNTER_FORCED_DODGE );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::InputFlankEnemy( inputdata_t &inputdata )
|
|
{
|
|
SetCondition( COND_HUNTER_FORCED_FLANK_ENEMY );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::InputDisableShooting( inputdata_t &inputdata )
|
|
{
|
|
m_bDisableShooting = true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::InputEnableShooting( inputdata_t &inputdata )
|
|
{
|
|
m_bDisableShooting = false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::InputEnableSquadShootDelay( inputdata_t &inputdata )
|
|
{
|
|
m_bEnableSquadShootDelay = true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::InputDisableSquadShootDelay( inputdata_t &inputdata )
|
|
{
|
|
m_bEnableSquadShootDelay = false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::FVisible( CBaseEntity *pEntity, int traceMask, CBaseEntity **ppBlocker )
|
|
{
|
|
return BaseClass::FVisible( pEntity, traceMask, ppBlocker );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::IsValidEnemy( CBaseEntity *pTarget )
|
|
{
|
|
if ( IsStriderBuster( pTarget) )
|
|
{
|
|
if ( !m_EscortBehavior.m_bEnabled || !m_EscortBehavior.GetEscortTarget() )
|
|
{
|
|
// We only hate striderbusters when we are actively protecting a strider.
|
|
return false;
|
|
}
|
|
|
|
if ( pTarget->VPhysicsGetObject() )
|
|
{
|
|
if ( ( pTarget->VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_PLAYER_HELD ) &&
|
|
hunter_hate_held_striderbusters.GetBool() )
|
|
{
|
|
if ( gpGlobals->curtime - StriderBuster_GetPickupTime( pTarget ) > hunter_hate_held_striderbusters_delay.GetFloat())
|
|
{
|
|
if ( StriderBuster_NumFlechettesAttached( pTarget ) <= 2 )
|
|
{
|
|
if ( m_EscortBehavior.GetEscortTarget() &&
|
|
( m_EscortBehavior.GetEscortTarget()->GetAbsOrigin().AsVector2D() - pTarget->GetAbsOrigin().AsVector2D() ).LengthSqr() < Square( hunter_hate_held_striderbusters_tolerance.GetFloat() ) )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool bThrown = ( pTarget->VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_WAS_THROWN ) != 0;
|
|
bool bAttached = StriderBuster_IsAttachedStriderBuster( pTarget );
|
|
|
|
if ( ( bThrown && !bAttached ) && hunter_hate_thrown_striderbusters.GetBool() )
|
|
{
|
|
float t;
|
|
float dist = CalcDistanceSqrToLineSegment2D( m_EscortBehavior.GetEscortTarget()->GetAbsOrigin().AsVector2D(),
|
|
pTarget->GetAbsOrigin().AsVector2D(),
|
|
pTarget->GetAbsOrigin().AsVector2D() + pTarget->GetSmoothedVelocity().AsVector2D(), &t );
|
|
|
|
if ( t > 0 && dist < Square( hunter_hate_thrown_striderbusters_tolerance.GetFloat() ))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if ( bAttached && StriderBuster_IsAttachedStriderBuster( pTarget, m_EscortBehavior.GetEscortTarget() ) && hunter_hate_attached_striderbusters.GetBool() )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
return BaseClass::IsValidEnemy( pTarget );
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
Disposition_t CNPC_Hunter::IRelationType( CBaseEntity *pTarget )
|
|
{
|
|
if ( !pTarget )
|
|
return D_NU;
|
|
|
|
if ( IsStriderBuster( pTarget ) )
|
|
{
|
|
if ( HateThisStriderBuster( pTarget ) )
|
|
return D_HT;
|
|
|
|
return D_NU;
|
|
}
|
|
|
|
if ( hunter_retreat_striderbusters.GetBool() )
|
|
{
|
|
if ( pTarget->IsPlayer() && (m_hAttachedBusters.Count() > 0) )
|
|
{
|
|
return D_FR;
|
|
}
|
|
}
|
|
|
|
return BaseClass::IRelationType( pTarget );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Hunter::IRelationPriority( CBaseEntity *pTarget )
|
|
{
|
|
if ( IsStriderBuster( pTarget ) )
|
|
{
|
|
// If we're here, we already know that we hate striderbusters.
|
|
return 1000.0f;
|
|
}
|
|
|
|
return BaseClass::IRelationPriority( pTarget );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::SetSquad( CAI_Squad *pSquad )
|
|
{
|
|
BaseClass::SetSquad( pSquad );
|
|
if ( pSquad && pSquad->NumMembers() == 1 )
|
|
{
|
|
pSquad->SetSquadData( HUNTER_RUNDOWN_SQUADDATA, 0 );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::OnSeeEntity( CBaseEntity *pEntity )
|
|
{
|
|
BaseClass::OnSeeEntity(pEntity);
|
|
|
|
if ( IsStriderBuster( pEntity ) && IsValidEnemy( pEntity ) )
|
|
{
|
|
SetCondition( COND_HUNTER_SEE_STRIDERBUSTER );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::UpdateEnemyMemory( CBaseEntity *pEnemy, const Vector &position, CBaseEntity *pInformer )
|
|
{
|
|
//EmitSound( "NPC_Hunter.Alert" );
|
|
return BaseClass::UpdateEnemyMemory( pEnemy, position, pInformer );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::CanPlantHere( const Vector &vecPos )
|
|
{
|
|
// TODO: cache results?
|
|
//if ( vecPos == m_vecLastCanPlantHerePos )
|
|
//{
|
|
// return m_bLastCanPlantHere;
|
|
//}
|
|
|
|
Vector vecMins = GetHullMins();
|
|
Vector vecMaxs = GetHullMaxs();
|
|
|
|
vecMins.x -= 16;
|
|
vecMins.y -= 16;
|
|
|
|
vecMaxs.x += 16;
|
|
vecMaxs.y += 16;
|
|
vecMaxs.z -= hunter_plant_adjust_z.GetInt();
|
|
|
|
bool bResult = false;
|
|
|
|
trace_t tr;
|
|
UTIL_TraceHull( vecPos, vecPos, vecMins, vecMaxs, MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );
|
|
if ( tr.startsolid )
|
|
{
|
|
// Try again, tracing down from above.
|
|
Vector vecStart = vecPos;
|
|
vecStart.z += hunter_plant_adjust_z.GetInt();
|
|
|
|
UTIL_TraceHull( vecStart, vecPos, vecMins, vecMaxs, MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );
|
|
}
|
|
|
|
if ( tr.startsolid )
|
|
{
|
|
//NDebugOverlay::Box( vecPos, vecMins, vecMaxs, 255, 0, 0, 0, 0 );
|
|
}
|
|
else
|
|
{
|
|
//NDebugOverlay::Box( vecPos, vecMins, vecMaxs, 0, 255, 0, 0, 0 );
|
|
bResult = true;
|
|
}
|
|
|
|
// Cache the results in case we ask again for the same spot.
|
|
//m_vecLastCanPlantHerePos = vecPos;
|
|
//m_bLastCanPlantHere = bResult;
|
|
|
|
return bResult;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Hunter::MeleeAttack1ConditionsVsEnemyInVehicle( CBaseCombatCharacter *pEnemy, float flDot )
|
|
{
|
|
if( !IsCorporealEnemy( GetEnemy() ) )
|
|
return COND_NONE;
|
|
|
|
// Try and trace a box to the player, and if I hit the vehicle, attack it
|
|
Vector vecDelta = (pEnemy->WorldSpaceCenter() - WorldSpaceCenter());
|
|
VectorNormalize( vecDelta );
|
|
trace_t tr;
|
|
AI_TraceHull( WorldSpaceCenter(), WorldSpaceCenter() + (vecDelta * 64), -Vector(8,8,8), Vector(8,8,8), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
|
|
if ( tr.fraction != 1.0 && tr.m_pEnt == pEnemy->GetVehicleEntity() )
|
|
{
|
|
// We're near the vehicle. Are we facing it?
|
|
if (flDot < 0.7)
|
|
return COND_NOT_FACING_ATTACK;
|
|
|
|
return COND_CAN_MELEE_ATTACK1;
|
|
}
|
|
|
|
return COND_TOO_FAR_TO_ATTACK;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// For innate melee attack
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Hunter::MeleeAttack1Conditions ( float flDot, float flDist )
|
|
{
|
|
if ( !IsCorporealEnemy( GetEnemy() ) )
|
|
return COND_NONE;
|
|
|
|
if ( ( gpGlobals->curtime < m_flNextMeleeTime ) && // allow berzerk bashing if cornered
|
|
!( m_hAttachedBusters.Count() > 0 && gpGlobals->curtime < m_fCorneredTimer ) )
|
|
{
|
|
return COND_NONE;
|
|
}
|
|
|
|
if ( GetEnemy()->Classify() == CLASS_PLAYER_ALLY_VITAL )
|
|
{
|
|
return COND_NONE;
|
|
}
|
|
|
|
if ( flDist > HUNTER_MELEE_REACH )
|
|
{
|
|
// Translate a hit vehicle into its passenger if found
|
|
if ( GetEnemy() != NULL )
|
|
{
|
|
CBaseCombatCharacter *pCCEnemy = GetEnemy()->MyCombatCharacterPointer();
|
|
if ( pCCEnemy != NULL && pCCEnemy->IsInAVehicle() )
|
|
{
|
|
return MeleeAttack1ConditionsVsEnemyInVehicle( pCCEnemy, flDot );
|
|
}
|
|
|
|
#if defined(HL2_DLL) && !defined(HL2MP)
|
|
// If the player is holding an object, knock it down.
|
|
if ( GetEnemy()->IsPlayer() )
|
|
{
|
|
CBasePlayer *pPlayer = ToBasePlayer( GetEnemy() );
|
|
|
|
Assert( pPlayer != NULL );
|
|
|
|
// Is the player carrying something?
|
|
CBaseEntity *pObject = GetPlayerHeldEntity(pPlayer);
|
|
|
|
if ( !pObject )
|
|
{
|
|
pObject = PhysCannonGetHeldEntity( pPlayer->GetActiveWeapon() );
|
|
}
|
|
|
|
if ( pObject )
|
|
{
|
|
float flDist = pObject->WorldSpaceCenter().DistTo( WorldSpaceCenter() );
|
|
|
|
if ( flDist <= HUNTER_MELEE_REACH )
|
|
{
|
|
return COND_CAN_MELEE_ATTACK1;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
return COND_TOO_FAR_TO_ATTACK;
|
|
}
|
|
|
|
if (flDot < 0.7)
|
|
{
|
|
return COND_NOT_FACING_ATTACK;
|
|
}
|
|
|
|
// Build a cube-shaped hull, the same hull that MeleeAttack is going to use.
|
|
Vector vecMins = GetHullMins();
|
|
Vector vecMaxs = GetHullMaxs();
|
|
vecMins.z = vecMins.x;
|
|
vecMaxs.z = vecMaxs.x;
|
|
|
|
Vector forward;
|
|
GetVectors( &forward, NULL, NULL );
|
|
|
|
trace_t tr;
|
|
AI_TraceHull( WorldSpaceCenter(), WorldSpaceCenter() + forward * HUNTER_MELEE_REACH, vecMins, vecMaxs, MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );
|
|
|
|
if ( tr.fraction == 1.0 || !tr.m_pEnt )
|
|
{
|
|
// This attack would miss completely. Trick the hunter into moving around some more.
|
|
return COND_TOO_FAR_TO_ATTACK;
|
|
}
|
|
|
|
if ( tr.m_pEnt == GetEnemy() || tr.m_pEnt->IsNPC() || (tr.m_pEnt->m_takedamage == DAMAGE_YES && (dynamic_cast<CBreakableProp*>(tr.m_pEnt))) )
|
|
{
|
|
// Let the hunter swipe at his enemy if he's going to hit them.
|
|
// Also let him swipe at NPC's that happen to be between the hunter and the enemy.
|
|
// This makes mobs of hunters seem more rowdy since it doesn't leave guys in the back row standing around.
|
|
// Also let him swipe at things that takedamage, under the assumptions that they can be broken.
|
|
return COND_CAN_MELEE_ATTACK1;
|
|
}
|
|
|
|
// dvs TODO: incorporate this
|
|
/*if ( tr.m_pEnt->IsBSPModel() )
|
|
{
|
|
// The trace hit something solid, but it's not the enemy. If this item is closer to the hunter than
|
|
// the enemy is, treat this as an obstruction.
|
|
Vector vecToEnemy = GetEnemy()->WorldSpaceCenter() - WorldSpaceCenter();
|
|
Vector vecTrace = tr.endpos - tr.startpos;
|
|
|
|
if ( vecTrace.Length2DSqr() < vecToEnemy.Length2DSqr() )
|
|
{
|
|
return COND_HUNTER_LOCAL_MELEE_OBSTRUCTION;
|
|
}
|
|
}*/
|
|
|
|
if ( !tr.m_pEnt->IsWorld() && GetEnemy() && GetEnemy()->GetGroundEntity() == tr.m_pEnt )
|
|
{
|
|
// Try to swat whatever the player is standing on instead of acting like a dill.
|
|
return COND_CAN_MELEE_ATTACK1;
|
|
}
|
|
|
|
// Move around some more
|
|
return COND_TOO_FAR_TO_ATTACK;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// For innate melee attack
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Hunter::MeleeAttack2Conditions ( float flDot, float flDist )
|
|
{
|
|
return COND_NONE;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::IsCorporealEnemy( CBaseEntity *pEnemy )
|
|
{
|
|
if( !pEnemy )
|
|
return false;
|
|
|
|
// Generally speaking, don't melee attack anything the player can't see.
|
|
if( pEnemy->IsEffectActive( EF_NODRAW ) )
|
|
return false;
|
|
|
|
// Don't flank, melee attack striderbusters.
|
|
if ( IsStriderBuster( pEnemy ) )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Hunter::RangeAttack1Conditions( float flDot, float flDist )
|
|
{
|
|
return COND_NONE;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Hunter::RangeAttack2Conditions( float flDot, float flDist )
|
|
{
|
|
bool bIsBuster = IsStriderBuster( GetEnemy() );
|
|
bool bIsPerfectBullseye = ( GetEnemy() && dynamic_cast<CNPC_Bullseye *>(GetEnemy()) && ((CNPC_Bullseye *)GetEnemy())->UsePerfectAccuracy() );
|
|
|
|
if ( !bIsPerfectBullseye && !bIsBuster && !hunter_flechette_test.GetBool() && ( gpGlobals->curtime < m_flNextRangeAttack2Time ) )
|
|
{
|
|
return COND_NONE;
|
|
}
|
|
|
|
if ( m_bDisableShooting )
|
|
{
|
|
return COND_NONE;
|
|
}
|
|
|
|
if ( !HasCondition( COND_SEE_ENEMY ) )
|
|
{
|
|
return COND_NONE;
|
|
}
|
|
|
|
float flMaxFlechetteRange = hunter_flechette_max_range.GetFloat();
|
|
|
|
if ( IsUsingSiegeTargets() )
|
|
{
|
|
flMaxFlechetteRange *= HUNTER_SIEGE_MAX_DIST_MODIFIER;
|
|
}
|
|
|
|
if ( !bIsBuster && ( flDist > flMaxFlechetteRange ) )
|
|
{
|
|
return COND_TOO_FAR_TO_ATTACK;
|
|
}
|
|
else if ( !bIsBuster && ( !GetEnemy() || !GetEnemy()->ClassMatches( "npc_bullseye" ) ) && flDist < hunter_flechette_min_range.GetFloat() )
|
|
{
|
|
return COND_TOO_CLOSE_TO_ATTACK;
|
|
}
|
|
else if ( flDot < HUNTER_FACING_DOT )
|
|
{
|
|
return COND_NOT_FACING_ATTACK;
|
|
}
|
|
|
|
if ( !bIsBuster && !m_bEnableUnplantedShooting && !hunter_flechette_test.GetBool() && !CanPlantHere( GetAbsOrigin() ) )
|
|
{
|
|
return COND_HUNTER_CANT_PLANT;
|
|
}
|
|
|
|
return COND_CAN_RANGE_ATTACK2;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::WeaponLOSCondition(const Vector &ownerPos, const Vector &targetPos, bool bSetConditions)
|
|
{
|
|
CBaseEntity *pTargetEnt;
|
|
|
|
pTargetEnt = GetEnemy();
|
|
|
|
trace_t tr;
|
|
Vector vFrom = ownerPos + GetViewOffset();
|
|
AI_TraceLine( vFrom, targetPos, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
|
|
|
|
if ( ( pTargetEnt && tr.m_pEnt == pTargetEnt) || tr.fraction == 1.0 || CanShootThrough( tr, targetPos ) )
|
|
{
|
|
static Vector vMins( -2.0, -2.0, -2.0 );
|
|
static Vector vMaxs( -vMins);
|
|
// Hit the enemy, or hit nothing (traced all the way to a nonsolid enemy like a bullseye)
|
|
AI_TraceHull( vFrom - Vector( 0, 0, 18 ), targetPos, vMins, vMaxs, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);
|
|
|
|
if ( ( pTargetEnt && tr.m_pEnt == pTargetEnt) || tr.fraction == 1.0 || CanShootThrough( tr, targetPos ) )
|
|
{
|
|
if ( hunter_show_weapon_los_condition.GetBool() )
|
|
{
|
|
NDebugOverlay::Line( vFrom, targetPos, 255, 0, 255, false, 0.1 );
|
|
NDebugOverlay::Line( vFrom - Vector( 0, 0, 18 ), targetPos, 0, 0, 255, false, 0.1 );
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
else if ( bSetConditions )
|
|
{
|
|
SetCondition( COND_WEAPON_SIGHT_OCCLUDED );
|
|
SetEnemyOccluder( tr.m_pEnt );
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Look in front and see if the claw hit anything.
|
|
//
|
|
// Input : flDist distance to trace
|
|
// iDamage damage to do if attack hits
|
|
// vecViewPunch camera punch (if attack hits player)
|
|
// vecVelocityPunch velocity punch (if attack hits player)
|
|
//
|
|
// Output : The entity hit by claws. NULL if nothing.
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CNPC_Hunter::MeleeAttack( float flDist, int iDamage, QAngle &qaViewPunch, Vector &vecVelocityPunch, int BloodOrigin )
|
|
{
|
|
// Added test because claw attack anim sometimes used when for cases other than melee
|
|
if ( GetEnemy() )
|
|
{
|
|
trace_t tr;
|
|
AI_TraceHull( WorldSpaceCenter(), GetEnemy()->WorldSpaceCenter(), -Vector(8,8,8), Vector(8,8,8), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
|
|
|
|
if ( tr.fraction < 1.0f )
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// Trace out a cubic section of our hull and see what we hit.
|
|
//
|
|
Vector vecMins = GetHullMins();
|
|
Vector vecMaxs = GetHullMaxs();
|
|
vecMins.z = vecMins.x;
|
|
vecMaxs.z = vecMaxs.x;
|
|
|
|
CBaseEntity *pHurt = CheckTraceHullAttack( flDist, vecMins, vecMaxs, iDamage, DMG_SLASH );
|
|
|
|
if ( pHurt )
|
|
{
|
|
EmitSound( "NPC_Hunter.MeleeHit" );
|
|
EmitSound( "NPC_Hunter.TackleHit" );
|
|
|
|
CBasePlayer *pPlayer = ToBasePlayer( pHurt );
|
|
|
|
if ( pPlayer != NULL && !(pPlayer->GetFlags() & FL_GODMODE ) )
|
|
{
|
|
pPlayer->ViewPunch( qaViewPunch );
|
|
pPlayer->VelocityPunch( vecVelocityPunch );
|
|
|
|
// Shake the screen
|
|
UTIL_ScreenShake( pPlayer->GetAbsOrigin(), 100.0, 1.5, 1.0, 2, SHAKE_START );
|
|
|
|
// Red damage indicator
|
|
color32 red = { 128, 0, 0, 128 };
|
|
UTIL_ScreenFade( pPlayer, red, 1.0f, 0.1f, FFADE_IN );
|
|
|
|
/*if ( UTIL_ShouldShowBlood( pPlayer->BloodColor() ) )
|
|
{
|
|
// Spray some of the player's blood on the hunter.
|
|
trace_t tr;
|
|
|
|
Vector vecHunterEyePos; // = EyePosition();
|
|
QAngle angDiscard;
|
|
GetBonePosition( LookupBone( "MiniStrider.top_eye_bone" ), vecHunterEyePos, angDiscard );
|
|
|
|
Vector vecPlayerEyePos = pPlayer->EyePosition();
|
|
|
|
Vector vecDir = vecHunterEyePos - vecPlayerEyePos;
|
|
float flLen = VectorNormalize( vecDir );
|
|
|
|
Vector vecStart = vecPlayerEyePos - ( vecDir * 64 );
|
|
Vector vecEnd = vecPlayerEyePos + ( vecDir * ( flLen + 64 ) );
|
|
|
|
NDebugOverlay::HorzArrow( vecStart, vecEnd, 16, 255, 255, 0, 255, false, 10 );
|
|
|
|
UTIL_TraceLine( vecStart, vecEnd, MASK_SHOT, pPlayer, COLLISION_GROUP_NONE, &tr );
|
|
|
|
if ( tr.m_pEnt )
|
|
{
|
|
Msg( "Hit %s!!!\n", tr.m_pEnt->GetDebugName() );
|
|
UTIL_DecalTrace( &tr, "Blood" );
|
|
}
|
|
}*/
|
|
}
|
|
else if ( !pPlayer )
|
|
{
|
|
if ( IsMovablePhysicsObject( pHurt ) )
|
|
{
|
|
// If it's a vphysics object that's too heavy, crash into it too.
|
|
IPhysicsObject *pPhysics = pHurt->VPhysicsGetObject();
|
|
if ( pPhysics )
|
|
{
|
|
// If the object is being held by the player, break it or make them drop it.
|
|
if ( pPhysics->GetGameFlags() & FVPHYSICS_PLAYER_HELD )
|
|
{
|
|
// If it's breakable, break it.
|
|
if ( pHurt->m_takedamage == DAMAGE_YES )
|
|
{
|
|
CBreakableProp *pBreak = dynamic_cast<CBreakableProp*>(pHurt);
|
|
if ( pBreak )
|
|
{
|
|
CTakeDamageInfo info( this, this, 20, DMG_SLASH );
|
|
pBreak->Break( this, info );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( UTIL_ShouldShowBlood(pHurt->BloodColor()) )
|
|
{
|
|
// Hit an NPC. Bleed them!
|
|
Vector vecBloodPos;
|
|
|
|
switch ( BloodOrigin )
|
|
{
|
|
case HUNTER_BLOOD_LEFT_FOOT:
|
|
{
|
|
if ( GetAttachment( "blood_left", vecBloodPos ) )
|
|
{
|
|
SpawnBlood( vecBloodPos, g_vecAttackDir, pHurt->BloodColor(), MIN( iDamage, 30 ) );
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// TODO:
|
|
//AttackMissSound();
|
|
}
|
|
|
|
m_flNextMeleeTime = gpGlobals->curtime + hunter_melee_delay.GetFloat();
|
|
|
|
return pHurt;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::TestShootPosition(const Vector &vecShootPos, const Vector &targetPos )
|
|
{
|
|
if ( !CanPlantHere(vecShootPos ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return BaseClass::TestShootPosition( vecShootPos, targetPos );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
Vector CNPC_Hunter::Weapon_ShootPosition( )
|
|
{
|
|
matrix3x4_t gunMatrix;
|
|
GetAttachment( gm_nTopGunAttachment, gunMatrix );
|
|
|
|
Vector vecShootPos;
|
|
MatrixGetColumn( gunMatrix, 3, vecShootPos );
|
|
|
|
return vecShootPos;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType )
|
|
{
|
|
float flTracerDist;
|
|
Vector vecDir;
|
|
Vector vecEndPos;
|
|
|
|
vecDir = tr.endpos - vecTracerSrc;
|
|
|
|
flTracerDist = VectorNormalize( vecDir );
|
|
|
|
int nAttachment = LookupAttachment( "MiniGun" );
|
|
|
|
UTIL_Tracer( vecTracerSrc, tr.endpos, nAttachment, TRACER_FLAG_USEATTACHMENT, 5000, true, "HunterTracer" );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Trace didn't hit the intended target, but should the hunter
|
|
// shoot anyway? We use this to get the hunter to destroy
|
|
// breakables that are between him and his target.
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::CanShootThrough( const trace_t &tr, const Vector &vecTarget )
|
|
{
|
|
if ( !tr.m_pEnt )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( !tr.m_pEnt->GetHealth() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Don't try to shoot through allies.
|
|
CAI_BaseNPC *pNPC = tr.m_pEnt->MyNPCPointer();
|
|
if ( pNPC && ( IRelationType( pNPC ) == D_LI ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Would a trace ignoring this entity continue to the target?
|
|
trace_t continuedTrace;
|
|
AI_TraceLine( tr.endpos, vecTarget, MASK_SHOT, tr.m_pEnt, COLLISION_GROUP_NONE, &continuedTrace );
|
|
|
|
if ( continuedTrace.fraction != 1.0 )
|
|
{
|
|
if ( continuedTrace.m_pEnt != GetEnemy() )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Hunter::GetSoundInterests()
|
|
{
|
|
return SOUND_WORLD | SOUND_COMBAT | SOUND_PLAYER | SOUND_DANGER | SOUND_PHYSICS_DANGER | SOUND_PLAYER_VEHICLE | SOUND_BULLET_IMPACT | SOUND_MOVE_AWAY;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Tells us whether the Hunter is acting in a large, outdoor map,
|
|
// currently only ep2_outland_12. This allows us to create logic
|
|
// branches here in the AI code so that we can make choices that
|
|
// tailor behavior to larger and smaller maps.
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::IsInLargeOutdoorMap()
|
|
{
|
|
return m_bInLargeOutdoorMap;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::AlertSound()
|
|
{
|
|
EmitSound( "NPC_Hunter.Alert" );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::PainSound( const CTakeDamageInfo &info )
|
|
{
|
|
if ( gpGlobals->curtime > m_flNextDamageTime )
|
|
{
|
|
EmitSound( "NPC_Hunter.Pain" );
|
|
m_flNextDamageTime = gpGlobals->curtime + random->RandomFloat( 0.5, 1.2 );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::DeathSound( const CTakeDamageInfo &info )
|
|
{
|
|
EmitSound( "NPC_Hunter.Death" );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::TraceAttack( const CTakeDamageInfo &inputInfo, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
|
|
{
|
|
CTakeDamageInfo info = inputInfo;
|
|
|
|
// Even though the damage might not hurt us, we want to react to it
|
|
// if it's from the player.
|
|
if ( info.GetAttacker()->IsPlayer() )
|
|
{
|
|
if ( !HasMemory( bits_MEMORY_PROVOKED ) )
|
|
{
|
|
GetEnemies()->ClearMemory( info.GetAttacker() );
|
|
Remember( bits_MEMORY_PROVOKED );
|
|
SetCondition( COND_LIGHT_DAMAGE );
|
|
}
|
|
}
|
|
|
|
// HUnters have special resisitance to some types of damage.
|
|
if ( ( info.GetDamageType() & DMG_BULLET ) ||
|
|
( info.GetDamageType() & DMG_BUCKSHOT ) ||
|
|
( info.GetDamageType() & DMG_CLUB ) ||
|
|
( info.GetDamageType() & DMG_NEVERGIB ) )
|
|
{
|
|
float flScale = 1.0;
|
|
|
|
if ( info.GetDamageType() & DMG_BUCKSHOT )
|
|
{
|
|
flScale = sk_hunter_buckshot_damage_scale.GetFloat();
|
|
}
|
|
else if ( ( info.GetDamageType() & DMG_BULLET ) || ( info.GetDamageType() & DMG_NEVERGIB ) )
|
|
{
|
|
// Hunters resist most bullet damage, but they are actually vulnerable to .357 rounds,
|
|
// since players regard that weapon as one of the game's truly powerful weapons.
|
|
if( info.GetAmmoType() == GetAmmoDef()->Index("357") )
|
|
{
|
|
flScale = 1.16f;
|
|
}
|
|
else
|
|
{
|
|
flScale = sk_hunter_bullet_damage_scale.GetFloat();
|
|
}
|
|
}
|
|
|
|
if ( GetActivity() == ACT_HUNTER_CHARGE_RUN )
|
|
{
|
|
flScale *= sk_hunter_charge_damage_scale.GetFloat();
|
|
}
|
|
|
|
if ( flScale != 0 )
|
|
{
|
|
float flDamage = info.GetDamage() * flScale;
|
|
info.SetDamage( flDamage );
|
|
}
|
|
|
|
QAngle vecAngles;
|
|
VectorAngles( ptr->plane.normal, vecAngles );
|
|
DispatchParticleEffect( "blood_impact_synth_01", ptr->endpos, vecAngles );
|
|
DispatchParticleEffect( "blood_impact_synth_01_arc_parent", PATTACH_POINT_FOLLOW, this, gm_nHeadCenterAttachment );
|
|
}
|
|
|
|
BaseClass::TraceAttack( info, vecDir, ptr, pAccumulator );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
const impactdamagetable_t &CNPC_Hunter::GetPhysicsImpactDamageTable()
|
|
{
|
|
return s_HunterImpactDamageTable;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::PhysicsDamageEffect( const Vector &vecPos, const Vector &vecDir )
|
|
{
|
|
CEffectData data;
|
|
data.m_vOrigin = vecPos;
|
|
data.m_vNormal = vecDir;
|
|
DispatchEffect( "HunterDamage", data );
|
|
|
|
if ( random->RandomInt( 0, 1 ) == 0 )
|
|
{
|
|
CBaseEntity *pTrail = CreateEntityByName( "sparktrail" );
|
|
pTrail->SetOwnerEntity( this );
|
|
pTrail->Spawn();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// We were hit by a strider buster. Do the tesla effect on our hitboxes.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::TeslaThink()
|
|
{
|
|
CEffectData data;
|
|
data.m_nEntIndex = entindex();
|
|
data.m_flMagnitude = 3;
|
|
data.m_flScale = 0.5f;
|
|
DispatchEffect( "TeslaHitboxes", data );
|
|
EmitSound( "RagdollBoogie.Zap" );
|
|
|
|
if ( gpGlobals->curtime < m_flTeslaStopTime )
|
|
{
|
|
SetContextThink( &CNPC_Hunter::TeslaThink, gpGlobals->curtime + random->RandomFloat( 0.1f, 0.3f ), HUNTER_ZAP_THINK );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Our health is low. Show damage effects.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::BleedThink()
|
|
{
|
|
// Spurt blood from random points on the hunter's head.
|
|
Vector vecOrigin;
|
|
QAngle angDir;
|
|
GetAttachment( gm_nHeadCenterAttachment, vecOrigin, angDir );
|
|
|
|
Vector vecDir = RandomVector( -1, 1 );
|
|
VectorNormalize( vecDir );
|
|
VectorAngles( vecDir, Vector( 0, 0, 1 ), angDir );
|
|
|
|
vecDir *= gm_flHeadRadius;
|
|
DispatchParticleEffect( "blood_spurt_synth_01", vecOrigin + vecDir, angDir );
|
|
|
|
SetNextThink( gpGlobals->curtime + random->RandomFloat( 0.6, 1.5 ), HUNTER_BLEED_THINK );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::IsHeavyDamage( const CTakeDamageInfo &info )
|
|
{
|
|
if ( info.GetDamage() < 45 )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( info.GetDamage() < 180 )
|
|
{
|
|
if ( !m_HeavyDamageDelay.Expired() || !BaseClass::IsHeavyDamage( info ) )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
m_HeavyDamageDelay.Set( 15, 25 );
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// We've taken some damage. Maybe we should flinch because of it.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::ConsiderFlinching( const CTakeDamageInfo &info )
|
|
{
|
|
if ( !m_FlinchTimer.Expired() )
|
|
{
|
|
// Someone is whaling on us. Push out the timer so we don't keep flinching.
|
|
m_FlinchTimer.Set( random->RandomFloat( 0.3 ) );
|
|
return;
|
|
}
|
|
|
|
if ( GetState() == NPC_STATE_SCRIPT )
|
|
{
|
|
return;
|
|
}
|
|
|
|
Activity eGesture = ACT_HUNTER_FLINCH_N;
|
|
|
|
Vector forward;
|
|
GetVectors( &forward, NULL, NULL );
|
|
|
|
Vector vecForceDir = info.GetDamageForce();
|
|
VectorNormalize( vecForceDir );
|
|
|
|
float flDot = DotProduct( forward, vecForceDir );
|
|
|
|
if ( flDot > 0.707 )
|
|
{
|
|
// flinch forward
|
|
eGesture = ACT_HUNTER_FLINCH_N;
|
|
}
|
|
else if ( flDot < -0.707 )
|
|
{
|
|
// flinch back
|
|
eGesture = ACT_HUNTER_FLINCH_S;
|
|
}
|
|
else
|
|
{
|
|
// flinch left or right
|
|
Vector cross = CrossProduct( forward, vecForceDir );
|
|
|
|
if ( cross.z > 0 )
|
|
{
|
|
eGesture = ACT_HUNTER_FLINCH_W;
|
|
}
|
|
else
|
|
{
|
|
eGesture = ACT_HUNTER_FLINCH_E;
|
|
}
|
|
}
|
|
|
|
if ( !IsPlayingGesture( eGesture ) )
|
|
{
|
|
RestartGesture( eGesture );
|
|
m_FlinchTimer.Set( random->RandomFloat( 0.3, 1.0 ) );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// This is done from a think function because when the hunter is killed,
|
|
// the physics code puts the vehicle's pre-collision velocity back so the jostle
|
|
// is basically discared.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::JostleVehicleThink()
|
|
{
|
|
CBaseEntity *pInflictor = m_hHitByVehicle;
|
|
if ( !pInflictor )
|
|
return;
|
|
|
|
Vector vecVelDir = pInflictor->GetSmoothedVelocity();
|
|
float flSpeed = VectorNormalize( vecVelDir );
|
|
Vector vecForce = CrossProduct( vecVelDir, Vector( 0, 0, 1 ) );
|
|
if ( DotProduct( vecForce, GetAbsOrigin() ) < DotProduct( vecForce, pInflictor->GetAbsOrigin() ) )
|
|
{
|
|
// We're to the left of the vehicle that's hitting us.
|
|
vecForce *= -1;
|
|
}
|
|
|
|
VectorNormalize( vecForce );
|
|
vecForce.z = 1.0;
|
|
|
|
float flForceScale = RemapValClamped( flSpeed, hunter_jostle_car_min_speed.GetFloat(), hunter_jostle_car_max_speed.GetFloat(), 50.0f, 150.0f );
|
|
|
|
vecForce *= ( flForceScale * pInflictor->VPhysicsGetObject()->GetMass() );
|
|
|
|
pInflictor->VPhysicsGetObject()->ApplyForceOffset( vecForce, WorldSpaceCenter() );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Hunter::OnTakeDamage( const CTakeDamageInfo &info )
|
|
{
|
|
CTakeDamageInfo myInfo = info;
|
|
|
|
if ( ( info.GetDamageType() & DMG_CRUSH ) && !( info.GetDamageType() & DMG_VEHICLE ) )
|
|
{
|
|
// Don't take damage from physics objects that weren't thrown by the player.
|
|
CBaseEntity *pInflictor = info.GetInflictor();
|
|
|
|
IPhysicsObject *pObj = pInflictor->VPhysicsGetObject();
|
|
//Assert( pObj );
|
|
|
|
if ( !pObj || !pInflictor->HasPhysicsAttacker( 4.0 ) )
|
|
{
|
|
myInfo.SetDamage( 0 );
|
|
}
|
|
else
|
|
{
|
|
// Physics objects that have flechettes stuck in them spoof
|
|
// a flechette hitting us so we dissolve when killed and award
|
|
// the achievement of killing a hunter with its flechettes.
|
|
CUtlVector<CBaseEntity *> children;
|
|
GetAllChildren( pInflictor, children );
|
|
for (int i = 0; i < children.Count(); i++ )
|
|
{
|
|
CBaseEntity *pent = children.Element( i );
|
|
if ( dynamic_cast<CHunterFlechette *>( pent ) )
|
|
{
|
|
myInfo.SetInflictor( pent );
|
|
myInfo.SetDamageType( myInfo.GetDamageType() | DMG_DISSOLVE );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return BaseClass::OnTakeDamage( myInfo );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Hunter::OnTakeDamage_Alive( const CTakeDamageInfo &info )
|
|
{
|
|
CTakeDamageInfo myInfo = info;
|
|
|
|
// don't take damage from my own weapons!!!
|
|
// Exception: I "own" a magnade if it's glued to me.
|
|
CBaseEntity *pInflictor = info.GetInflictor();
|
|
CBaseEntity *pAttacker = info.GetAttacker();
|
|
if ( pInflictor )
|
|
{
|
|
if ( IsStriderBuster( pInflictor ) )
|
|
{
|
|
// Get a tesla effect on our hitboxes for a little while.
|
|
SetContextThink( &CNPC_Hunter::TeslaThink, gpGlobals->curtime, HUNTER_ZAP_THINK );
|
|
m_flTeslaStopTime = gpGlobals->curtime + 2.0f;
|
|
|
|
myInfo.SetDamage( sk_hunter_dmg_from_striderbuster.GetFloat() ) ;
|
|
|
|
SetCondition( COND_HUNTER_STAGGERED );
|
|
}
|
|
else if ( pInflictor->ClassMatches( GetClassname() ) && !( info.GetDamageType() == DMG_GENERIC ) )
|
|
{
|
|
return 0;
|
|
}
|
|
else if ( pInflictor->ClassMatches( "hunter_flechette" ) )
|
|
{
|
|
if ( !( ( CHunterFlechette *)pInflictor )->WasThrownBack() )
|
|
{
|
|
// Flechettes only hurt us if they were thrown back at us by the player. This prevents
|
|
// hunters from hurting themselves when they walk into their own flechette clusters.
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( m_EscortBehavior.GetFollowTarget() && m_EscortBehavior.GetFollowTarget() == pAttacker )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
bool bHitByUnoccupiedCar = false;
|
|
if ( ( ( info.GetDamageType() & DMG_CRUSH ) && ( pAttacker && pAttacker->IsPlayer() ) ) ||
|
|
( info.GetDamageType() & DMG_VEHICLE ) )
|
|
{
|
|
// myInfo, not info! it may have been modified above.
|
|
float flDamage = myInfo.GetDamage();
|
|
if ( flDamage < HUNTER_MIN_PHYSICS_DAMAGE )
|
|
{
|
|
//DevMsg( "hunter: <<<< ZERO PHYSICS DAMAGE: %f\n", flDamage );
|
|
myInfo.SetDamage( 0 );
|
|
}
|
|
else
|
|
{
|
|
CBaseEntity *pInflictor = info.GetInflictor();
|
|
if ( ( info.GetDamageType() & DMG_VEHICLE ) ||
|
|
( pInflictor && pInflictor->GetServerVehicle() &&
|
|
( ( bHitByUnoccupiedCar = ( dynamic_cast<CPropVehicleDriveable *>(pInflictor) && static_cast<CPropVehicleDriveable *>(pInflictor)->GetDriver() == NULL ) ) == false ) ) )
|
|
{
|
|
// Adjust the damage from vehicles.
|
|
flDamage *= sk_hunter_vehicle_damage_scale.GetFloat();
|
|
myInfo.SetDamage( flDamage );
|
|
|
|
// Apply a force to jostle the vehicle that hit us.
|
|
// Pick a force direction based on which side we're on relative to the vehicle's motion.
|
|
Vector vecVelDir = pInflictor->GetSmoothedVelocity();
|
|
if ( vecVelDir.Length() >= hunter_jostle_car_min_speed.GetFloat() )
|
|
{
|
|
EmitSound( "NPC_Hunter.HitByVehicle" );
|
|
m_hHitByVehicle = pInflictor;
|
|
SetContextThink( &CNPC_Hunter::JostleVehicleThink, gpGlobals->curtime, HUNTER_JOSTLE_VEHICLE_THINK );
|
|
}
|
|
}
|
|
|
|
if ( !bHitByUnoccupiedCar )
|
|
{
|
|
SetCondition( COND_HUNTER_STAGGERED );
|
|
}
|
|
}
|
|
|
|
//DevMsg( "hunter: >>>> PHYSICS DAMAGE: %f (was %f)\n", flDamage, info.GetDamage() );
|
|
}
|
|
|
|
// Show damage effects if we actually took damage.
|
|
if ( ( myInfo.GetDamageType() & ( DMG_CRUSH | DMG_BLAST ) ) && ( myInfo.GetDamage() > 0 ) )
|
|
{
|
|
if ( !bHitByUnoccupiedCar )
|
|
SetCondition( COND_HUNTER_STAGGERED );
|
|
}
|
|
|
|
if ( HasCondition( COND_HUNTER_STAGGERED ) )
|
|
{
|
|
// Throw a bunch of gibs out
|
|
Vector vecForceDir = -myInfo.GetDamageForce();
|
|
VectorNormalize( vecForceDir );
|
|
PhysicsDamageEffect( myInfo.GetDamagePosition(), vecForceDir );
|
|
|
|
// Stagger away from the direction the damage came from.
|
|
m_vecStaggerDir = myInfo.GetDamageForce();
|
|
VectorNormalize( m_vecStaggerDir );
|
|
}
|
|
|
|
// Take less damage from citizens and Alyx, otherwise hunters go down too easily.
|
|
float flScale = 1.0;
|
|
|
|
if ( pAttacker &&
|
|
( ( pAttacker->Classify() == CLASS_CITIZEN_REBEL ) ||
|
|
( pAttacker->Classify() == CLASS_PLAYER_ALLY ) ||
|
|
( pAttacker->Classify() == CLASS_PLAYER_ALLY_VITAL ) ) )
|
|
{
|
|
flScale *= sk_hunter_citizen_damage_scale.GetFloat();
|
|
}
|
|
|
|
if ( flScale != 0 )
|
|
{
|
|
// We're taking a nonzero amount of damage.
|
|
|
|
// If we're not staggering, consider flinching!
|
|
if ( !HasCondition( COND_HUNTER_STAGGERED ) )
|
|
{
|
|
ConsiderFlinching( info );
|
|
}
|
|
|
|
if( pAttacker && pAttacker->IsPlayer() )
|
|
{
|
|
// This block of code will distract the Hunter back to the player if the
|
|
// player does harm to the Hunter but is not the Hunter's current enemy.
|
|
// This is achieved by updating the Hunter's enemy memory of the player and
|
|
// making the Hunter's current enemy invalid for a short time.
|
|
if( !GetEnemy() || !GetEnemy()->IsPlayer() )
|
|
{
|
|
UpdateEnemyMemory( pAttacker, pAttacker->GetAbsOrigin(), this );
|
|
|
|
if( GetEnemy() )
|
|
{
|
|
// Gotta forget about this person for a little bit.
|
|
GetEnemies()->SetTimeValidEnemy( GetEnemy(), gpGlobals->curtime + HUNTER_IGNORE_ENEMY_TIME );
|
|
}
|
|
}
|
|
}
|
|
|
|
float flDamage = myInfo.GetDamage() * flScale;
|
|
myInfo.SetDamage( flDamage );
|
|
}
|
|
|
|
int nRet = BaseClass::OnTakeDamage_Alive( myInfo );
|
|
|
|
m_EscortBehavior.OnDamage( myInfo );
|
|
|
|
// Spark at 30% health.
|
|
if ( !IsBleeding() && ( GetHealth() <= sk_hunter_health.GetInt() * 0.3 ) )
|
|
{
|
|
StartBleeding();
|
|
}
|
|
|
|
if ( IsUsingSiegeTargets() && info.GetAttacker() != NULL && info.GetAttacker()->IsPlayer() )
|
|
{
|
|
// Defend myself. Try to siege attack immediately.
|
|
m_flTimeNextSiegeTargetAttack = gpGlobals->curtime;
|
|
}
|
|
|
|
return nRet;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::Event_Killed( const CTakeDamageInfo &info )
|
|
{
|
|
// Remember the killing blow to make decisions about ragdolling.
|
|
m_nKillingDamageType = info.GetDamageType();
|
|
|
|
if ( m_EscortBehavior.GetFollowTarget() )
|
|
{
|
|
if ( AIGetNumFollowers( m_EscortBehavior.GetFollowTarget(), m_iClassname ) == 1 )
|
|
{
|
|
m_EscortBehavior.GetEscortTarget()->AlertSound();
|
|
if ( info.GetAttacker() && info.GetAttacker()->IsPlayer() )
|
|
{
|
|
m_EscortBehavior.GetEscortTarget()->UpdateEnemyMemory( UTIL_GetLocalPlayer(), UTIL_GetLocalPlayer()->GetAbsOrigin(), this );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( info.GetDamageType() & DMG_VEHICLE )
|
|
{
|
|
bool bWasRunDown = false;
|
|
int iRundownCounter = 0;
|
|
if ( GetSquad() )
|
|
{
|
|
if ( !m_IgnoreVehicleTimer.Expired() )
|
|
{
|
|
GetSquad()->GetSquadData( HUNTER_RUNDOWN_SQUADDATA, &iRundownCounter );
|
|
GetSquad()->SetSquadData( HUNTER_RUNDOWN_SQUADDATA, iRundownCounter + 1 );
|
|
bWasRunDown = true;
|
|
}
|
|
}
|
|
|
|
if ( hunter_dodge_debug.GetBool() )
|
|
Msg( "Hunter %d was%s run down\n", entindex(), ( bWasRunDown ) ? "" : " not" );
|
|
|
|
// Death by vehicle! Decrement the hunters to run over counter.
|
|
// When the counter reaches zero hunters will start dodging.
|
|
if ( GlobalEntity_GetCounter( s_iszHuntersToRunOver ) > 0 )
|
|
{
|
|
GlobalEntity_AddToCounter( s_iszHuntersToRunOver, -1 );
|
|
}
|
|
}
|
|
|
|
// Stop all our thinks
|
|
SetContextThink( NULL, 0, HUNTER_BLEED_THINK );
|
|
|
|
StopParticleEffects( this );
|
|
|
|
BaseClass::Event_Killed( info );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::StartBleeding()
|
|
{
|
|
// Do this even if we're already bleeding (see OnRestore).
|
|
m_bIsBleeding = true;
|
|
|
|
// Start gushing blood from our... anus or something.
|
|
DispatchParticleEffect( "blood_drip_synth_01", PATTACH_POINT_FOLLOW, this, gm_nHeadBottomAttachment );
|
|
|
|
// Emit spurts of our blood
|
|
SetContextThink( &CNPC_Hunter::BleedThink, gpGlobals->curtime + 0.1, HUNTER_BLEED_THINK );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
float CNPC_Hunter::MaxYawSpeed()
|
|
{
|
|
if ( IsStriderBuster( GetEnemy() ) )
|
|
{
|
|
return 60;
|
|
}
|
|
|
|
if ( GetActivity() == ACT_HUNTER_ANGRY )
|
|
return 0;
|
|
|
|
if ( GetActivity() == ACT_HUNTER_CHARGE_RUN )
|
|
return 5;
|
|
|
|
if ( GetActivity() == ACT_HUNTER_IDLE_PLANTED )
|
|
return 0;
|
|
|
|
if ( GetActivity() == ACT_HUNTER_RANGE_ATTACK2_UNPLANTED )
|
|
return 180;
|
|
|
|
switch ( GetActivity() )
|
|
{
|
|
case ACT_RANGE_ATTACK2:
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
case ACT_90_LEFT:
|
|
case ACT_90_RIGHT:
|
|
{
|
|
return 45;
|
|
}
|
|
|
|
case ACT_TURN_LEFT:
|
|
case ACT_TURN_RIGHT:
|
|
{
|
|
return 45;
|
|
}
|
|
|
|
case ACT_WALK:
|
|
{
|
|
return 25;
|
|
}
|
|
|
|
default:
|
|
{
|
|
return 35;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::IsJumpLegal(const Vector &startPos, const Vector &apex, const Vector &endPos) const
|
|
{
|
|
float MAX_JUMP_RISE = 220.0f;
|
|
float MAX_JUMP_DISTANCE = 512.0f;
|
|
float MAX_JUMP_DROP = 384.0f;
|
|
|
|
trace_t tr;
|
|
UTIL_TraceHull( startPos, startPos, GetHullMins(), GetHullMaxs(), MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );
|
|
if ( tr.startsolid )
|
|
{
|
|
// Trying to start a jump in solid! Consider checking for this in CAI_MoveProbe::JumpMoveLimit.
|
|
Assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
if ( BaseClass::IsJumpLegal( startPos, apex, endPos, MAX_JUMP_RISE, MAX_JUMP_DROP, MAX_JUMP_DISTANCE ) )
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Let the probe know I can run through small debris
|
|
// Stolen shamelessly from the Antlion Guard
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::ShouldProbeCollideAgainstEntity( CBaseEntity *pEntity )
|
|
{
|
|
if ( s_iszPhysPropClassname != pEntity->m_iClassname )
|
|
return BaseClass::ShouldProbeCollideAgainstEntity( pEntity );
|
|
|
|
if ( pEntity->GetMoveType() == MOVETYPE_VPHYSICS )
|
|
{
|
|
IPhysicsObject *pPhysObj = pEntity->VPhysicsGetObject();
|
|
|
|
if( pPhysObj && pPhysObj->GetMass() <= 500.0f )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return BaseClass::ShouldProbeCollideAgainstEntity( pEntity );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::DoMuzzleFlash( int nAttachment )
|
|
{
|
|
BaseClass::DoMuzzleFlash();
|
|
|
|
DispatchParticleEffect( "hunter_muzzle_flash", PATTACH_POINT_FOLLOW, this, nAttachment );
|
|
|
|
// Dispatch the elight
|
|
CEffectData data;
|
|
data.m_nAttachmentIndex = nAttachment;
|
|
data.m_nEntIndex = entindex();
|
|
DispatchEffect( "HunterMuzzleFlash", data );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CNPC_Hunter::CountRangedAttackers()
|
|
{
|
|
CBaseEntity *pEnemy = GetEnemy();
|
|
if ( !pEnemy )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int nAttackers = 0;
|
|
for ( int i = 0; i < g_Hunters.Count(); i++ )
|
|
{
|
|
CNPC_Hunter *pOtherHunter = g_Hunters[i];
|
|
if ( pOtherHunter->GetEnemy() == pEnemy )
|
|
{
|
|
if ( pOtherHunter->IsCurSchedule( SCHED_HUNTER_RANGE_ATTACK2 ) )
|
|
{
|
|
nAttackers++;
|
|
}
|
|
}
|
|
}
|
|
return nAttackers;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::DelayRangedAttackers( float minDelay, float maxDelay, bool bForced )
|
|
{
|
|
float delayMultiplier = ( g_pGameRules->IsSkillLevel( SKILL_EASY ) ) ? 1.25 : 1.0;
|
|
if ( !m_bEnableSquadShootDelay && !bForced )
|
|
{
|
|
m_flNextRangeAttack2Time = gpGlobals->curtime + random->RandomFloat( minDelay, maxDelay ) * delayMultiplier;
|
|
return;
|
|
}
|
|
|
|
CBaseEntity *pEnemy = GetEnemy();
|
|
for ( int i = 0; i < g_Hunters.Count(); i++ )
|
|
{
|
|
CNPC_Hunter *pOtherHunter = g_Hunters[i];
|
|
if ( pOtherHunter->GetEnemy() == pEnemy )
|
|
{
|
|
float nextTime = gpGlobals->curtime + random->RandomFloat( minDelay, maxDelay ) * delayMultiplier;
|
|
if ( nextTime > pOtherHunter->m_flNextRangeAttack2Time )
|
|
pOtherHunter->m_flNextRangeAttack2Time = nextTime;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Given a target to shoot at, decide where to aim.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::GetShootDir( Vector &vecDir, const Vector &vecSrc, CBaseEntity *pTargetEntity, bool bStriderBuster, int nShotNum, bool bSingleShot )
|
|
{
|
|
//RestartGesture( ACT_HUNTER_GESTURE_SHOOT );
|
|
|
|
EmitSound( "NPC_Hunter.FlechetteShoot" );
|
|
|
|
Vector vecBodyTarget;
|
|
|
|
if( pTargetEntity->Classify() == CLASS_PLAYER_ALLY_VITAL )
|
|
{
|
|
// Shooting at Alyx, most likely (in EP2). The attack is designed to displace
|
|
// her, not necessarily actually harm her. So shoot at the area around her feet.
|
|
vecBodyTarget = pTargetEntity->GetAbsOrigin();
|
|
}
|
|
else
|
|
{
|
|
vecBodyTarget = pTargetEntity->BodyTarget( vecSrc );
|
|
}
|
|
|
|
Vector vecTarget = vecBodyTarget;
|
|
|
|
Vector vecDelta = pTargetEntity->GetAbsOrigin() - GetAbsOrigin();
|
|
float flDist = vecDelta.Length();
|
|
|
|
if ( !bStriderBuster )
|
|
{
|
|
// If we're not firing at a strider buster, miss in an entertaining way for the
|
|
// first three shots of each volley.
|
|
if ( ( nShotNum < 3 ) && ( flDist > 200 ) )
|
|
{
|
|
Vector vecTargetForward;
|
|
Vector vecTargetRight;
|
|
pTargetEntity->GetVectors( &vecTargetForward, &vecTargetRight, NULL );
|
|
|
|
Vector vecForward;
|
|
GetVectors( &vecForward, NULL, NULL );
|
|
|
|
float flDot = DotProduct( vecTargetForward, vecForward );
|
|
|
|
if ( flDot < -0.8f )
|
|
{
|
|
// Our target is facing us, shoot the ground between us.
|
|
float flPerc = 0.7 + ( 0.1 * nShotNum );
|
|
vecTarget = GetAbsOrigin() + ( flPerc * ( pTargetEntity->GetAbsOrigin() - GetAbsOrigin() ) );
|
|
}
|
|
else if ( flDot > 0.8f )
|
|
{
|
|
// Our target is facing away from us, shoot to the left or right.
|
|
Vector vecMissDir = vecTargetRight;
|
|
if ( m_bMissLeft )
|
|
{
|
|
vecMissDir *= -1.0f;
|
|
}
|
|
|
|
vecTarget = pTargetEntity->EyePosition() + ( 36.0f * ( 3 - nShotNum ) ) * vecMissDir;
|
|
}
|
|
else
|
|
{
|
|
// Our target is facing vaguely perpendicular to us, shoot across their view.
|
|
vecTarget = pTargetEntity->EyePosition() + ( 36.0f * ( 3 - nShotNum ) ) * vecTargetForward;
|
|
}
|
|
}
|
|
// If we can't see them, shoot where we last saw them.
|
|
else if ( !HasCondition( COND_SEE_ENEMY ) )
|
|
{
|
|
Vector vecDelta = vecTarget - pTargetEntity->GetAbsOrigin();
|
|
vecTarget = m_vecEnemyLastSeen + vecDelta;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If we're firing at a striderbuster, lead it.
|
|
float flSpeed = hunter_flechette_speed.GetFloat();
|
|
if ( !flSpeed )
|
|
{
|
|
flSpeed = 2500.0f;
|
|
}
|
|
|
|
flSpeed *= 1.5;
|
|
|
|
float flDeltaTime = flDist / flSpeed;
|
|
vecTarget = vecTarget + flDeltaTime * pTargetEntity->GetSmoothedVelocity();
|
|
}
|
|
|
|
vecDir = vecTarget - vecSrc;
|
|
VectorNormalize( vecDir );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Ensures that we don't exceed our pitch/yaw limits when shooting flechettes.
|
|
// Returns true if we had to clamp, false if not.
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::ClampShootDir( Vector &vecDir )
|
|
{
|
|
Vector vecDir2D = vecDir;
|
|
vecDir2D.z = 0;
|
|
|
|
Vector vecForward;
|
|
GetVectors( &vecForward, NULL, NULL );
|
|
|
|
Vector vecForward2D = vecForward;
|
|
vecForward2D.z = 0;
|
|
|
|
float flDot = DotProduct( vecForward2D, vecDir2D );
|
|
if ( flDot >= HUNTER_SHOOT_MAX_YAW_COS )
|
|
{
|
|
// No need to clamp.
|
|
return false;
|
|
}
|
|
|
|
Vector vecAxis;
|
|
CrossProduct( vecDir, vecForward, vecAxis );
|
|
VectorNormalize( vecAxis );
|
|
|
|
Quaternion q;
|
|
AxisAngleQuaternion( vecAxis, -HUNTER_SHOOT_MAX_YAW_DEG, q );
|
|
|
|
matrix3x4_t rot;
|
|
QuaternionMatrix( q, rot );
|
|
VectorRotate( vecForward, rot, vecDir );
|
|
VectorNormalize( vecDir );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::ShouldSeekTarget( CBaseEntity *pTargetEntity, bool bStriderBuster )
|
|
{
|
|
bool bSeek = false;
|
|
|
|
if ( bStriderBuster )
|
|
{
|
|
bool bSeek = false;
|
|
|
|
if ( pTargetEntity->VPhysicsGetObject() && ( pTargetEntity->VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_PLAYER_HELD ) )
|
|
{
|
|
bSeek = true;
|
|
}
|
|
else if ( StriderBuster_NumFlechettesAttached( pTargetEntity ) == 0 )
|
|
{
|
|
if ( StriderBuster_IsAttachedStriderBuster(pTargetEntity) )
|
|
{
|
|
bSeek = true;
|
|
}
|
|
else if ( hunter_seek_thrown_striderbusters_tolerance.GetFloat() > 0.0 )
|
|
{
|
|
CNPC_Strider *pEscortTarget = m_EscortBehavior.GetEscortTarget();
|
|
if ( pEscortTarget && ( pEscortTarget->GetAbsOrigin() - pTargetEntity->GetAbsOrigin() ).LengthSqr() < Square( hunter_seek_thrown_striderbusters_tolerance.GetFloat() ) )
|
|
{
|
|
bSeek = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return bSeek;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::BeginVolley( int nNum, float flStartTime )
|
|
{
|
|
m_nFlechettesQueued = nNum;
|
|
m_nClampedShots = 0;
|
|
m_flNextFlechetteTime = flStartTime;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::ShootFlechette( CBaseEntity *pTargetEntity, bool bSingleShot )
|
|
{
|
|
if ( !pTargetEntity )
|
|
{
|
|
Assert( false );
|
|
return false;
|
|
}
|
|
|
|
int nShotNum = hunter_flechette_volley_size.GetInt() - m_nFlechettesQueued;
|
|
|
|
bool bStriderBuster = IsStriderBuster( pTargetEntity );
|
|
|
|
// Choose the next muzzle to shoot from.
|
|
Vector vecSrc;
|
|
QAngle angMuzzle;
|
|
|
|
if ( m_bTopMuzzle )
|
|
{
|
|
GetAttachment( gm_nTopGunAttachment, vecSrc, angMuzzle );
|
|
DoMuzzleFlash( gm_nTopGunAttachment );
|
|
}
|
|
else
|
|
{
|
|
GetAttachment( gm_nBottomGunAttachment, vecSrc, angMuzzle );
|
|
DoMuzzleFlash( gm_nBottomGunAttachment );
|
|
}
|
|
|
|
m_bTopMuzzle = !m_bTopMuzzle;
|
|
|
|
Vector vecDir;
|
|
GetShootDir( vecDir, vecSrc, pTargetEntity, bStriderBuster, nShotNum, bSingleShot );
|
|
|
|
bool bClamped = false;
|
|
if ( hunter_clamp_shots.GetBool() )
|
|
{
|
|
bClamped = ClampShootDir( vecDir );
|
|
}
|
|
|
|
CShotManipulator manipulator( vecDir );
|
|
Vector vecShoot;
|
|
|
|
if( IsUsingSiegeTargets() && nShotNum >= 2 && (nShotNum % 2) == 0 )
|
|
{
|
|
// Near perfect accuracy for these three shots, so they are likely to fly right into the windows.
|
|
// NOTE! In siege behavior in the map that this behavior was designed for (ep2_outland_10), the
|
|
// Hunters will only ever shoot at siege targets in siege mode. If you allow Hunters in siege mode
|
|
// to attack players or other NPCs, this accuracy bonus will apply unless we apply a bit more logic to it.
|
|
vecShoot = manipulator.ApplySpread( VECTOR_CONE_1DEGREES * 0.5, 1.0f );
|
|
}
|
|
else
|
|
{
|
|
vecShoot = manipulator.ApplySpread( VECTOR_CONE_4DEGREES, 1.0f );
|
|
}
|
|
|
|
QAngle angShoot;
|
|
VectorAngles( vecShoot, angShoot );
|
|
|
|
CHunterFlechette *pFlechette = CHunterFlechette::FlechetteCreate( vecSrc, angShoot, this );
|
|
|
|
pFlechette->AddEffects( EF_NOSHADOW );
|
|
|
|
vecShoot *= hunter_flechette_speed.GetFloat();
|
|
|
|
pFlechette->Shoot( vecShoot, bStriderBuster );
|
|
|
|
if ( ShouldSeekTarget( pTargetEntity, bStriderBuster ) )
|
|
{
|
|
pFlechette->SetSeekTarget( pTargetEntity );
|
|
}
|
|
|
|
if( nShotNum == 1 && pTargetEntity->Classify() == CLASS_PLAYER_ALLY_VITAL )
|
|
{
|
|
// Make this person afraid and react to ME, not to the flechettes.
|
|
// Otherwise they could be scared into running towards the hunter.
|
|
CSoundEnt::InsertSound( SOUND_DANGER|SOUND_CONTEXT_REACT_TO_SOURCE|SOUND_CONTEXT_EXCLUDE_COMBINE, pTargetEntity->EyePosition(), 180.0f, 2.0f, this );
|
|
}
|
|
|
|
return bClamped;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
Vector CNPC_Hunter::LeftFootHit( float eventtime )
|
|
{
|
|
Vector footPosition;
|
|
|
|
GetAttachment( "left foot", footPosition );
|
|
CPASAttenuationFilter filter( this );
|
|
EmitSound( filter, entindex(), "NPC_Hunter.Footstep", &footPosition, eventtime );
|
|
|
|
FootFX( footPosition );
|
|
|
|
return footPosition;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
Vector CNPC_Hunter::RightFootHit( float eventtime )
|
|
{
|
|
Vector footPosition;
|
|
|
|
GetAttachment( "right foot", footPosition );
|
|
CPASAttenuationFilter filter( this );
|
|
EmitSound( filter, entindex(), "NPC_Hunter.Footstep", &footPosition, eventtime );
|
|
FootFX( footPosition );
|
|
|
|
return footPosition;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
Vector CNPC_Hunter::BackFootHit( float eventtime )
|
|
{
|
|
Vector footPosition;
|
|
|
|
GetAttachment( "back foot", footPosition );
|
|
CPASAttenuationFilter filter( this );
|
|
EmitSound( filter, entindex(), "NPC_Hunter.BackFootstep", &footPosition, eventtime );
|
|
FootFX( footPosition );
|
|
|
|
return footPosition;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::FootFX( const Vector &origin )
|
|
{
|
|
return;
|
|
|
|
// dvs TODO: foot dust? probably too expensive for these guys
|
|
/*trace_t tr;
|
|
AI_TraceLine( origin, origin - Vector(0,0,100), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
|
|
float yaw = random->RandomInt(0,120);
|
|
for ( int i = 0; i < 3; i++ )
|
|
{
|
|
Vector dir = UTIL_YawToVector( yaw + i*120 ) * 10;
|
|
VectorNormalize( dir );
|
|
dir.z = 0.25;
|
|
VectorNormalize( dir );
|
|
g_pEffects->Dust( tr.endpos, dir, 12, 50 );
|
|
}*/
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CNPC_Hunter::GetEnemyVehicle()
|
|
{
|
|
if ( GetEnemy() == NULL )
|
|
return NULL;
|
|
|
|
CBaseCombatCharacter *pCCEnemy = GetEnemy()->MyCombatCharacterPointer();
|
|
if ( pCCEnemy != NULL )
|
|
return pCCEnemy->GetVehicleEntity();
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::DrawDebugGeometryOverlays()
|
|
{
|
|
if (m_debugOverlays & OVERLAY_BBOX_BIT)
|
|
{
|
|
float flViewRange = acos(0.8);
|
|
Vector vEyeDir = EyeDirection2D( );
|
|
Vector vLeftDir, vRightDir;
|
|
float fSin, fCos;
|
|
SinCos( flViewRange, &fSin, &fCos );
|
|
|
|
vLeftDir.x = vEyeDir.x * fCos - vEyeDir.y * fSin;
|
|
vLeftDir.y = vEyeDir.x * fSin + vEyeDir.y * fCos;
|
|
vLeftDir.z = vEyeDir.z;
|
|
fSin = sin(-flViewRange);
|
|
fCos = cos(-flViewRange);
|
|
vRightDir.x = vEyeDir.x * fCos - vEyeDir.y * fSin;
|
|
vRightDir.y = vEyeDir.x * fSin + vEyeDir.y * fCos;
|
|
vRightDir.z = vEyeDir.z;
|
|
|
|
int nSeq = GetSequence();
|
|
if ( ( GetEntryNode( nSeq ) == gm_nPlantedNode ) && ( GetExitNode( nSeq ) == gm_nPlantedNode ) )
|
|
{
|
|
// planted - green
|
|
NDebugOverlay::Box( GetAbsOrigin(), GetHullMins(), GetHullMaxs(), 0, 255, 0, 128, 0 );
|
|
}
|
|
else if ( ( GetEntryNode( nSeq ) == gm_nUnplantedNode ) && ( GetExitNode( nSeq ) == gm_nUnplantedNode ) )
|
|
{
|
|
// unplanted - blue
|
|
NDebugOverlay::Box( GetAbsOrigin(), GetHullMins(), GetHullMaxs(), 0, 0, 255, 128, 0 );
|
|
}
|
|
else if ( ( GetEntryNode( nSeq ) == gm_nUnplantedNode ) && ( GetExitNode( nSeq ) == gm_nPlantedNode ) )
|
|
{
|
|
// planting transition - cyan
|
|
NDebugOverlay::Box( GetAbsOrigin(), GetHullMins(), GetHullMaxs(), 0, 255, 255, 128, 0 );
|
|
}
|
|
else if ( ( GetEntryNode( nSeq ) == gm_nPlantedNode ) && ( GetExitNode( nSeq ) == gm_nUnplantedNode ) )
|
|
{
|
|
// unplanting transition - purple
|
|
NDebugOverlay::Box( GetAbsOrigin(), GetHullMins(), GetHullMaxs(), 255, 0, 255, 128, 0 );
|
|
}
|
|
else
|
|
{
|
|
// unknown / other node - red
|
|
Msg( "UNKNOWN: %s\n", GetSequenceName( GetSequence() ) );
|
|
NDebugOverlay::Box( GetAbsOrigin(), GetHullMins(), GetHullMaxs(), 255, 0, 0, 128, 0 );
|
|
}
|
|
|
|
NDebugOverlay::BoxDirection(EyePosition(), Vector(0,0,-1), Vector(200,0,1), vLeftDir, 255, 0, 0, 50, 0 );
|
|
NDebugOverlay::BoxDirection(EyePosition(), Vector(0,0,-1), Vector(200,0,1), vRightDir, 255, 0, 0, 50, 0 );
|
|
NDebugOverlay::BoxDirection(EyePosition(), Vector(0,0,-1), Vector(200,0,1), vEyeDir, 0, 255, 0, 50, 0 );
|
|
NDebugOverlay::Box(EyePosition(), -Vector(2,2,2), Vector(2,2,2), 0, 255, 0, 128, 0 );
|
|
}
|
|
|
|
m_EscortBehavior.DrawDebugGeometryOverlays();
|
|
|
|
BaseClass::DrawDebugGeometryOverlays();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Player has illuminated this NPC with the flashlight
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::PlayerHasIlluminatedNPC( CBasePlayer *pPlayer, float flDot )
|
|
{
|
|
if ( m_bFlashlightInEyes )
|
|
return;
|
|
|
|
// Ignore the flashlight if it's not shining at my eyes
|
|
if ( PlayerFlashlightOnMyEyes( pPlayer ) )
|
|
{
|
|
//Msg( ">>>> SHINING FLASHLIGHT ON ME\n" );
|
|
m_bFlashlightInEyes = true;
|
|
SetExpression( "scenes/npc/hunter/hunter_eyeclose.vcd" );
|
|
m_flPupilDilateTime = gpGlobals->curtime + 0.2f;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::PlayerFlashlightOnMyEyes( CBasePlayer *pPlayer )
|
|
{
|
|
Vector vecEyes, vecEyeForward, vecPlayerForward;
|
|
GetAttachment( gm_nTopGunAttachment, vecEyes, &vecEyeForward );
|
|
pPlayer->EyeVectors( &vecPlayerForward );
|
|
|
|
Vector vecToEyes = (vecEyes - pPlayer->EyePosition());
|
|
//float flDist = VectorNormalize( vecToEyes );
|
|
|
|
float flDot = DotProduct( vecPlayerForward, vecToEyes );
|
|
if ( flDot < 0.98 )
|
|
return false;
|
|
|
|
// Check facing to ensure we're in front of her
|
|
Vector los = ( pPlayer->EyePosition() - EyePosition() );
|
|
los.z = 0;
|
|
VectorNormalize( los );
|
|
Vector facingDir = EyeDirection2D();
|
|
flDot = DotProduct( los, facingDir );
|
|
return ( flDot > 0.3 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Return a random expression for the specified state to play over
|
|
// the state's expression loop.
|
|
//-----------------------------------------------------------------------------
|
|
const char *CNPC_Hunter::SelectRandomExpressionForState( NPC_STATE state )
|
|
{
|
|
if ( m_bFlashlightInEyes )
|
|
return NULL;
|
|
|
|
if ( !hunter_random_expressions.GetBool() )
|
|
return NULL;
|
|
|
|
char *szExpressions[4] =
|
|
{
|
|
"scenes/npc/hunter/hunter_scan.vcd",
|
|
"scenes/npc/hunter/hunter_eyeclose.vcd",
|
|
"scenes/npc/hunter/hunter_roar.vcd",
|
|
"scenes/npc/hunter/hunter_pain.vcd"
|
|
};
|
|
|
|
int nIndex = random->RandomInt( 0, 3 );
|
|
//Msg( "RANDOM Expression: %s\n", szExpressions[nIndex] );
|
|
return szExpressions[nIndex];
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::PlayExpressionForState( NPC_STATE state )
|
|
{
|
|
if ( m_bFlashlightInEyes )
|
|
{
|
|
return;
|
|
}
|
|
|
|
BaseClass::PlayExpressionForState( state );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// TODO: remove if we're not doing striderbuster stuff
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::StriderBusterAttached( CBaseEntity *pAttached )
|
|
{
|
|
// Add another to the list
|
|
m_hAttachedBusters.AddToTail( pAttached );
|
|
|
|
SetCondition( COND_HUNTER_HIT_BY_STICKYBOMB );
|
|
if (m_hAttachedBusters.Count() == 1)
|
|
{
|
|
EmitSound( "NPC_Hunter.Alert" );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::StriderBusterDetached( CBaseEntity *pAttached )
|
|
{
|
|
int elem = m_hAttachedBusters.Find(pAttached);
|
|
if (elem >= 0)
|
|
{
|
|
m_hAttachedBusters.FastRemove(elem);
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Set direction that the hunter aims his body and eyes (guns).
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::SetAim( const Vector &aimDir, float flInterval )
|
|
{
|
|
QAngle angDir;
|
|
VectorAngles( aimDir, angDir );
|
|
float curPitch = GetPoseParameter( gm_nBodyPitchPoseParam );
|
|
float curYaw = GetPoseParameter( gm_nBodyYawPoseParam );
|
|
|
|
float newPitch;
|
|
float newYaw;
|
|
|
|
if ( GetEnemy() )
|
|
{
|
|
// clamp and dampen movement
|
|
newPitch = curPitch + 0.8 * UTIL_AngleDiff( UTIL_ApproachAngle( angDir.x, curPitch, 20 ), curPitch );
|
|
|
|
float flRelativeYaw = UTIL_AngleDiff( angDir.y, GetAbsAngles().y );
|
|
newYaw = curYaw + UTIL_AngleDiff( flRelativeYaw, curYaw );
|
|
}
|
|
else
|
|
{
|
|
// Sweep your weapon more slowly if you're not fighting someone
|
|
newPitch = curPitch + 0.6 * UTIL_AngleDiff( UTIL_ApproachAngle( angDir.x, curPitch, 20 ), curPitch );
|
|
|
|
float flRelativeYaw = UTIL_AngleDiff( angDir.y, GetAbsAngles().y );
|
|
newYaw = curYaw + 0.6 * UTIL_AngleDiff( flRelativeYaw, curYaw );
|
|
}
|
|
|
|
newPitch = AngleNormalize( newPitch );
|
|
newYaw = AngleNormalize( newYaw );
|
|
|
|
//Msg( "pitch=%f, yaw=%f\n", newPitch, newYaw );
|
|
|
|
SetPoseParameter( gm_nAimPitchPoseParam, 0 );
|
|
SetPoseParameter( gm_nAimYawPoseParam, 0 );
|
|
|
|
SetPoseParameter( gm_nBodyPitchPoseParam, clamp( newPitch, -45, 45 ) );
|
|
SetPoseParameter( gm_nBodyYawPoseParam, clamp( newYaw, -45, 45 ) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::RelaxAim( float flInterval )
|
|
{
|
|
float curPitch = GetPoseParameter( gm_nBodyPitchPoseParam );
|
|
float curYaw = GetPoseParameter( gm_nBodyYawPoseParam );
|
|
|
|
// dampen existing aim
|
|
float newPitch = AngleNormalize( UTIL_ApproachAngle( 0, curPitch, 3 ) );
|
|
float newYaw = AngleNormalize( UTIL_ApproachAngle( 0, curYaw, 2 ) );
|
|
|
|
SetPoseParameter( gm_nAimPitchPoseParam, 0 );
|
|
SetPoseParameter( gm_nAimYawPoseParam, 0 );
|
|
|
|
SetPoseParameter( gm_nBodyPitchPoseParam, clamp( newPitch, -45, 45 ) );
|
|
SetPoseParameter( gm_nBodyYawPoseParam, clamp( newYaw, -45, 45 ) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CNPC_Hunter::UpdateAim()
|
|
{
|
|
if ( !GetModelPtr() || !GetModelPtr()->SequencesAvailable() )
|
|
return;
|
|
|
|
float flInterval = GetAnimTimeInterval();
|
|
|
|
// Some activities look bad if we're giving our enemy the stinkeye.
|
|
int eActivity = GetActivity();
|
|
|
|
if ( GetEnemy() &&
|
|
GetState() != NPC_STATE_SCRIPT &&
|
|
( eActivity != ACT_HUNTER_CHARGE_CRASH ) &&
|
|
( eActivity != ACT_HUNTER_CHARGE_HIT ) )
|
|
{
|
|
Vector vecShootOrigin;
|
|
|
|
vecShootOrigin = Weapon_ShootPosition();
|
|
Vector vecShootDir = GetShootEnemyDir( vecShootOrigin, false );
|
|
|
|
SetAim( vecShootDir, flInterval );
|
|
}
|
|
else
|
|
{
|
|
RelaxAim( flInterval );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Don't become a ragdoll until we've finished our death anim
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPC_Hunter::CanBecomeRagdoll()
|
|
{
|
|
return ( m_nKillingDamageType & DMG_CRUSH ) ||
|
|
IsCurSchedule( SCHED_DIE, false ) || // Finished playing death anim, time to ragdoll
|
|
IsCurSchedule( SCHED_HUNTER_CHARGE_ENEMY, false ) || // While moving, it looks better to ragdoll instantly
|
|
IsCurSchedule( SCHED_SCRIPTED_RUN, false ) ||
|
|
( GetActivity() == ACT_WALK ) || ( GetActivity() == ACT_RUN ) ||
|
|
GetCurSchedule() == NULL; // Failsafe
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Determines the best type of death anim to play based on how we died.
|
|
//-----------------------------------------------------------------------------
|
|
Activity CNPC_Hunter::GetDeathActivity()
|
|
{
|
|
return ACT_DIESIMPLE;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CAI_HunterEscortBehavior::OnDamage( const CTakeDamageInfo &info )
|
|
{
|
|
if ( info.GetDamage() > 0 && info.GetAttacker()->IsPlayer() &&
|
|
GetFollowTarget() && ( AIGetNumFollowers( GetFollowTarget() ) > 1 ) &&
|
|
( GetOuter()->GetSquad()->GetSquadSoundWaitTime() <= gpGlobals->curtime ) ) // && !FarFromFollowTarget()
|
|
{
|
|
// Start the clock ticking. We'll return the the strider when the timer elapses.
|
|
m_flTimeEscortReturn = gpGlobals->curtime + random->RandomFloat( 15.0f, 25.0f );
|
|
GetOuter()->GetSquad()->SetSquadSoundWaitTime( m_flTimeEscortReturn + 1.0 ); // prevent others from breaking escort
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CAI_HunterEscortBehavior::BuildScheduleTestBits()
|
|
{
|
|
BaseClass::BuildScheduleTestBits();
|
|
|
|
if ( ( m_flTimeEscortReturn != 0 ) && ( gpGlobals->curtime > m_flTimeEscortReturn ) )
|
|
{
|
|
// We're delinquent! Return to strider!
|
|
GetOuter()->ClearCustomInterruptCondition( COND_NEW_ENEMY );
|
|
GetOuter()->ClearCustomInterruptCondition( COND_SEE_ENEMY );
|
|
GetOuter()->ClearCustomInterruptCondition( COND_SEE_HATE );
|
|
GetOuter()->ClearCustomInterruptCondition( COND_CAN_RANGE_ATTACK1 );
|
|
GetOuter()->ClearCustomInterruptCondition( COND_CAN_RANGE_ATTACK2 );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CAI_HunterEscortBehavior::CheckBreakEscort()
|
|
{
|
|
if ( m_flTimeEscortReturn != 0 && ( FarFromFollowTarget() || gpGlobals->curtime >= m_flTimeEscortReturn ) )
|
|
{
|
|
if ( FarFromFollowTarget() )
|
|
{
|
|
m_flTimeEscortReturn = gpGlobals->curtime;
|
|
}
|
|
else
|
|
{
|
|
m_flTimeEscortReturn = 0;
|
|
}
|
|
if ( GetOuter()->GetSquad() )
|
|
{
|
|
GetOuter()->GetSquad()->SetSquadSoundWaitTime( gpGlobals->curtime + random->RandomFloat( 5.0f, 12.0f ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CAI_HunterEscortBehavior::GatherConditionsNotActive( void )
|
|
{
|
|
if ( m_bEnabled )
|
|
{
|
|
DistributeFreeHunters();
|
|
}
|
|
|
|
BaseClass::GatherConditionsNotActive();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CAI_HunterEscortBehavior::GatherConditions( void )
|
|
{
|
|
m_bEnabled = true;
|
|
|
|
DistributeFreeHunters();
|
|
|
|
BaseClass::GatherConditions();
|
|
|
|
if ( GetEnemy() && GetEnemy()->IsPlayer() && HasCondition( COND_SEE_ENEMY ) )
|
|
{
|
|
if ( GetOuter()->GetSquad()->GetSquadSoundWaitTime() <= gpGlobals->curtime && ((CBasePlayer *)GetEnemy())->IsInAVehicle() )
|
|
{
|
|
m_flTimeEscortReturn = gpGlobals->curtime + random->RandomFloat( 15.0f, 25.0f );
|
|
GetOuter()->GetSquad()->SetSquadSoundWaitTime( m_flTimeEscortReturn + 1.0 ); // prevent others from breaking escort
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CAI_HunterEscortBehavior::ShouldFollow()
|
|
{
|
|
if ( IsStriderBuster( GetEnemy() ) )
|
|
return false;
|
|
|
|
if ( HasCondition( COND_HEAR_PHYSICS_DANGER ) )
|
|
return false;
|
|
|
|
if ( m_flTimeEscortReturn <= gpGlobals->curtime )
|
|
{
|
|
return CAI_FollowBehavior::ShouldFollow();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CAI_HunterEscortBehavior::BeginScheduleSelection()
|
|
{
|
|
BaseClass::BeginScheduleSelection();
|
|
Assert( m_SavedDistTooFar == GetOuter()->m_flDistTooFar );
|
|
GetOuter()->m_flDistTooFar *= 2;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CAI_HunterEscortBehavior::SelectSchedule()
|
|
{
|
|
if( m_FollowDelay.IsRunning() && !m_FollowDelay.Expired() )
|
|
{
|
|
return FollowCallBaseSelectSchedule();
|
|
}
|
|
return BaseClass::SelectSchedule();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CAI_HunterEscortBehavior::FollowCallBaseSelectSchedule()
|
|
{
|
|
if ( GetOuter()->GetState() == NPC_STATE_COMBAT )
|
|
{
|
|
return GetOuter()->SelectCombatSchedule();
|
|
}
|
|
|
|
return BaseClass::FollowCallBaseSelectSchedule();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CAI_HunterEscortBehavior::StartTask( const Task_t *pTask )
|
|
{
|
|
switch( pTask->iTask )
|
|
{
|
|
case TASK_MOVE_TO_FOLLOW_POSITION:
|
|
{
|
|
if ( GetEnemy() )
|
|
{
|
|
if ( GetOuter()->OccupyStrategySlot( SQUAD_SLOT_RUN_SHOOT ) )
|
|
{
|
|
if ( GetOuter()->GetSquad()->GetSquadMemberNearestTo( GetEnemy()->GetAbsOrigin() ) == GetOuter() )
|
|
{
|
|
GetOuter()->BeginVolley( NUM_FLECHETTE_VOLLEY_ON_FOLLOW, gpGlobals->curtime + 1.0 + random->RandomFloat( 0, .25 ) + random->RandomFloat( 0, .25 ) );
|
|
}
|
|
else
|
|
{
|
|
GetOuter()->VacateStrategySlot();
|
|
}
|
|
}
|
|
}
|
|
BaseClass::StartTask( pTask );
|
|
break;
|
|
}
|
|
|
|
default:
|
|
BaseClass::StartTask( pTask );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CAI_HunterEscortBehavior::RunTask( const Task_t *pTask )
|
|
{
|
|
switch( pTask->iTask )
|
|
{
|
|
case TASK_MOVE_TO_FOLLOW_POSITION:
|
|
{
|
|
if ( !GetFollowTarget() )
|
|
{
|
|
TaskFail( FAIL_NO_TARGET );
|
|
}
|
|
else
|
|
{
|
|
if ( GetEnemy() )
|
|
{
|
|
CNPC_Hunter *pHunter = GetOuter();
|
|
Vector vecEnemyLKP = pHunter->GetEnemyLKP();
|
|
pHunter->AddFacingTarget( pHunter->GetEnemy(), vecEnemyLKP, 1.0, 0.8 );
|
|
bool bVacate = false;
|
|
|
|
bool bHasSlot = pHunter->HasStrategySlot( SQUAD_SLOT_RUN_SHOOT );
|
|
if ( HasCondition( COND_SEE_ENEMY ) )
|
|
{
|
|
float maxDist = hunter_flechette_max_range.GetFloat() * 3;
|
|
float distSq = ( pHunter->GetAbsOrigin() - pHunter->GetEnemy()->GetAbsOrigin() ).Length2DSqr();
|
|
|
|
if ( distSq < Square( maxDist ) )
|
|
{
|
|
if ( gpGlobals->curtime >= pHunter->m_flNextFlechetteTime )
|
|
{
|
|
if ( !bHasSlot )
|
|
{
|
|
if ( GetOuter()->OccupyStrategySlot( SQUAD_SLOT_RUN_SHOOT ) )
|
|
{
|
|
if ( GetOuter()->GetSquad()->GetSquadMemberNearestTo( GetEnemy()->GetAbsOrigin() ) == GetOuter() )
|
|
{
|
|
bHasSlot = true;
|
|
}
|
|
else
|
|
{
|
|
GetOuter()->VacateStrategySlot();
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( bHasSlot )
|
|
{
|
|
// Start the firing sound.
|
|
//CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
|
//if ( controller.SoundGetVolume( pHunter->m_pGunFiringSound ) == 0.0f )
|
|
//{
|
|
// controller.SoundChangeVolume( pHunter->m_pGunFiringSound, 1.0f, 0.0f );
|
|
//}
|
|
|
|
pHunter->ShootFlechette( GetEnemy(), true );
|
|
|
|
if ( --pHunter->m_nFlechettesQueued > 0 )
|
|
{
|
|
pHunter->m_flNextFlechetteTime = gpGlobals->curtime + hunter_flechette_delay.GetFloat();
|
|
}
|
|
else
|
|
{
|
|
// Stop the firing sound.
|
|
//CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
|
//controller.SoundChangeVolume( pHunter->m_pGunFiringSound, 0, 0.01f );
|
|
|
|
bVacate = true;
|
|
pHunter->BeginVolley( NUM_FLECHETTE_VOLLEY_ON_FOLLOW, gpGlobals->curtime + 1.0 + random->RandomFloat( 0, .25 ) + random->RandomFloat( 0, .25 ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ( bHasSlot )
|
|
{
|
|
bVacate = true;
|
|
}
|
|
}
|
|
else if ( bHasSlot )
|
|
{
|
|
bVacate = true;
|
|
}
|
|
|
|
if ( bVacate )
|
|
{
|
|
pHunter->VacateStrategySlot();
|
|
}
|
|
}
|
|
|
|
if ( m_FollowAttackTimer.Expired() && IsFollowTargetInRange( .8 ))
|
|
{
|
|
m_FollowAttackTimer.Set( 8, 24 );
|
|
TaskComplete();
|
|
}
|
|
else
|
|
{
|
|
BaseClass::RunTask( pTask );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
BaseClass::RunTask( pTask );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CAI_HunterEscortBehavior::FindFreeHunters( CUtlVector<CNPC_Hunter *> *pFreeHunters )
|
|
{
|
|
pFreeHunters->EnsureCapacity( g_Hunters.Count() );
|
|
int i;
|
|
|
|
for ( i = 0; i < g_Hunters.Count(); i++ )
|
|
{
|
|
CNPC_Hunter *pHunter = g_Hunters[i];
|
|
if ( pHunter->IsAlive() && pHunter->m_EscortBehavior.m_bEnabled )
|
|
{
|
|
if ( pHunter->m_EscortBehavior.GetFollowTarget() == NULL || !pHunter->m_EscortBehavior.GetFollowTarget()->IsAlive() )
|
|
{
|
|
pFreeHunters->AddToTail( pHunter);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CAI_HunterEscortBehavior::DistributeFreeHunters()
|
|
{
|
|
if ( g_TimeLastDistributeFreeHunters != -1 && gpGlobals->curtime - g_TimeLastDistributeFreeHunters < FREE_HUNTER_DISTRIBUTE_INTERVAL )
|
|
{
|
|
return;
|
|
}
|
|
|
|
g_TimeLastDistributeFreeHunters = gpGlobals->curtime;
|
|
|
|
CUtlVector<CNPC_Hunter *> freeHunters;
|
|
int i;
|
|
FindFreeHunters( &freeHunters );
|
|
|
|
CAI_BaseNPC **ppNPCs = g_AI_Manager.AccessAIs();
|
|
for ( i = 0; i < g_AI_Manager.NumAIs() && freeHunters.Count(); i++ )
|
|
{
|
|
int nToAdd;
|
|
CNPC_Strider *pStrider = ( ppNPCs[i]->IsAlive() ) ? dynamic_cast<CNPC_Strider *>( ppNPCs[i] ) : NULL;
|
|
if ( pStrider && !pStrider->CarriedByDropship() )
|
|
{
|
|
if ( ( nToAdd = 3 - AIGetNumFollowers( pStrider ) ) > 0 )
|
|
{
|
|
for ( int j = freeHunters.Count() - 1; j >= 0 && nToAdd > 0; --j )
|
|
{
|
|
DevMsg( "npc_hunter %d assigned to npc_strider %d\n", freeHunters[j]->entindex(), pStrider->entindex() );
|
|
freeHunters[j]->FollowStrider( pStrider );
|
|
freeHunters.FastRemove( j );
|
|
nToAdd--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( i = 0; i < freeHunters.Count(); i++ )
|
|
{
|
|
//DevMsg( "npc_hunter %d assigned to free_hunters_squad\n", freeHunters[i]->entindex() );
|
|
freeHunters[i]->m_EscortBehavior.SetFollowTarget( NULL );
|
|
freeHunters[i]->AddToSquad( AllocPooledString( "free_hunters_squad" ) );
|
|
}
|
|
|
|
#if 0
|
|
CBaseEntity *pHunterMaker = gEntList.FindEntityByClassname( NULL, "npc_hunter_maker" ); // TODO: this picks the same one every time!
|
|
if ( pHunterMaker )
|
|
{
|
|
for ( i = 0; i < freeHunters.Count(); i++ )
|
|
{
|
|
freeHunters[i]->m_EscortBehavior.SetFollowTarget( pHunterMaker );
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CAI_HunterEscortBehavior::DrawDebugGeometryOverlays()
|
|
{
|
|
if ( !GetFollowTarget() )
|
|
return;
|
|
|
|
Vector vecFollowPos = GetGoalPosition();
|
|
if ( FarFromFollowTarget() )
|
|
{
|
|
if ( gpGlobals->curtime >= m_flTimeEscortReturn )
|
|
{
|
|
NDebugOverlay::HorzArrow( GetOuter()->GetAbsOrigin(), vecFollowPos, 16.0f, 255, 0, 0, 0, true, 0 );
|
|
}
|
|
else
|
|
{
|
|
NDebugOverlay::HorzArrow( GetOuter()->GetAbsOrigin(), vecFollowPos, 16.0f, 255, 255, 0, 0, true, 0 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NDebugOverlay::HorzArrow( GetOuter()->GetAbsOrigin(), vecFollowPos, 16.0f, 0, 255, 0, 0, true, 0 );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool Hunter_IsHunter(CBaseEntity *pEnt)
|
|
{
|
|
return dynamic_cast<CNPC_Hunter *>(pEnt) != NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void Hunter_StriderBusterLaunched( CBaseEntity *pBuster )
|
|
{
|
|
CAI_BaseNPC **ppAIs = g_AI_Manager.AccessAIs();
|
|
int nAIs = g_AI_Manager.NumAIs();
|
|
|
|
for ( int i = 0; i < nAIs; i++ )
|
|
{
|
|
CAI_BaseNPC *pNPC = ppAIs[ i ];
|
|
if ( pNPC && ( pNPC->Classify() == CLASS_COMBINE_HUNTER ) && pNPC->m_lifeState == LIFE_ALIVE )
|
|
{
|
|
if ( !pNPC->GetEnemy() || !IsStriderBuster( pNPC->GetEnemy() ) )
|
|
{
|
|
Vector vecDelta = pNPC->GetAbsOrigin() - pBuster->GetAbsOrigin();
|
|
if ( vecDelta.Length2DSqr() < 9437184.0f ) // 3072 * 3072
|
|
{
|
|
pNPC->SetEnemy( pBuster );
|
|
pNPC->SetState( NPC_STATE_COMBAT );
|
|
pNPC->UpdateEnemyMemory( pBuster, pBuster->GetAbsOrigin() );
|
|
|
|
// Stop whatever we're doing.
|
|
pNPC->SetCondition( COND_SCHEDULE_DONE );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void Hunter_StriderBusterAttached( CBaseEntity *pHunter, CBaseEntity *pAttached )
|
|
{
|
|
Assert(dynamic_cast<CNPC_Hunter *>(pHunter));
|
|
|
|
static_cast<CNPC_Hunter *>(pHunter)->StriderBusterAttached(pAttached);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void Hunter_StriderBusterDetached( CBaseEntity *pHunter, CBaseEntity *pAttached )
|
|
{
|
|
Assert(dynamic_cast<CNPC_Hunter *>(pHunter));
|
|
|
|
static_cast<CNPC_Hunter *>(pHunter)->StriderBusterDetached(pAttached);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
//
|
|
// ep2_outland_12 custom npc makers
|
|
//
|
|
//-------------------------------------------------------------------------------------------------
|
|
|
|
class CHunterMaker : public CTemplateNPCMaker
|
|
{
|
|
typedef CTemplateNPCMaker BaseClass;
|
|
public:
|
|
void MakeMultipleNPCS( int nNPCs )
|
|
{
|
|
const float MIN_HEALTH_PCT = 0.2;
|
|
|
|
CUtlVector<CNPC_Hunter *> candidates;
|
|
CUtlVectorFixed<CNPC_Hunter *, 3> freeHunters;
|
|
CAI_HunterEscortBehavior::FindFreeHunters( &candidates );
|
|
|
|
freeHunters.EnsureCapacity( 3 );
|
|
int i;
|
|
|
|
for ( i = 0; i < candidates.Count() && freeHunters.Count() < 3; i++ )
|
|
{
|
|
if ( candidates[i]->GetHealth() > candidates[i]->GetMaxHealth() * MIN_HEALTH_PCT )
|
|
{
|
|
freeHunters.AddToTail( candidates[i] );
|
|
}
|
|
}
|
|
|
|
int nRequested = nNPCs;
|
|
if ( nNPCs < 3 )
|
|
{
|
|
nNPCs = MIN( 3, nNPCs + freeHunters.Count() );
|
|
}
|
|
|
|
int nSummoned = 0;
|
|
for ( i = 0; i < freeHunters.Count() && nNPCs; i++ )
|
|
{
|
|
freeHunters[i]->m_EscortBehavior.SetFollowTarget( this ); // this will make them not "free"
|
|
freeHunters[i]->SetName( m_iszTemplateName ); // this will force the hunter to get the FollowStrider input
|
|
nNPCs--;
|
|
nSummoned++;
|
|
}
|
|
|
|
DevMsg( "Requested %d to spawn, Summoning %d free hunters, spawning %d new hunters\n", nRequested, nSummoned, nNPCs );
|
|
if ( nNPCs )
|
|
{
|
|
BaseClass::MakeMultipleNPCS( nNPCs );
|
|
}
|
|
}
|
|
};
|
|
|
|
LINK_ENTITY_TO_CLASS( npc_hunter_maker, CHunterMaker );
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
//
|
|
// Schedules
|
|
//
|
|
//-------------------------------------------------------------------------------------------------
|
|
AI_BEGIN_CUSTOM_NPC( npc_hunter, CNPC_Hunter )
|
|
|
|
DECLARE_TASK( TASK_HUNTER_AIM )
|
|
DECLARE_TASK( TASK_HUNTER_FIND_DODGE_POSITION )
|
|
DECLARE_TASK( TASK_HUNTER_DODGE )
|
|
DECLARE_TASK( TASK_HUNTER_PRE_RANGE_ATTACK2 )
|
|
DECLARE_TASK( TASK_HUNTER_SHOOT_COMMIT )
|
|
DECLARE_TASK( TASK_HUNTER_ANNOUNCE_FLANK )
|
|
DECLARE_TASK( TASK_HUNTER_BEGIN_FLANK )
|
|
DECLARE_TASK( TASK_HUNTER_STAGGER )
|
|
DECLARE_TASK( TASK_HUNTER_CORNERED_TIMER )
|
|
DECLARE_TASK( TASK_HUNTER_FIND_SIDESTEP_POSITION )
|
|
DECLARE_TASK( TASK_HUNTER_CHARGE )
|
|
DECLARE_TASK( TASK_HUNTER_FINISH_RANGE_ATTACK )
|
|
DECLARE_TASK( TASK_HUNTER_WAIT_FOR_MOVEMENT_FACING_ENEMY )
|
|
DECLARE_TASK( TASK_HUNTER_CHARGE_DELAY )
|
|
|
|
DECLARE_ACTIVITY( ACT_HUNTER_DEPLOYRA2 )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_DODGER )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_DODGEL )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_GESTURE_SHOOT )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_FLINCH_STICKYBOMB )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_STAGGER )
|
|
DECLARE_ACTIVITY( ACT_DI_HUNTER_MELEE )
|
|
DECLARE_ACTIVITY( ACT_DI_HUNTER_THROW )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_MELEE_ATTACK1_VS_PLAYER )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_ANGRY )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_WALK_ANGRY )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_FOUND_ENEMY )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_FOUND_ENEMY_ACK )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_CHARGE_START )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_CHARGE_RUN )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_CHARGE_STOP )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_CHARGE_CRASH )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_CHARGE_HIT )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_RANGE_ATTACK2_UNPLANTED )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_IDLE_PLANTED )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_FLINCH_N )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_FLINCH_S )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_FLINCH_E )
|
|
DECLARE_ACTIVITY( ACT_HUNTER_FLINCH_W )
|
|
|
|
DECLARE_INTERACTION( g_interactionHunterFoundEnemy );
|
|
|
|
DECLARE_SQUADSLOT( SQUAD_SLOT_HUNTER_CHARGE )
|
|
DECLARE_SQUADSLOT( SQUAD_SLOT_HUNTER_FLANK_FIRST )
|
|
DECLARE_SQUADSLOT( SQUAD_SLOT_RUN_SHOOT )
|
|
|
|
DECLARE_CONDITION( COND_HUNTER_SHOULD_PATROL )
|
|
DECLARE_CONDITION( COND_HUNTER_FORCED_FLANK_ENEMY )
|
|
DECLARE_CONDITION( COND_HUNTER_CAN_CHARGE_ENEMY )
|
|
DECLARE_CONDITION( COND_HUNTER_STAGGERED )
|
|
DECLARE_CONDITION( COND_HUNTER_IS_INDOORS )
|
|
DECLARE_CONDITION( COND_HUNTER_HIT_BY_STICKYBOMB )
|
|
DECLARE_CONDITION( COND_HUNTER_SEE_STRIDERBUSTER )
|
|
DECLARE_CONDITION( COND_HUNTER_FORCED_DODGE )
|
|
DECLARE_CONDITION( COND_HUNTER_INCOMING_VEHICLE )
|
|
DECLARE_CONDITION( COND_HUNTER_NEW_HINTGROUP )
|
|
DECLARE_CONDITION( COND_HUNTER_CANT_PLANT )
|
|
DECLARE_CONDITION( COND_HUNTER_SQUADMATE_FOUND_ENEMY )
|
|
|
|
DECLARE_ANIMEVENT( AE_HUNTER_FOOTSTEP_LEFT )
|
|
DECLARE_ANIMEVENT( AE_HUNTER_FOOTSTEP_RIGHT )
|
|
DECLARE_ANIMEVENT( AE_HUNTER_FOOTSTEP_BACK )
|
|
DECLARE_ANIMEVENT( AE_HUNTER_MELEE_ANNOUNCE )
|
|
DECLARE_ANIMEVENT( AE_HUNTER_MELEE_ATTACK_LEFT )
|
|
DECLARE_ANIMEVENT( AE_HUNTER_MELEE_ATTACK_RIGHT )
|
|
DECLARE_ANIMEVENT( AE_HUNTER_DIE )
|
|
DECLARE_ANIMEVENT( AE_HUNTER_SPRAY_BLOOD )
|
|
DECLARE_ANIMEVENT( AE_HUNTER_START_EXPRESSION )
|
|
DECLARE_ANIMEVENT( AE_HUNTER_END_EXPRESSION )
|
|
|
|
//=========================================================
|
|
// Attack (Deploy/shoot/finish)
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_RANGE_ATTACK1,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_HUNTER_SHOOT_COMMIT 0"
|
|
" TASK_RANGE_ATTACK1 0"
|
|
" "
|
|
" Interrupts"
|
|
" COND_NEW_ENEMY"
|
|
" COND_ENEMY_DEAD"
|
|
" COND_LOST_ENEMY"
|
|
" COND_ENEMY_OCCLUDED"
|
|
" COND_WEAPON_SIGHT_OCCLUDED"
|
|
" COND_TOO_CLOSE_TO_ATTACK"
|
|
" COND_TOO_FAR_TO_ATTACK"
|
|
" COND_NOT_FACING_ATTACK"
|
|
)
|
|
|
|
//=========================================================
|
|
// Attack (Deploy/shoot/finish)
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_RANGE_ATTACK2,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_HUNTER_PRE_RANGE_ATTACK2 0"
|
|
" TASK_HUNTER_SHOOT_COMMIT 0"
|
|
" TASK_RANGE_ATTACK2 0"
|
|
" TASK_HUNTER_FINISH_RANGE_ATTACK 0"
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
|
|
" TASK_WAIT 0.4"
|
|
" TASK_WAIT_RANDOM 0.2"
|
|
" "
|
|
" Interrupts"
|
|
" COND_NEW_ENEMY"
|
|
)
|
|
|
|
//=========================================================
|
|
// Shoot at striderbuster. Distinct from generic range attack
|
|
// because of BuildScheduleTestBits.
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_RANGE_ATTACK2_VS_STRIDERBUSTER,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_HUNTER_SHOOT_COMMIT 0"
|
|
" TASK_RANGE_ATTACK2 0"
|
|
" "
|
|
" Interrupts"
|
|
)
|
|
|
|
//=========================================================
|
|
// Shoot at striderbuster with a little latency beforehand
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_RANGE_ATTACK2_VS_STRIDERBUSTER_LATENT,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_HUNTER_SHOOT_COMMIT 0"
|
|
" TASK_WAIT 0.2"
|
|
" TASK_PLAY_SEQUENCE_FACE_ENEMY ACTIVITY:ACT_RANGE_ATTACK2"
|
|
" TASK_RANGE_ATTACK2 0"
|
|
" "
|
|
" Interrupts"
|
|
)
|
|
|
|
//=========================================================
|
|
// Dodge Incoming vehicle
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_DODGE,
|
|
|
|
" Tasks"
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_HUNTER_FAIL_DODGE"
|
|
" TASK_HUNTER_FIND_DODGE_POSITION 0"
|
|
" TASK_HUNTER_DODGE 0"
|
|
""
|
|
" Interrupts"
|
|
)
|
|
|
|
//=========================================================
|
|
// Dodge Incoming vehicle
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_FAIL_DODGE,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
|
|
" TASK_FACE_ENEMY 0"
|
|
""
|
|
" Interrupts"
|
|
)
|
|
|
|
//==================================================
|
|
// > SCHED_HUNTER_CHARGE_ENEMY
|
|
// Rush at my enemy and head-butt them.
|
|
//==================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_CHARGE_ENEMY,
|
|
|
|
" Tasks"
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_HUNTER_FAIL_CHARGE_ENEMY"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_FACE_ENEMY 0"
|
|
" TASK_HUNTER_CHARGE 0"
|
|
""
|
|
" Interrupts"
|
|
" COND_TASK_FAILED"
|
|
" COND_ENEMY_DEAD"
|
|
)
|
|
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_FAIL_CHARGE_ENEMY,
|
|
|
|
" Tasks"
|
|
" TASK_HUNTER_CHARGE_DELAY 10"
|
|
)
|
|
|
|
//=========================================================
|
|
// Chase the enemy with intent to claw
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_CHASE_ENEMY_MELEE,
|
|
|
|
" Tasks"
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_ESTABLISH_LINE_OF_FIRE"
|
|
" 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_MELEE_ATTACK1"
|
|
" COND_CAN_MELEE_ATTACK2"
|
|
//" COND_TOO_CLOSE_TO_ATTACK"
|
|
" COND_LOST_ENEMY"
|
|
)
|
|
|
|
//=========================================================
|
|
// Chase my enemy, shoot or claw when possible to do so.
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_CHASE_ENEMY,
|
|
|
|
" Tasks"
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_ESTABLISH_LINE_OF_FIRE"
|
|
" 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_RANGE_ATTACK2"
|
|
" COND_CAN_MELEE_ATTACK1"
|
|
" COND_CAN_MELEE_ATTACK2"
|
|
" COND_TOO_CLOSE_TO_ATTACK"
|
|
" COND_LOST_ENEMY"
|
|
)
|
|
|
|
//=========================================================
|
|
// Move to a flanking position, then shoot if possible.
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_FLANK_ENEMY,
|
|
|
|
" Tasks"
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_ESTABLISH_LINE_OF_FIRE"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_HUNTER_BEGIN_FLANK 0"
|
|
" TASK_GET_FLANK_ARC_PATH_TO_ENEMY_LOS 30"
|
|
" TASK_HUNTER_ANNOUNCE_FLANK 0"
|
|
" TASK_RUN_PATH 0"
|
|
" TASK_WAIT_FOR_MOVEMENT 0"
|
|
" TASK_FACE_ENEMY 0"
|
|
//" TASK_HUNTER_END_FLANK 0"
|
|
""
|
|
" Interrupts"
|
|
" COND_NEW_ENEMY"
|
|
//" COND_CAN_RANGE_ATTACK1"
|
|
//" COND_CAN_RANGE_ATTACK2"
|
|
" COND_CAN_MELEE_ATTACK1"
|
|
" COND_CAN_MELEE_ATTACK2"
|
|
" COND_ENEMY_DEAD"
|
|
" COND_ENEMY_UNREACHABLE"
|
|
" COND_TOO_CLOSE_TO_ATTACK"
|
|
" COND_LOST_ENEMY"
|
|
)
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_COMBAT_FACE,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
|
|
" TASK_WAIT_FACE_ENEMY 1"
|
|
""
|
|
" Interrupts"
|
|
" COND_CAN_RANGE_ATTACK1"
|
|
" COND_CAN_RANGE_ATTACK2"
|
|
" COND_CAN_MELEE_ATTACK1"
|
|
" COND_CAN_MELEE_ATTACK2"
|
|
" COND_NEW_ENEMY"
|
|
" COND_ENEMY_DEAD"
|
|
)
|
|
|
|
//=========================================================
|
|
// Like the base class, only don't stop in the middle of
|
|
// swinging if the enemy is killed, hides, or new enemy.
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_MELEE_ATTACK1,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_FACE_ENEMY 0"
|
|
" TASK_MELEE_ATTACK1 0"
|
|
//" TASK_SET_SCHEDULE SCHEDULE:SCHED_HUNTER_POST_MELEE_WAIT"
|
|
""
|
|
" Interrupts"
|
|
)
|
|
|
|
//=========================================================
|
|
// In a fight with nothing to do. Make busy!
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_CHANGE_POSITION,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_WANDER 720432" // 6 feet to 36 feet
|
|
" TASK_RUN_PATH 0"
|
|
" TASK_HUNTER_WAIT_FOR_MOVEMENT_FACING_ENEMY 0"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_SET_SCHEDULE SCHEDULE:SCHED_HUNTER_CHANGE_POSITION_FINISH"
|
|
""
|
|
" Interrupts"
|
|
" COND_ENEMY_DEAD"
|
|
" COND_CAN_MELEE_ATTACK1"
|
|
" COND_CAN_MELEE_ATTACK2"
|
|
" COND_HEAR_DANGER"
|
|
" COND_HEAR_MOVE_AWAY"
|
|
" COND_NEW_ENEMY"
|
|
)
|
|
|
|
//=========================================================
|
|
// In a fight with nothing to do. Make busy!
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_CHANGE_POSITION_FINISH,
|
|
|
|
" Tasks"
|
|
" TASK_FACE_ENEMY 0"
|
|
" TASK_WAIT_FACE_ENEMY_RANDOM 5"
|
|
""
|
|
" Interrupts"
|
|
" COND_ENEMY_DEAD"
|
|
" COND_CAN_RANGE_ATTACK1"
|
|
" COND_CAN_RANGE_ATTACK2"
|
|
" COND_CAN_MELEE_ATTACK1"
|
|
" COND_CAN_MELEE_ATTACK2"
|
|
" COND_HEAR_DANGER"
|
|
" COND_HEAR_MOVE_AWAY"
|
|
" COND_NEW_ENEMY"
|
|
)
|
|
|
|
//=========================================================
|
|
// In a fight with nothing to do. Make busy!
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_SIDESTEP,
|
|
|
|
" Tasks"
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_HUNTER_FAIL_IMMEDIATE" // used because sched_fail includes a one second pause. ick!
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_HUNTER_FIND_SIDESTEP_POSITION 0"
|
|
" TASK_GET_PATH_TO_SAVEPOSITION 0"
|
|
" TASK_RUN_PATH 0"
|
|
" TASK_WAIT_FOR_MOVEMENT 0"
|
|
" TASK_FACE_ENEMY 0"
|
|
""
|
|
" Interrupts"
|
|
)
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_PATROL,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_WANDER 720432" // 6 feet to 36 feet
|
|
" TASK_WALK_PATH 0"
|
|
" TASK_WAIT_FOR_MOVEMENT 0"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_FACE_REASONABLE 0"
|
|
" TASK_WAIT_RANDOM 3"
|
|
""
|
|
" Interrupts"
|
|
" COND_ENEMY_DEAD"
|
|
" COND_LIGHT_DAMAGE"
|
|
" COND_HEAVY_DAMAGE"
|
|
" COND_HEAR_DANGER"
|
|
" COND_HEAR_COMBAT"
|
|
" COND_HEAR_PLAYER"
|
|
" COND_HEAR_BULLET_IMPACT"
|
|
" COND_HEAR_MOVE_AWAY"
|
|
" COND_NEW_ENEMY"
|
|
" COND_SEE_ENEMY"
|
|
" COND_CAN_RANGE_ATTACK1"
|
|
" COND_CAN_RANGE_ATTACK2"
|
|
" COND_CAN_MELEE_ATTACK1"
|
|
" COND_CAN_MELEE_ATTACK2"
|
|
)
|
|
|
|
//=========================================================
|
|
// Stagger because I got hit by something heavy
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_STAGGER,
|
|
|
|
" Tasks"
|
|
" TASK_HUNTER_STAGGER 0"
|
|
""
|
|
" Interrupts"
|
|
)
|
|
|
|
//=========================================================
|
|
// Run around randomly until we detect an enemy
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_PATROL_RUN,
|
|
|
|
" Tasks"
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_COMBAT_FACE"
|
|
" TASK_SET_ROUTE_SEARCH_TIME 5" // Spend 5 seconds trying to build a path if stuck
|
|
" TASK_GET_PATH_TO_RANDOM_NODE 200"
|
|
" TASK_RUN_PATH 0"
|
|
" TASK_WAIT_FOR_MOVEMENT 0"
|
|
""
|
|
" Interrupts"
|
|
" COND_CAN_RANGE_ATTACK1 "
|
|
" COND_CAN_RANGE_ATTACK2 "
|
|
" COND_CAN_MELEE_ATTACK1 "
|
|
" COND_CAN_MELEE_ATTACK2"
|
|
" COND_GIVE_WAY"
|
|
" COND_NEW_ENEMY"
|
|
" COND_HEAR_COMBAT"
|
|
" COND_HEAR_DANGER"
|
|
" COND_HEAR_PLAYER"
|
|
" COND_LIGHT_DAMAGE"
|
|
" COND_HEAVY_DAMAGE"
|
|
)
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_TAKE_COVER_FROM_ENEMY,
|
|
|
|
" Tasks"
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_HUNTER_CHASE_ENEMY_MELEE"
|
|
" TASK_HUNTER_CORNERED_TIMER 10.0"
|
|
" TASK_WAIT 0.0"
|
|
// " TASK_SET_TOLERANCE_DISTANCE 24"
|
|
// " TASK_FIND_COVER_FROM_ENEMY 0"
|
|
" TASK_FIND_FAR_NODE_COVER_FROM_ENEMY 200.0"
|
|
" TASK_RUN_PATH 0"
|
|
" TASK_HUNTER_CORNERED_TIMER 0.0"
|
|
// " TASK_CLEAR_FAIL_SCHEDULE 0" // not used because sched_fail includes a one second pause. ick!
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_HUNTER_FAIL_IMMEDIATE"
|
|
" TASK_WAIT_FOR_MOVEMENT 0"
|
|
" TASK_REMEMBER MEMORY:INCOVER"
|
|
" TASK_SET_SCHEDULE SCHEDULE:SCHED_HUNTER_HIDE_UNDER_COVER"
|
|
/*
|
|
" TASK_FACE_ENEMY 0"
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE" // Translated to cover
|
|
" TASK_WAIT 1"
|
|
*/
|
|
""
|
|
" Interrupts"
|
|
" COND_NEW_ENEMY"
|
|
" COND_HEAR_DANGER"
|
|
)
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_HIDE_UNDER_COVER,
|
|
|
|
" Tasks"
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_HUNTER_FAIL_IMMEDIATE" // used because sched_fail includes a one second pause. ick!
|
|
" TASK_FACE_ENEMY 0"
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE" // Translated to cover
|
|
" TASK_WAIT 1"
|
|
""
|
|
" Interrupts"
|
|
" COND_NEW_ENEMY"
|
|
" COND_HEAR_DANGER"
|
|
" COND_HAVE_ENEMY_LOS"
|
|
)
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_FOUND_ENEMY,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_FACE_ENEMY 0"
|
|
" TASK_PLAY_SEQUENCE_FACE_ENEMY ACTIVITY:ACT_HUNTER_FOUND_ENEMY"
|
|
""
|
|
" Interrupts"
|
|
" COND_LIGHT_DAMAGE"
|
|
" COND_HEAVY_DAMAGE"
|
|
)
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_FOUND_ENEMY_ACK,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_WAIT_RANDOM 0.75"
|
|
" TASK_FACE_ENEMY 0"
|
|
" TASK_PLAY_SEQUENCE_FACE_ENEMY ACTIVITY:ACT_HUNTER_FOUND_ENEMY_ACK"
|
|
""
|
|
" Interrupts"
|
|
" COND_LIGHT_DAMAGE"
|
|
" COND_HEAVY_DAMAGE"
|
|
)
|
|
|
|
//=========================================================
|
|
// An empty schedule that immediately bails out, faster than
|
|
// SCHED_FAIL which stops moving and waits for one second.
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_FAIL_IMMEDIATE,
|
|
|
|
" Tasks"
|
|
" TASK_WAIT 0"
|
|
|
|
)
|
|
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_GOTO_HINT,
|
|
" Tasks"
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_HUNTER_CLEAR_HINTNODE" // used because sched_fail includes a one second pause. ick!
|
|
" TASK_GET_PATH_TO_HINTNODE 1"
|
|
" TASK_WAIT_FOR_MOVEMENT 0"
|
|
" TASK_CLEAR_HINTNODE 0"
|
|
""
|
|
""
|
|
" Interrupts"
|
|
)
|
|
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_CLEAR_HINTNODE,
|
|
" Tasks"
|
|
" TASK_CLEAR_HINTNODE 0"
|
|
""
|
|
""
|
|
" Interrupts"
|
|
)
|
|
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_SIEGE_STAND,
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
|
|
" TASK_FACE_PLAYER 0"
|
|
" TASK_WAIT 10"
|
|
" TASK_WAIT_RANDOM 2"
|
|
" TASK_SET_SCHEDULE SCHEDULE:SCHED_HUNTER_CHANGE_POSITION_SIEGE"
|
|
""
|
|
""
|
|
" Interrupts"
|
|
" COND_SEE_PLAYER"
|
|
" COND_NEW_ENEMY"
|
|
)
|
|
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_HUNTER_CHANGE_POSITION_SIEGE,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_WANDER 2400480"
|
|
" TASK_RUN_PATH 0"
|
|
" TASK_WAIT_FOR_MOVEMENT 0"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
|
|
" TASK_FACE_PLAYER 0"
|
|
""
|
|
" Interrupts"
|
|
" COND_NEW_ENEMY"
|
|
)
|
|
|
|
// formula is MIN_DIST * 10000 + MAX_DIST
|
|
|
|
AI_END_CUSTOM_NPC()
|