//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "baseanimating.h"
#include "ai_network.h"
#include "ai_default.h"
#include "ai_schedule.h"
#include "ai_hull.h"
#include "ai_node.h"
#include "ai_task.h"
#include "ai_motor.h"
#include "entitylist.h"
#include "basecombatweapon.h"
#include "soundenvelope.h"
#include "gib.h"
#include "gamerules.h"
#include "ammodef.h"
#include "cbasehelicopter.h"
#include "npcevent.h"
#include "ndebugoverlay.h"
#include "decals.h"
#include "explode.h" // temp (sjb)
#include "smoke_trail.h" // temp (sjb)
#include "IEffects.h"
#include "vstdlib/random.h"
#include "engine/IEngineSound.h"
#include "ar2_explosion.h"
#include "te_effect_dispatch.h"
#include "rope.h"
#include "effect_dispatch_data.h"
#include "trains.h"
#include "globals.h"
#include "physics_prop_ragdoll.h"
#include "iservervehicle.h"
#include "soundent.h"
#include "npc_citizen17.h"
#include "physics_saverestore.h"
#include "hl2_shareddefs.h"
#include "props.h"
#include "npc_attackchopper.h"
#include "citadel_effects_shared.h"
#include "eventqueue.h"
#include "beam_flags.h"
#include "ai_eventresponse.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define GUNSHIP_MSG_BIG_SHOT 1
#define GUNSHIP_MSG_STREAKS 2
#define GUNSHIP_NUM_DAMAGE_OUTPUTS 4
extern short g_sModelIndexFireball; // holds the index for the fireball
int g_iGunshipEffectIndex = -1;
#define GUNSHIP_ACCEL_RATE 500
// Spawnflags
#define SF_GUNSHIP_NO_GROUND_ATTACK ( 1 << 12 )
#define SF_GUNSHIP_USE_CHOPPER_MODEL ( 1 << 13 )
ConVar sk_gunship_burst_size("sk_gunship_burst_size", "15" );
ConVar sk_gunship_burst_min("sk_gunship_burst_min", "800" );
ConVar sk_gunship_burst_dist("sk_gunship_burst_dist", "768" );
// Number of times the gunship must be struck by explosive damage
ConVar sk_gunship_health_increments( "sk_gunship_health_increments", "0" );
/*
Wedge's notes:
Gunship should move its head according to flight model when the target is behind the gunship,
or when the target is too far away to shoot at. Otherwise, the head should aim at the target.
Negative angvelocity.y is a RIGHT turn.
Negative angvelocity.x is UP
*/
#define GUNSHIP_AP_MUZZLE 5
#define GUNSHIP_MAX_SPEED 1056.0f
#define GUNSHIP_MAX_FIRING_SPEED 200.0f
#define GUNSHIP_MIN_ROCKET_DIST 1000.0f
#define GUNSHIP_MAX_GUN_DIST 2000.0f
#define GUNSHIP_ARRIVE_DIST 128.0f
#define GUNSHIP_HOVER_SPEED 300.0f // play hover animation if moving slower than this.
#define GUNSHIP_AE_THRUST 1
#define GUNSHIP_HEAD_MAX_UP -65
#define GUNSHIP_HEAD_MAX_DOWN 60
#define GUNSHIP_HEAD_MAX_LEFT 60
#define GUNSHIP_HEAD_MAX_RIGHT -60
#define BASE_STITCH_VELOCITY 800 //Units per second
#define MAX_STITCH_VELOCITY 1000 //Units per second
#define GUNSHIP_LEAD_DISTANCE 800.0f
#define GUNSHIP_AVOID_DIST 512.0f
#define GUNSHIP_STITCH_MIN 512.0f
#define GUNSHIP_MIN_CHASE_DIST_DIFF 128.0f // Distance threshold used to determine when a target has moved enough to update our navigation to it
#define MIN_GROUND_ATTACK_DIST 500.0f // Minimum distance a target has to be for the gunship to consider using the ground attack weapon
#define MIN_GROUND_ATTACK_HEIGHT_DIFF 128.0f // Target's position and hit position must be within this threshold vertically
#define GUNSHIP_WASH_ALTITUDE 1024.0f
#define GUNSHIP_MIN_DAMAGE_THRESHOLD 50.0f
#define GUNSHIP_INNER_NAV_DIST 400.0f
#define GUNSHIP_OUTER_NAV_DIST 800.0f
#define GUNSHIP_BELLYBLAST_TARGET_HEIGHT 512.0 // Height above targets that the gunship wants to be when bellyblasting
#define GUNSHIP_MISSILE_MAX_RESPONSE_TIME 0.4
#define GUNSHIP_MAX_HITS_PER_BURST 5
#define GUNSHIP_FLARE_IGNORE_TIME 6.0
//=====================================
// Custom activities
//=====================================
Activity ACT_GUNSHIP_PATROL;
Activity ACT_GUNSHIP_HOVER;
Activity ACT_GUNSHIP_CRASH;
#define GUNSHIP_DEBUG_LEADING 1
#define GUNSHIP_DEBUG_PATH 2
#define GUNSHIP_DEBUG_STITCHING 3
#define GUNSHIP_DEBUG_BELLYBLAST 4
ConVar g_debug_gunship( "g_debug_gunship", "0", FCVAR_CHEAT );
//-----------------------------------------------------------------------------
// Purpose: Dying gunship ragdoll controller
//-----------------------------------------------------------------------------
class CGunshipRagdollMotion : public IMotionEvent
{
DECLARE_SIMPLE_DATADESC();
public:
virtual simresult_e Simulate( IPhysicsMotionController *pController, IPhysicsObject *pObject, float deltaTime, Vector &linear, AngularImpulse &angular )
{
linear = Vector(0,0,400);
angular = Vector(0,600,100);
return SIM_GLOBAL_ACCELERATION;
}
};
BEGIN_SIMPLE_DATADESC( CGunshipRagdollMotion )
END_DATADESC()
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CTargetGunshipCrash : public CPointEntity
{
DECLARE_CLASS( CTargetGunshipCrash, CPointEntity );
public:
DECLARE_DATADESC();
void InputEnable( inputdata_t &inputdata )
{
m_bDisabled = false;
}
void InputDisable( inputdata_t &inputdata )
{
m_bDisabled = true;
}
bool IsDisabled( void )
{
return m_bDisabled;
}
void GunshipCrashedOnTarget( void )
{
m_OnCrashed.FireOutput( this, this );
}
private:
bool m_bDisabled;
COutputEvent m_OnCrashed;
};
LINK_ENTITY_TO_CLASS( info_target_gunshipcrash, CTargetGunshipCrash );
BEGIN_DATADESC( CTargetGunshipCrash )
DEFINE_FIELD( m_bDisabled, FIELD_BOOLEAN ),
// Inputs
DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
// Outputs
DEFINE_OUTPUT( m_OnCrashed, "OnCrashed" ),
END_DATADESC()
//===================================================================
// Gunship - the combine dugongic like attack vehicle.
//===================================================================
class CNPC_CombineGunship : public CBaseHelicopter
{
public:
DECLARE_CLASS( CNPC_CombineGunship, CBaseHelicopter );
CNPC_CombineGunship( void );
~CNPC_CombineGunship( void );
DECLARE_DATADESC();
DECLARE_SERVERCLASS();
DEFINE_CUSTOM_AI;
void PlayPatrolLoop( void );
void PlayAngryLoop( void );
void Spawn( void );
void Precache( void );
void OnRestore( void );
void PrescheduleThink( void );
void HelicopterPostThink( void );
void StopLoopingSounds( void );
bool IsValidEnemy( CBaseEntity *pEnemy );
void GatherEnemyConditions( CBaseEntity *pEnemy );
void Flight( void );
bool FVisible( CBaseEntity *pEntity, int traceMask = MASK_BLOCKLOS, CBaseEntity **ppBlocker = NULL );
int OnTakeDamage_Alive( const CTakeDamageInfo &info );
void FireDamageOutputsUpto( int iDamageNumber );
virtual float GetAcceleration( void ) { return 15; }
virtual void MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType );
virtual void DoImpactEffect( trace_t &tr, int nDamageType );
void MoveHead( void );
void UpdateDesiredPosition( void );
void DoCombat( void );
bool ChooseEnemy( void );
void DoMuzzleFlash( void );
void Ping( void );
void FireCannonRound( void );
// Gunship death process
void Event_Killed( const CTakeDamageInfo &info );
void BeginCrash( void ); // I'm going to go to a crash point and die there
void BeginDestruct( void ); // I want to die now, so create my ragdoll
void SelfDestruct( void ); // I'm now fully dead, so remove myself.
void CreateSmokeTrail( void );
bool FindNearestGunshipCrash( void );
int BloodColor( void ) { return DONT_BLEED; }
void GibMonster( void );
void UpdateRotorSoundPitch( int iPitch );
void InitializeRotorSound( void );
void ApplyGeneralDrag( void );
void ApplySidewaysDrag( const Vector &vecRight );
void TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator );
void UpdateEnemyTarget( void );
Vector GetEnemyTarget( void );
Vector GetMissileTarget( void );
float GroundDistToPosition( const Vector &pos );
bool FireGun( void );
bool IsTargettingMissile( void );
Class_T Classify( void ) { return CLASS_COMBINE_GUNSHIP; } // for now
float GetAutoAimRadius() { return 144.0f; }
// Input functions
void InputSetPenetrationDepth( inputdata_t &inputdata );
void InputOmniscientOn( inputdata_t &inputdata );
void InputOmniscientOff( inputdata_t &inputdata );
void InputBlindfireOn( inputdata_t &inputdata );
void InputBlindfireOff( inputdata_t &inputdata );
void InputSelfDestruct( inputdata_t &inputdata );
void InputSetDockingBBox( inputdata_t &inputdata );
void InputSetNormalBBox( inputdata_t &inputdata );
void InputEnableGroundAttack( inputdata_t &inputdata );
void InputDisableGroundAttack( inputdata_t &inputdata );
void InputDoGroundAttack( inputdata_t &inputdata );
//NOTENOTE: I'm rather queasy about adding these, as they can lead to nasty bugs...
void InputBecomeInvulnerable( inputdata_t &inputdata );
void InputBecomeVulnerable( inputdata_t &inputdata );
bool PoseGunTowardTargetDirection( const Vector &vTargetDir );
void StartCannonBurst( int iBurstSize );
void StopCannonBurst( void );
bool CheckGroundAttack( void );
void StartGroundAttack( void );
void StopGroundAttack( bool bDoAttack );
Vector GetGroundAttackHitPosition( void );
void DoGroundAttackExplosion( void );
void DrawRotorWash( float flAltitude, const Vector &vecRotorOrigin );
void ManageWarningBeam( void );
void DoBellyBlastDamage( trace_t &tr, Vector vMins, Vector vMaxs );
// Updates the facing direction
void UpdateFacingDirection( void );
void CreateBellyBlastEnergyCore( void );
protected:
// Because the combine gunship is a leaf class, we can use
// static variables to store this information, and save some memory.
// Should the gunship end up having inheritors, their activate may
// stomp these numbers, in which case you should make these ordinary members
// again.
static int m_poseFlex_Horz, m_poseFlex_Vert, m_posePitch, m_poseYaw, m_poseFin_Accel, m_poseFin_Sway;
static int m_poseWeapon_Pitch, m_poseWeapon_Yaw;
static bool m_sbStaticPoseParamsLoaded;
virtual void PopulatePoseParameters( void );
private:
// Outputs
COutputEvent m_OnFireCannon;
COutputEvent m_OnCrashed;
COutputEvent m_OnFirstDamage; // First damage tick
COutputEvent m_OnSecondDamage;
COutputEvent m_OnThirdDamage;
COutputEvent m_OnFourthDamage;
// Keep track of which damage outputs we've fired. This is necessary
// to ensure that the game doesn't break if a mapmaker has outputs that
// must be fired on gunships, and the player switches skill levels
// midway through a gunship battle.
bool m_bDamageOutputsFired[GUNSHIP_NUM_DAMAGE_OUTPUTS];
float m_flNextGroundAttack; // Time to wait before the next ground attack
bool m_bIsGroundAttacking; // Denotes that we are ground attacking
bool m_bCanGroundAttack; // Denotes whether we can ground attack or not
float m_flGroundAttackTime; // Delay before blast happens from ground attack
CHandle<SmokeTrail> m_pSmokeTrail;
EHANDLE m_hGroundAttackTarget;
CSoundPatch *m_pAirExhaustSound;
CSoundPatch *m_pAirBlastSound;
CSoundPatch *m_pCannonSound;
CBaseEntity *m_pRotorWashModel;
QAngle m_vecAngAcceleration;
float m_flEndDestructTime;
int m_iDoSmokePuff;
int m_iAmmoType;
int m_iBurstSize;
bool m_fBlindfire;
bool m_fOmniscient;
bool m_bIsFiring;
int m_iBurstHits;
bool m_bPreFire;
bool m_bInvulnerable;
float m_flTimeNextPing;
float m_flPenetrationDepth;
float m_flDeltaT;
float m_flTimeNextAttack;
float m_flNextSeeEnemySound;
float m_flNextRocket;
float m_flBurstDelay;
Vector m_vecAttackPosition;
Vector m_vecAttackVelocity;
// Used when the gunships using the chopper model
Vector m_angGun;
// For my death throes
IPhysicsMotionController *m_pCrashingController;
CGunshipRagdollMotion m_crashCallback;
EHANDLE m_hRagdoll;
CHandle<CTargetGunshipCrash> m_hCrashTarget;
float m_flNextGunshipCrashFind;
CHandle<CCitadelEnergyCore> m_hEnergyCore;
CNetworkVector( m_vecHitPos );
// If true, playing patrol loop.
// Else, playing angry.
bool m_fPatrolLoopPlaying;
};
LINK_ENTITY_TO_CLASS( npc_combinegunship, CNPC_CombineGunship );
IMPLEMENT_SERVERCLASS_ST( CNPC_CombineGunship, DT_CombineGunship )
SendPropVector(SENDINFO(m_vecHitPos), -1, SPROP_COORD),
END_SEND_TABLE()
BEGIN_DATADESC( CNPC_CombineGunship )
DEFINE_ENTITYFUNC( FlyTouch ),
DEFINE_FIELD( m_flNextGroundAttack,FIELD_TIME ),
DEFINE_FIELD( m_bIsGroundAttacking,FIELD_BOOLEAN ),
DEFINE_FIELD( m_bCanGroundAttack, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flGroundAttackTime,FIELD_TIME ),
DEFINE_FIELD( m_pRotorWashModel, FIELD_CLASSPTR ),
DEFINE_FIELD( m_pSmokeTrail, FIELD_EHANDLE ),
DEFINE_FIELD( m_hGroundAttackTarget, FIELD_EHANDLE ),
DEFINE_SOUNDPATCH( m_pAirExhaustSound ),
DEFINE_SOUNDPATCH( m_pAirBlastSound ),
DEFINE_SOUNDPATCH( m_pCannonSound ),
DEFINE_FIELD( m_vecAngAcceleration,FIELD_VECTOR ),
DEFINE_FIELD( m_flDeltaT, FIELD_FLOAT ),
DEFINE_FIELD( m_flTimeNextAttack, FIELD_TIME ),
DEFINE_FIELD( m_flNextSeeEnemySound, FIELD_TIME ),
DEFINE_FIELD( m_flEndDestructTime, FIELD_TIME ),
DEFINE_FIELD( m_flNextRocket, FIELD_TIME ),
DEFINE_FIELD( m_iDoSmokePuff, FIELD_INTEGER ),
DEFINE_FIELD( m_iAmmoType, FIELD_INTEGER ),
DEFINE_FIELD( m_iBurstSize, FIELD_INTEGER ),
DEFINE_FIELD( m_flBurstDelay, FIELD_FLOAT ),
DEFINE_FIELD( m_fBlindfire, FIELD_BOOLEAN ),
DEFINE_FIELD( m_fOmniscient, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bIsFiring, FIELD_BOOLEAN ),
DEFINE_FIELD( m_iBurstHits, FIELD_INTEGER ),
DEFINE_FIELD( m_flTimeNextPing, FIELD_TIME ),
DEFINE_FIELD( m_flPenetrationDepth,FIELD_FLOAT ),
DEFINE_FIELD( m_vecAttackPosition, FIELD_VECTOR ),
DEFINE_FIELD( m_vecAttackVelocity, FIELD_VECTOR ),
DEFINE_FIELD( m_angGun, FIELD_VECTOR ),
DEFINE_PHYSPTR( m_pCrashingController ),
DEFINE_EMBEDDED( m_crashCallback ),
DEFINE_FIELD( m_hRagdoll, FIELD_EHANDLE ),
DEFINE_FIELD( m_hCrashTarget, FIELD_EHANDLE ),
DEFINE_FIELD( m_vecHitPos, FIELD_VECTOR ),
DEFINE_FIELD( m_fPatrolLoopPlaying,FIELD_BOOLEAN ),
DEFINE_FIELD( m_bPreFire, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bInvulnerable, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flNextGunshipCrashFind, FIELD_TIME ),
DEFINE_FIELD( m_hEnergyCore, FIELD_EHANDLE ),
DEFINE_ARRAY( m_bDamageOutputsFired, FIELD_BOOLEAN, GUNSHIP_NUM_DAMAGE_OUTPUTS ),
// Function pointers
DEFINE_INPUTFUNC( FIELD_VOID, "OmniscientOn", InputOmniscientOn ),
DEFINE_INPUTFUNC( FIELD_VOID, "OmniscientOff", InputOmniscientOff ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetPenetrationDepth", InputSetPenetrationDepth ),
DEFINE_INPUTFUNC( FIELD_VOID, "BlindfireOn", InputBlindfireOn ),
DEFINE_INPUTFUNC( FIELD_VOID, "BlindfireOff", InputBlindfireOff ),
DEFINE_INPUTFUNC( FIELD_VOID, "SelfDestruct", InputSelfDestruct ),
DEFINE_INPUTFUNC( FIELD_VOID, "SetDockingBBox", InputSetDockingBBox ),
DEFINE_INPUTFUNC( FIELD_VOID, "SetNormalBBox", InputSetNormalBBox ),
DEFINE_INPUTFUNC( FIELD_VOID, "EnableGroundAttack", InputEnableGroundAttack ),
DEFINE_INPUTFUNC( FIELD_VOID, "DisableGroundAttack", InputDisableGroundAttack ),
DEFINE_INPUTFUNC( FIELD_STRING, "DoGroundAttack", InputDoGroundAttack ),
DEFINE_OUTPUT( m_OnFireCannon, "OnFireCannon" ),
DEFINE_OUTPUT( m_OnFirstDamage, "OnFirstDamage" ),
DEFINE_OUTPUT( m_OnSecondDamage, "OnSecondDamage" ),
DEFINE_OUTPUT( m_OnThirdDamage, "OnThirdDamage" ),
DEFINE_OUTPUT( m_OnFourthDamage, "OnFourthDamage" ),
DEFINE_OUTPUT( m_OnCrashed, "OnCrashed" ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CNPC_CombineGunship::CNPC_CombineGunship( void )
{
m_hGroundAttackTarget = NULL;
m_pSmokeTrail = NULL;
m_iAmmoType = -1;
m_pCrashingController = NULL;
m_hRagdoll = NULL;
m_hCrashTarget = NULL;
}
void CNPC_CombineGunship::CreateBellyBlastEnergyCore( void )
{
CCitadelEnergyCore *pCore = static_cast<CCitadelEnergyCore*>( CreateEntityByName( "env_citadel_energy_core" ) );
if ( pCore == NULL )
return;
m_hEnergyCore = pCore;
int iAttachment = LookupAttachment( "BellyGun" );
Vector vOrigin;
QAngle vAngle;
GetAttachment( iAttachment, vOrigin, vAngle );
pCore->SetAbsOrigin( vOrigin );
pCore->SetAbsAngles( vAngle );
DispatchSpawn( pCore );
pCore->Activate();
pCore->SetParent( this, iAttachment );
pCore->SetScale( 4.0f );
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CNPC_CombineGunship::Spawn( void )
{
Precache( );
if ( HasSpawnFlags( SF_GUNSHIP_USE_CHOPPER_MODEL ) )
{
SetModel( "models/combine_helicopter.mdl" );
}
else
{
SetModel( "models/gunship.mdl" );
}
ExtractBbox( SelectHeaviestSequence( ACT_GUNSHIP_PATROL ), m_cullBoxMins, m_cullBoxMaxs );
BaseClass::Spawn();
InitPathingData( GUNSHIP_ARRIVE_DIST, GUNSHIP_MIN_CHASE_DIST_DIFF, sk_gunship_burst_min.GetFloat() );
AddEFlags( EFL_NO_DISSOLVE | EFL_NO_MEGAPHYSCANNON_RAGDOLL | EFL_NO_PHYSCANNON_INTERACTION );
m_takedamage = DAMAGE_YES;
SetHullType(HULL_LARGE_CENTERED);
SetHullSizeNormal();
m_iMaxHealth = m_iHealth = 100;
m_flFieldOfView = -0.707; // 270 degrees
m_fHelicopterFlags |= BITS_HELICOPTER_GUN_ON;
InitBoneControllers();
InitCustomSchedules();
SetActivity( (Activity)ACT_GUNSHIP_PATROL );
SetCollisionGroup( HL2COLLISION_GROUP_GUNSHIP );
m_flMaxSpeed = GUNSHIP_MAX_SPEED;
m_flMaxSpeedFiring = GUNSHIP_MAX_SPEED;
m_flTimeNextAttack = gpGlobals->curtime;
m_flNextSeeEnemySound = gpGlobals->curtime;
// Init the pose parameters
SetPoseParameter( "flex_horz", 0 );
SetPoseParameter( "flex_vert", 0 );
SetPoseParameter( "fin_accel", 0 );
SetPoseParameter( "fin_sway", 0 );
if( m_iAmmoType == -1 )
{
// Since there's no weapon to index the ammo type,
// do it manually here.
m_iAmmoType = GetAmmoDef()->Index("CombineCannon");
}
//!!!HACKHACK
// This tricks the AI code that constantly complains that the gunship has no schedule.
SetSchedule( SCHED_IDLE_STAND );
AddRelationship( "env_flare D_LI 9", NULL );
AddRelationship( "rpg_missile D_HT 99", NULL );
m_flTimeNextPing = gpGlobals->curtime + 2;
m_flPenetrationDepth = 24;
m_flBurstDelay = 2.0f;
// Blindfire and Omniscience default to off
m_fBlindfire = false;
m_fOmniscient = false;
m_bIsFiring = false;
m_bPreFire = false;
m_bInvulnerable = false;
// See if we should start being able to attack
m_bCanGroundAttack = ( m_spawnflags & SF_GUNSHIP_NO_GROUND_ATTACK ) ? false : true;
m_flEndDestructTime = 0;
m_iBurstSize = 0;
m_iBurstHits = 0;
// Do not dissolve
AddEFlags( EFL_NO_DISSOLVE );
for ( int i = 0; i < GUNSHIP_NUM_DAMAGE_OUTPUTS; i++ )
{
m_bDamageOutputsFired[i] = false;
}
CapabilitiesAdd( bits_CAP_SQUAD);
if ( hl2_episodic.GetBool() == true )
{
CreateBellyBlastEnergyCore();
}
// Allows autoaim to help attack the gunship.
if( g_pGameRules->GetAutoAimMode() == AUTOAIM_ON_CONSOLE )
{
AddFlag( FL_AIMTARGET );
}
}
//-----------------------------------------------------------------------------
// Purpose: Restore the motion controller
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::OnRestore( void )
{
BaseClass::OnRestore();
if ( m_pCrashingController )
{
m_pCrashingController->SetEventHandler( &m_crashCallback );
}
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CNPC_CombineGunship::Precache( void )
{
if ( HasSpawnFlags( SF_GUNSHIP_USE_CHOPPER_MODEL ) )
{
PrecacheModel( "models/combine_helicopter.mdl" );
Chopper_PrecacheChunks( this );
}
else
{
PrecacheModel("models/gunship.mdl");
}
PrecacheModel("sprites/lgtning.vmt");
PrecacheMaterial( "effects/ar2ground2" );
PrecacheMaterial( "effects/blueblackflash" );
PrecacheScriptSound( "NPC_CombineGunship.SearchPing" );
PrecacheScriptSound( "NPC_CombineGunship.PatrolPing" );
PrecacheScriptSound( "NPC_Strider.Charge" );
PrecacheScriptSound( "NPC_Strider.Shoot" );
PrecacheScriptSound( "NPC_CombineGunship.SeeEnemy" );
PrecacheScriptSound( "NPC_CombineGunship.CannonStartSound" );
PrecacheScriptSound( "NPC_CombineGunship.Explode");
PrecacheScriptSound( "NPC_CombineGunship.Pain" );
PrecacheScriptSound( "NPC_CombineGunship.CannonStopSound" );
PrecacheScriptSound( "NPC_CombineGunship.DyingSound" );
PrecacheScriptSound( "NPC_CombineGunship.CannonSound" );
PrecacheScriptSound( "NPC_CombineGunship.RotorSound" );
PrecacheScriptSound( "NPC_CombineGunship.ExhaustSound" );
PrecacheScriptSound( "NPC_CombineGunship.RotorBlastSound" );
if ( hl2_episodic.GetBool() == true )
{
UTIL_PrecacheOther( "env_citadel_energy_core" );
g_iGunshipEffectIndex = PrecacheModel( "sprites/physbeam.vmt" );
}
PropBreakablePrecacheAll( MAKE_STRING("models/gunship.mdl") );
BaseClass::Precache();
}
//-----------------------------------------------------------------------------
// Purpose: Cache whatever pose parameters we intend to use
//-----------------------------------------------------------------------------
bool CNPC_CombineGunship::m_sbStaticPoseParamsLoaded = false;
int CNPC_CombineGunship::m_poseFlex_Horz = 0;
int CNPC_CombineGunship::m_poseFlex_Vert = 0;
int CNPC_CombineGunship::m_posePitch = 0;
int CNPC_CombineGunship::m_poseYaw = 0;
int CNPC_CombineGunship::m_poseFin_Accel = 0;
int CNPC_CombineGunship::m_poseFin_Sway = 0;
int CNPC_CombineGunship::m_poseWeapon_Pitch = 0;
int CNPC_CombineGunship::m_poseWeapon_Yaw = 0;
void CNPC_CombineGunship::PopulatePoseParameters( void )
{
if (!m_sbStaticPoseParamsLoaded)
{
m_poseFlex_Horz = LookupPoseParameter( "flex_horz");
m_poseFlex_Vert = LookupPoseParameter( "flex_vert" );
m_posePitch = LookupPoseParameter( "pitch" );
m_poseYaw = LookupPoseParameter( "yaw" );
m_poseFin_Accel = LookupPoseParameter( "fin_accel" );
m_poseFin_Sway = LookupPoseParameter( "fin_sway" );
m_poseWeapon_Pitch = LookupPoseParameter( "weapon_pitch" );
m_poseWeapon_Yaw = LookupPoseParameter( "weapon_yaw" );
m_sbStaticPoseParamsLoaded = true;
}
BaseClass::PopulatePoseParameters();
}
//------------------------------------------------------------------------------
// Purpose :
//------------------------------------------------------------------------------
CNPC_CombineGunship::~CNPC_CombineGunship(void)
{
StopLoopingSounds();
if ( m_pCrashingController )
{
physenv->DestroyMotionController( m_pCrashingController );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::Ping( void )
{
if( IsCrashing() )
return;
if( GetEnemy() != NULL )
{
if( !HasCondition(COND_SEE_ENEMY) && gpGlobals->curtime > m_flTimeNextPing )
{
EmitSound( "NPC_CombineGunship.SearchPing" );
m_flTimeNextPing = gpGlobals->curtime + 3;
}
}
else
{
if( gpGlobals->curtime > m_flTimeNextPing )
{
EmitSound( "NPC_CombineGunship.PatrolPing" );
m_flTimeNextPing = gpGlobals->curtime + 3;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &pos -
// Output : float
//-----------------------------------------------------------------------------
float CNPC_CombineGunship::GroundDistToPosition( const Vector &pos )
{
Vector vecDiff;
VectorSubtract( GetAbsOrigin(), pos, vecDiff );
// Only interested in the 2d dist
vecDiff.z = 0;
return vecDiff.Length();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::PlayPatrolLoop( void )
{
m_fPatrolLoopPlaying = true;
/*
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundChangeVolume( m_pPatrolSound, 1.0, 1.0 );
controller.SoundChangeVolume( m_pAngrySound, 0.0, 1.0 );
*/
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::PlayAngryLoop( void )
{
m_fPatrolLoopPlaying = false;
/*
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundChangeVolume( m_pPatrolSound, 0.0, 1.0 );
controller.SoundChangeVolume( m_pAngrySound, 1.0, 1.0 );
*/
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::HelicopterPostThink( void )
{
// After HelicopterThink()
if ( HasCondition( COND_ENEMY_DEAD ) )
{
if ( m_bIsFiring )
{
// Fire more shots at the dead body for effect
if ( m_iBurstSize > 8 )
{
m_iBurstSize = 8;
}
}
// Fade out search sound, fade in patrol sound.
PlayPatrolLoop();
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Vector
//-----------------------------------------------------------------------------
Vector CNPC_CombineGunship::GetGroundAttackHitPosition( void )
{
trace_t tr;
Vector vecShootPos, vecShootDir;
GetAttachment( "BellyGun", vecShootPos, &vecShootDir, NULL, NULL );
AI_TraceLine( vecShootPos, vecShootPos + Vector( 0, 0, -MAX_TRACE_LENGTH ), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
if ( m_hGroundAttackTarget )
{
return Vector( tr.endpos.x, tr.endpos.y, m_hGroundAttackTarget->WorldSpaceCenter().z );
}
return tr.endpos;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_CombineGunship::CheckGroundAttack( void )
{
if ( m_bCanGroundAttack == false )
return false;
if ( m_bIsGroundAttacking )
return false;
// Must have an enemy
if ( GetEnemy() == NULL )
return false;
// Must not have done it too recently
if ( m_flNextGroundAttack > gpGlobals->curtime )
return false;
Vector predPos, predDest;
// Find where the enemy is most likely to be in two seconds
UTIL_PredictedPosition( GetEnemy(), 1.0f, &predPos );
UTIL_PredictedPosition( this, 1.0f, &predDest );
Vector predGap = ( predDest - predPos );
predGap.z = 0;
float predDistance = predGap.Length();
// Must be within distance
if ( predDistance > MIN_GROUND_ATTACK_DIST )
return false;
// Can't ground attack missiles
if ( IsTargettingMissile() )
return false;
//FIXME: Check to make sure we're not firing too far above or below the target
if ( fabs( GetGroundAttackHitPosition().z - GetEnemy()->WorldSpaceCenter().z ) > MIN_GROUND_ATTACK_HEIGHT_DIFF )
return false;
//FIXME: Check for ground movement capabilities?
//TODO: Check for friendly-fire
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::StartGroundAttack( void )
{
// Mark us as attacking
m_bIsGroundAttacking = true;
m_flGroundAttackTime = gpGlobals->curtime + 3.0f;
// Setup the attack effects
Vector vecShootPos;
GetAttachment( "BellyGun", vecShootPos );
EntityMessageBegin( this, true );
WRITE_BYTE( GUNSHIP_MSG_STREAKS );
WRITE_VEC3COORD( vecShootPos );
MessageEnd();
CPASAttenuationFilter filter2( this, "NPC_Strider.Charge" );
EmitSound( filter2, entindex(), "NPC_Strider.Charge" );
Vector endpos = GetGroundAttackHitPosition();
CSoundEnt::InsertSound ( SOUND_DANGER, endpos, 1024, 0.5f );
if ( hl2_episodic.GetBool() == true )
{
if ( m_hEnergyCore )
{
variant_t value;
value.SetFloat( 3.0f );
g_EventQueue.AddEvent( m_hEnergyCore, "StartCharge", value, 0, this, this );
}
}
}
#define GUNSHIP_BELLY_BLAST_RADIUS 256.0f
#define BELLY_BLAST_MAX_PUNCH 5
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::ManageWarningBeam( void )
{
Vector vecSrc, vecShootDir;
GetAttachment( "BellyGun", vecSrc, NULL, NULL, NULL );
trace_t tr;
CTraceFilterSkipTwoEntities filter( m_hGroundAttackTarget, this, COLLISION_GROUP_NONE );
UTIL_TraceLine( vecSrc, m_vecHitPos, MASK_SOLID, &filter, &tr );
int iPunch = 0;
while ( tr.endpos != m_vecHitPos )
{
iPunch++;
if ( iPunch > BELLY_BLAST_MAX_PUNCH )
break;
if ( tr.fraction != 1.0 )
{
if ( tr.m_pEnt )
{
CTakeDamageInfo info( this, this, 1.0f, DMG_ENERGYBEAM );
Vector vTargetDir = tr.m_pEnt->BodyTarget( tr.endpos, false ) - tr.endpos;
VectorNormalize( vTargetDir );
info.SetDamagePosition( tr.endpos + ( tr.plane.normal * 64.0f ) );
info.SetDamageForce( vTargetDir * 100 );
if ( tr.m_pEnt->m_takedamage != DAMAGE_NO )
{
// Deal damage
tr.m_pEnt->TakeDamage( info );
}
}
Vector vDir = m_vecHitPos - vecSrc;
VectorNormalize( vDir );
Vector vStartPunch = tr.endpos + vDir * 1;
UTIL_TraceLine( vStartPunch, m_vecHitPos, MASK_SOLID, &filter, &tr );
if ( tr.startsolid )
{
float flLength = (vStartPunch - tr.endpos).Length();
Vector vEndPunch = vStartPunch + vDir * ( flLength * tr.fractionleftsolid );
UTIL_TraceLine( vEndPunch, m_vecHitPos, MASK_SOLID, &filter, &tr );
trace_t tr2;
UTIL_TraceLine( vEndPunch, vEndPunch - vDir * 2, MASK_SOLID, &filter, &tr2 );
if ( (m_flGroundAttackTime - gpGlobals->curtime) <= 2.0f )
{
g_pEffects->EnergySplash( tr2.endpos + vDir * 8, tr2.plane.normal, true );
}
g_pEffects->Sparks( tr2.endpos, 3.0f - (m_flGroundAttackTime-gpGlobals->curtime), 3.5f - (m_flGroundAttackTime-gpGlobals->curtime), &tr2.plane.normal );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::DoBellyBlastDamage( trace_t &tr, Vector vMins, Vector vMaxs )
{
CBaseEntity* pList[100];
if ( g_debug_gunship.GetInt() == GUNSHIP_DEBUG_BELLYBLAST )
{
NDebugOverlay::Box( tr.endpos, vMins, vMaxs, 255, 255, 0, true, 5.0f );
}
int count = UTIL_EntitiesInBox( pList, 100, tr.endpos + vMins, tr.endpos + vMaxs, 0 );
for ( int i = 0; i < count; i++ )
{
CBaseEntity *pEntity = pList[i];
if ( pEntity == this )
continue;
if ( pEntity->m_takedamage == DAMAGE_NO )
continue;
float damage = 150;
if ( pEntity->IsPlayer() )
{
float damageDist = ( pEntity->GetAbsOrigin() - tr.endpos ).Length();
damage = RemapValClamped( damageDist, 0, 300, 200, 0 );
}
CTakeDamageInfo info( this, this, damage, DMG_DISSOLVE );
Vector vTargetDir = pEntity->BodyTarget( tr.endpos, false ) - tr.endpos;
VectorNormalize( vTargetDir );
info.SetDamagePosition( tr.endpos + ( tr.plane.normal * 64.0f ) );
info.SetDamageForce( vTargetDir * 25000 );
// Deal damage
pEntity->TakeDamage( info );
trace_t groundTrace;
UTIL_TraceLine( pEntity->GetAbsOrigin(), pEntity->GetAbsOrigin() - Vector( 0, 0, 256 ), MASK_SOLID, pEntity, COLLISION_GROUP_NONE, &groundTrace );
if ( tr.fraction < 1.0f )
{
CEffectData data;
// Find the floor and add a dissolve explosion at that point
data.m_flRadius = GUNSHIP_BELLY_BLAST_RADIUS * 0.5f;
data.m_vNormal = groundTrace.plane.normal;
data.m_vOrigin = groundTrace.endpos;
DispatchEffect( "AR2Explosion", data );
}
// If the creature was killed, then dissolve it
if ( pEntity->GetHealth() <= 0.0f )
{
if ( pEntity->GetBaseAnimating() != NULL && !pEntity->IsEFlagSet( EFL_NO_DISSOLVE ) )
{
pEntity->GetBaseAnimating()->Dissolve( NULL, gpGlobals->curtime );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::DoGroundAttackExplosion( void )
{
// Fire the bullets
Vector vecSrc, vecShootDir;
Vector vecAttachmentOrigin;
GetAttachment( "BellyGun", vecAttachmentOrigin, &vecShootDir, NULL, NULL );
vecSrc = vecAttachmentOrigin;
if ( m_hGroundAttackTarget )
{
vecSrc = m_hGroundAttackTarget->GetAbsOrigin();
}
Vector impactPoint = vecSrc + ( Vector( 0, 0, -1 ) * MAX_TRACE_LENGTH );
trace_t tr;
UTIL_TraceLine( vecSrc, impactPoint, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
UTIL_DecalTrace( &tr, "Scorch" );
if ( hl2_episodic.GetBool() == true )
{
g_pEffects->EnergySplash( tr.endpos, tr.plane.normal );
CBroadcastRecipientFilter filter;
te->BeamRingPoint( filter, 0.0,
tr.endpos, //origin
0, //start radius
GUNSHIP_BELLY_BLAST_RADIUS, //end radius
g_iGunshipEffectIndex, //texture
0, //halo index
0, //start frame
0, //framerate
0.2, //life
10, //width
0, //spread
0, //amplitude
255, //r
255, //g
255, //b
50, //a
0, //speed
FBEAM_FADEOUT
);
}
// Send the effect over
CEffectData data;
// Do an extra effect if we struck the world
if ( tr.m_pEnt && tr.m_pEnt->IsWorld() )
{
data.m_flRadius = GUNSHIP_BELLY_BLAST_RADIUS;
data.m_vNormal = tr.plane.normal;
data.m_vOrigin = tr.endpos;
DispatchEffect( "AR2Explosion", data );
}
float flZLength = vecAttachmentOrigin.z - tr.endpos.z;
Vector vBeamMins = Vector( -16, -16, 0 );
Vector vBeamMaxs = Vector( 16, 16, flZLength );
DoBellyBlastDamage( tr, vBeamMins, vBeamMaxs );
Vector vBlastMins = Vector( -GUNSHIP_BELLY_BLAST_RADIUS, -GUNSHIP_BELLY_BLAST_RADIUS, 0 );
Vector vBlastMaxs = Vector( GUNSHIP_BELLY_BLAST_RADIUS, GUNSHIP_BELLY_BLAST_RADIUS, 96 );
DoBellyBlastDamage( tr, vBlastMins, vBlastMaxs );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::StopGroundAttack( bool bDoAttack )
{
if ( !m_bIsGroundAttacking )
return;
// Mark us as no longer attacking
m_bIsGroundAttacking = false;
m_flNextGroundAttack = gpGlobals->curtime + 4.0f;
m_flTimeNextAttack = gpGlobals->curtime + 2.0f;
Vector hitPos = GetGroundAttackHitPosition();
// tell the client side effect to complete
EntityMessageBegin( this, true );
WRITE_BYTE( GUNSHIP_MSG_BIG_SHOT );
WRITE_VEC3COORD( hitPos );
MessageEnd();
if ( hl2_episodic.GetBool() == true )
{
if ( m_hEnergyCore )
{
variant_t value;
value.SetFloat( 1.0f );
g_EventQueue.AddEvent( m_hEnergyCore, "Stop", value, 0, this, this );
}
}
// Only attack if told to
if ( bDoAttack )
{
CPASAttenuationFilter filter2( this, "NPC_Strider.Shoot" );
EmitSound( filter2, entindex(), "NPC_Strider.Shoot");
ApplyAbsVelocityImpulse( Vector( 0, 0, 200.0f ) );
//ExplosionCreate( hitPos, QAngle( 0, 0, 1 ), this, 500, 500, true );
DoGroundAttackExplosion();
}
// If we were attacking a target, revert to our previous target
if ( m_hGroundAttackTarget )
{
m_hGroundAttackTarget = NULL;
if ( GetDestPathTarget() )
{
// Return to our old path
SetupNewCurrentTarget( GetDestPathTarget() );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::DrawRotorWash( float flAltitude, const Vector &vecRotorOrigin )
{
// If we have a ragdoll, we want the wash under that, not me
if ( m_hRagdoll )
{
BaseClass::DrawRotorWash( flAltitude, m_hRagdoll->GetAbsOrigin() );
return;
}
BaseClass::DrawRotorWash( flAltitude, vecRotorOrigin );
}
//------------------------------------------------------------------------------
// Purpose : Override the desired position if your derived helicopter is doing something special
//------------------------------------------------------------------------------
void CNPC_CombineGunship::UpdateDesiredPosition( void )
{
if ( m_hCrashTarget )
{
SetDesiredPosition( m_hCrashTarget->WorldSpaceCenter() + Vector(0,0,128) );
}
else if ( m_hGroundAttackTarget )
{
SetDesiredPosition( m_hGroundAttackTarget->GetAbsOrigin() + Vector(0,0,GUNSHIP_BELLYBLAST_TARGET_HEIGHT) );
}
}
//-----------------------------------------------------------------------------
// Purpose: do all of the stuff related to having an enemy, attacking, etc.
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::DoCombat( void )
{
// Check for enemy change-overs
if ( HasEnemy() )
{
if ( HasCondition( COND_NEW_ENEMY ) )
{
if ( GetEnemy() && GetEnemy()->IsPlayer() && m_flNextSeeEnemySound < gpGlobals->curtime )
{
m_flNextSeeEnemySound = gpGlobals->curtime + 5.0;
if ( !HasSpawnFlags( SF_GUNSHIP_USE_CHOPPER_MODEL ) )
{
EmitSound( "NPC_CombineGunship.SeeEnemy" );
}
}
// If we're shooting at a missile, do it immediately!
if ( IsTargettingMissile() )
{
EmitSound( "NPC_CombineGunship.SeeMissile" );
// Allow the gunship to attack again immediately
if ( ( m_flTimeNextAttack > gpGlobals->curtime ) && ( ( m_flTimeNextAttack - gpGlobals->curtime ) > GUNSHIP_MISSILE_MAX_RESPONSE_TIME ) )
{
m_flTimeNextAttack = gpGlobals->curtime + GUNSHIP_MISSILE_MAX_RESPONSE_TIME;
m_iBurstSize = sk_gunship_burst_size.GetInt();
}
}
// Fade in angry sound, fade out patrol sound.
PlayAngryLoop();
}
}
// Do we have a belly blast target?
if ( m_hGroundAttackTarget && !m_bIsGroundAttacking )
{
// If we're over it, blast. Can't use GetDesiredPosition() because it's not updated yet.
Vector vecTarget = m_hGroundAttackTarget->GetAbsOrigin() + Vector(0,0,GUNSHIP_BELLYBLAST_TARGET_HEIGHT);
Vector vecToTarget = (vecTarget - GetAbsOrigin());
float flDistance = vecToTarget.Length();
// Get the difference between our velocity & the target's velocity
Vector vec2DVelocity = GetAbsVelocity();
Vector vec2DTargetVelocity = m_hGroundAttackTarget->GetAbsVelocity();
vec2DVelocity.z = vec2DTargetVelocity.z = 0;
float flVelocityDiff = (vec2DVelocity - vec2DTargetVelocity).Length();
if ( flDistance < 100 && flVelocityDiff < 200 )
{
StartGroundAttack();
}
}
// Update our firing
if ( m_bIsFiring )
{
// Fire if we have rounds remaining in this burst
if ( ( m_iBurstSize > 0 ) && ( gpGlobals->curtime > m_flTimeNextAttack ) )
{
UpdateEnemyTarget();
FireCannonRound();
}
else if ( m_iBurstSize < 1 )
{
// We're done firing
StopCannonBurst();
if ( IsTargettingMissile() )
{
m_flTimeNextAttack = gpGlobals->curtime + 0.5f;
}
}
}
else
{
// If we're not firing, look at the enemy
if ( GetEnemy() )
{
m_vecAttackPosition = GetEnemy()->EyePosition();
}
#ifdef BELLYBLAST
// Check for a ground attack
if ( CheckGroundAttack() )
{
StartGroundAttack();
}
#endif
// See if we're attacking
if ( m_bIsGroundAttacking )
{
m_vecHitPos = GetGroundAttackHitPosition();
ManageWarningBeam();
// If our time is up, fire the blast and be done
if ( m_flGroundAttackTime < gpGlobals->curtime )
{
// Fire!
StopGroundAttack( true );
}
}
}
// If we're using the chopper model, align the gun towards the target
if ( HasSpawnFlags( SF_GUNSHIP_USE_CHOPPER_MODEL ) )
{
Vector vGunPosition;
GetAttachment( "gun", vGunPosition );
Vector vecToAttackPos = (m_vecAttackPosition - vGunPosition);
PoseGunTowardTargetDirection( vecToAttackPos );
}
// Forget flares once I've seen them for a while
float flDeltaSeen = m_flLastSeen - m_flPrevSeen;
if ( GetEnemy() != NULL && GetEnemy()->Classify() == CLASS_FLARE && flDeltaSeen > GUNSHIP_FLARE_IGNORE_TIME )
{
AddEntityRelationship( GetEnemy(), D_NU, 5 );
PlayPatrolLoop();
// Forget the flare now.
SetEnemy( NULL );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_CombineGunship::ChooseEnemy( void )
{
// If we're firing, don't switch enemies. This stops the gunship occasionally
// stopping a burst before he's really fired at all, which makes him look indecisive.
if ( m_bIsFiring )
return true;
return BaseClass::ChooseEnemy();
}
//-----------------------------------------------------------------------------
// Purpose: There's a lot of code in here now. We should consider moving
// helicopters and such to scheduled AI. (sjb)
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::MoveHead( void )
{
float flYaw = GetPoseParameter( m_poseFlex_Horz );
float flPitch = GetPoseParameter( m_poseFlex_Vert );
/*
This head-turning code will cause the head to POP when switching from looking at the enemy
to looking according to the flight model. I will fix this later. Right now I'm turning
the code over to Ken for some aiming fixups. (sjb)
*/
while( 1 )
{
if ( GetEnemy() != NULL )
{
Vector vecToEnemy, vecAimDir;
float flDot;
Vector vTargetPos, vGunPosition;
Vector vecTargetOffset;
QAngle vGunAngles;
GetAttachment( "muzzle", vGunPosition, vGunAngles );
vTargetPos = GetEnemyTarget();
VectorSubtract( vTargetPos, vGunPosition, vecToEnemy );
VectorNormalize( vecToEnemy );
// get angles relative to body position
AngleVectors( GetAbsAngles(), &vecAimDir );
flDot = DotProduct( vecAimDir, vecToEnemy );
// Look at Enemy!!
if ( flDot > 0.3f )
{
float flDiff;
float flDesiredYaw = VecToYaw(vTargetPos - vGunPosition);
flDiff = UTIL_AngleDiff( flDesiredYaw, vGunAngles.y ) * 0.90;
flYaw = UTIL_Approach( flYaw + flDiff, flYaw, 5.0 );
float flDesiredPitch = UTIL_VecToPitch(vTargetPos - vGunPosition);
flDiff = UTIL_AngleDiff( flDesiredPitch, vGunAngles.x ) * 0.90;
flPitch = UTIL_Approach( flPitch + flDiff, flPitch, 5.0 );
break;
}
}
// Look where going!
#if 1 // old way- look according to rotational velocity
flYaw = UTIL_Approach( GetLocalAngularVelocity().y, flYaw, 2.0 * 10 * m_flDeltaT );
flPitch = UTIL_Approach( GetLocalAngularVelocity().x, flPitch, 2.0 * 10 * m_flDeltaT );
#else // new way- look towards the next waypoint?
// !!!UNDONE
#endif
break;
}
// Set the body flexes
SetPoseParameter( m_poseFlex_Vert, flPitch );
SetPoseParameter( m_poseFlex_Horz, flYaw );
}
//-----------------------------------------------------------------------------
// Purpose: There's a lot of code in here now. We should consider moving
// helicopters and such to scheduled AI. (sjb)
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::PrescheduleThink( void )
{
m_flDeltaT = gpGlobals->curtime - GetLastThink();
// Are we crashing?
if ( m_flEndDestructTime && gpGlobals->curtime > m_flEndDestructTime )
{
// We're dead, remove ourselves
SelfDestruct();
return;
}
if( m_lifeState == LIFE_ALIVE )
{
// Chopper doesn't ping
if ( !HasSpawnFlags( SF_GUNSHIP_USE_CHOPPER_MODEL ) )
{
Ping();
}
DoCombat();
MoveHead();
}
else if( m_lifeState == LIFE_DYING )
{
// Increase the number of explosions as he gets closer to death
bool bCreateExplosion = false;
float flTimeLeft = m_flEndDestructTime - gpGlobals->curtime;
if ( flTimeLeft > 1.5 )
{
bCreateExplosion = (random->RandomInt( 0, 3 ) == 0);
}
else
{
bCreateExplosion = (random->RandomInt( 0, 2 ) == 0);
}
if ( bCreateExplosion )
{
Vector explodePoint;
if ( m_hRagdoll )
{
m_hRagdoll->CollisionProp()->RandomPointInBounds( Vector(0.25,0.25,0.25), Vector(0.75,0.75,0.75), &explodePoint );
}
else
{
CollisionProp()->RandomPointInBounds( Vector(0.25,0.25,0.25), Vector(0.75,0.75,0.75), &explodePoint );
// Knock the gunship a little, but not if we're trying to fly to a point
if ( !m_hCrashTarget )
{
Vector vecPush = (GetAbsOrigin() - explodePoint);
VectorNormalize( vecPush );
ApplyAbsVelocityImpulse( vecPush * 128 );
}
}
ExplosionCreate( explodePoint, QAngle(0,0,1), this, 100, 128, false );
}
// Have we reached our crash point?
if ( m_flNextGunshipCrashFind && !m_hRagdoll )
{
// Update nearest crash point. The RPG that killed us may have knocked us
// closer to a different point than the one we were near when we first died.
if ( m_flNextGunshipCrashFind < gpGlobals->curtime )
{
FindNearestGunshipCrash();
}
if ( m_hCrashTarget )
{
MoveHead();
UpdateDesiredPosition();
// If we're over it, destruct
Vector vecToTarget = (GetDesiredPosition() - GetAbsOrigin());
if ( vecToTarget.LengthSqr() < (384 * 384) )
{
BeginDestruct();
m_OnCrashed.FireOutput( this, this );
m_hCrashTarget->GunshipCrashedOnTarget();
return;
}
}
}
}
BaseClass::PrescheduleThink();
#ifdef JACOBS_GUNSHIP
SetPoseParameter( m_posePitch, random->RandomFloat( GUNSHIP_HEAD_MAX_LEFT, GUNSHIP_HEAD_MAX_RIGHT ) );
SetPoseParameter( m_poseYaw, random->RandomFloat( GUNSHIP_HEAD_MAX_UP, GUNSHIP_HEAD_MAX_DOWN ) );
#endif
}
//------------------------------------------------------------------------------
// Purpose : If the enemy is in front of the gun, load up a burst.
// Actual gunfire is handled in PrescheduleThink
// Input :
// Output :
//------------------------------------------------------------------------------
bool CNPC_CombineGunship::FireGun( void )
{
if ( m_lifeState != LIFE_ALIVE )
return false;
if ( m_bIsGroundAttacking )
return false;
if ( GetEnemy() && !m_bIsFiring && gpGlobals->curtime > m_flTimeNextAttack )
{
// We want to decelerate to attack
if (m_flGoalSpeed > GetMaxSpeedFiring() )
{
m_flGoalSpeed = GetMaxSpeedFiring();
}
bool bTargetingMissile = IsTargettingMissile();
if ( !bTargetingMissile && !m_bPreFire )
{
m_bPreFire = true;
m_flTimeNextAttack = gpGlobals->curtime + 0.5f;
EmitSound( "NPC_CombineGunship.CannonStartSound" );
return false;
}
//TODO: Emit the danger noise and wait until it's finished
// Don't fire at an occluded enemy unless blindfire is on.
if ( HasCondition( COND_ENEMY_OCCLUDED ) && ( m_fBlindfire == false ) )
return false;
// Don't shoot if the enemy is too close
if ( !bTargetingMissile && GroundDistToPosition( GetEnemy()->GetAbsOrigin() ) < GUNSHIP_STITCH_MIN )
return false;
Vector vecAimDir, vecToEnemy;
Vector vecMuzzle, vecEnemyTarget;
GetAttachment( "muzzle", vecMuzzle, &vecAimDir, NULL, NULL );
vecEnemyTarget = GetEnemyTarget();
// Aim with the muzzle's attachment point.
VectorSubtract( vecEnemyTarget, vecMuzzle, vecToEnemy );
VectorNormalize( vecToEnemy );
VectorNormalize( vecAimDir );
if ( DotProduct( vecToEnemy, vecAimDir ) > 0.9 )
{
StartCannonBurst( sk_gunship_burst_size.GetInt() );
return true;
}
return false;
}
return false;
}
//------------------------------------------------------------------------------
// Purpose: Fire a round from the cannon
// Notes: Only call this if you have an enemy.
//------------------------------------------------------------------------------
void CNPC_CombineGunship::FireCannonRound( void )
{
Vector vecPenetrate;
trace_t tr;
Vector vecToEnemy, vecEnemyTarget;
Vector vecMuzzle;
Vector vecAimDir;
GetAttachment( "muzzle", vecMuzzle, &vecAimDir );
vecEnemyTarget = GetEnemyTarget();
// Aim with the muzzle's attachment point.
VectorSubtract( vecEnemyTarget, vecMuzzle, vecToEnemy );
VectorNormalize( vecToEnemy );
// If the gun is wildly off target, stop firing!
// FIXME - this should use a vector pointing
// to the enemy's location PLUS the stitching
// error! (sjb) !!!BUGBUG
if ( g_debug_gunship.GetInt() == GUNSHIP_DEBUG_STITCHING )
{
QAngle vecAimAngle;
Vector vForward, vRight, vUp;
GetAttachment( "muzzle", vecMuzzle, &vForward, &vRight, &vUp );
AngleVectors( vecAimAngle, &vForward, &vRight, &vUp );
NDebugOverlay::Line( vecMuzzle, vecEnemyTarget, 255, 255, 0, true, 1.0f );
NDebugOverlay::Line( vecMuzzle, vecMuzzle + ( vForward * 64.0f ), 255, 0, 0, true, 1.0f );
NDebugOverlay::Line( vecMuzzle, vecMuzzle + ( vRight * 32.0f ), 0, 255, 0, true, 1.0f );
NDebugOverlay::Line( vecMuzzle, vecMuzzle + ( vUp * 32.0f ), 0, 0, 255, true, 1.0f );
}
// Robin: Check the dotproduct to the enemy, NOT to the offsetted firing angle
// Fixes problems firing at close enemies, where the enemy is valid but
// the offset firing stitch isn't.
Vector vecDotCheck = vecToEnemy;
if ( GetEnemy() )
{
VectorSubtract( GetEnemy()->GetAbsOrigin(), vecMuzzle, vecDotCheck );
VectorNormalize( vecDotCheck );
}
if ( DotProduct( vecDotCheck, vecAimDir ) < 0.8f )
{
StopCannonBurst();
return;
}
DoMuzzleFlash();
m_OnFireCannon.FireOutput( this, this, 0 );
m_flTimeNextAttack = gpGlobals->curtime + 0.05f;
float flPrevHealth = 0;
if ( GetEnemy() )
{
flPrevHealth = GetEnemy()->GetHealth();
}
// Make sure we hit missiles
if ( IsTargettingMissile() )
{
// Fire a fake shot
FireBullets( 1, vecMuzzle, vecToEnemy, VECTOR_CONE_5DEGREES, 8192, m_iAmmoType, 1 );
CBaseEntity *pMissile = GetEnemy();
Vector missileDir, threatDir;
AngleVectors( pMissile->GetAbsAngles(), &missileDir );
threatDir = ( WorldSpaceCenter() - pMissile->GetAbsOrigin() );
float threatDist = VectorNormalize( threatDir );
// Check that the target is within some threshold
if ( ( DotProduct( threatDir, missileDir ) > 0.95f ) && ( threatDist < 1024.0f ) )
{
if ( random->RandomInt( 0, 1 ) == 0 )
{
CTakeDamageInfo info( this, this, 200, DMG_MISSILEDEFENSE );
CalculateBulletDamageForce( &info, m_iAmmoType, -threatDir, WorldSpaceCenter() );
GetEnemy()->TakeDamage( info );
}
}
else
{
//FIXME: Some other metric
}
}
else
{
m_iBurstSize--;
// Fire directly at the target
FireBulletsInfo_t info( 1, vecMuzzle, vecToEnemy, vec3_origin, MAX_COORD_RANGE, m_iAmmoType );
info.m_iTracerFreq = 1;
CAmmoDef *pAmmoDef = GetAmmoDef();
info.m_iPlayerDamage = pAmmoDef->PlrDamage( m_iAmmoType );
// If we've already hit the player, do 0 damage. This ensures we don't hit the
// player multiple times during a single burst.
if ( m_iBurstHits >= GUNSHIP_MAX_HITS_PER_BURST )
{
info.m_iPlayerDamage = 1;
}
FireBullets( info );
if ( GetEnemy() && flPrevHealth != GetEnemy()->GetHealth() )
{
m_iBurstHits++;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::DoMuzzleFlash( void )
{
BaseClass::DoMuzzleFlash();
CEffectData data;
data.m_nAttachmentIndex = LookupAttachment( "muzzle" );
data.m_nEntIndex = entindex();
DispatchEffect( "GunshipMuzzleFlash", data );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_CombineGunship::FVisible( CBaseEntity *pEntity, int traceMask, CBaseEntity **ppBlocker )
{
bool fReturn = BaseClass::FVisible( pEntity, traceMask, ppBlocker );
if( m_fOmniscient )
{
if( !fReturn )
{
// Set this condition so that we can check it later and know that the
// enemy truly is occluded, but the gunship regards it as visible due
// to omniscience.
SetCondition( COND_ENEMY_OCCLUDED );
}
else
{
ClearCondition( COND_ENEMY_OCCLUDED );
}
return true;
}
if( fReturn )
{
ClearCondition( COND_ENEMY_OCCLUDED );
}
else
{
SetCondition( COND_ENEMY_OCCLUDED );
}
return fReturn;
}
//-----------------------------------------------------------------------------
// Purpose: Change the depth that gunship bullets can penetrate through solids
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::InputSetPenetrationDepth( inputdata_t &inputdata )
{
m_flPenetrationDepth = inputdata.value.Float();
}
//-----------------------------------------------------------------------------
// Purpose: Allow the gunship to sense its enemy's location even when enemy
// is hidden from sight.
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::InputOmniscientOn( inputdata_t &inputdata )
{
m_fOmniscient = true;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the gunship to its default requirement that it see the
// enemy to know its current position
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::InputOmniscientOff( inputdata_t &inputdata )
{
m_fOmniscient = false;
}
//-----------------------------------------------------------------------------
// Purpose: Allows the gunship to fire at an unseen enemy. The gunship is relying
// on hitting the target with bullets that will punch through the
// cover that the enemy is hiding behind. (Such as the Depot lighthouse)
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::InputBlindfireOn( inputdata_t &inputdata )
{
m_fBlindfire = true;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the gunship to default rules for attacking the enemy. The
// enemy must be seen to be fired at.
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::InputBlindfireOff( inputdata_t &inputdata )
{
m_fBlindfire = false;
}
//-----------------------------------------------------------------------------
// Purpose: Set the gunship's paddles flailing!
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::Event_Killed( const CTakeDamageInfo &info )
{
m_takedamage = DAMAGE_NO;
StopCannonBurst();
// Replace the rotor sound with broken engine sound.
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundDestroy( m_pRotorSound );
// BUGBUG: Isn't this sound just going to get stomped when the base class calls StopLoopingSounds() ??
CPASAttenuationFilter filter2( this );
m_pRotorSound = controller.SoundCreate( filter2, entindex(), "NPC_CombineGunship.DyingSound" );
controller.Play( m_pRotorSound, 1.0, 100 );
m_OnDeath.FireOutput( info.GetAttacker(), this );
SendOnKilledGameEvent( info );
BeginCrash();
// we deliberately do not call BaseClass::EventKilled
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::BeginCrash( void )
{
m_lifeState = LIFE_DYING;
StopGroundAttack( false );
// Increase our smoke trail
CreateSmokeTrail();
if ( m_pSmokeTrail )
{
m_pSmokeTrail->SetLifetime( -1 );
m_pSmokeTrail->m_StartSize = 64;
m_pSmokeTrail->m_EndSize = 128;
m_pSmokeTrail->m_Opacity = 0.5f;
}
if ( !FindNearestGunshipCrash() )
{
// We couldn't find a crash target, so just die right here.
BeginDestruct();
return;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CNPC_CombineGunship::FindNearestGunshipCrash( void )
{
// Find the nearest crash point. If we find one, we'll try to fly to it and die.
// If we can't find one, we'll die right here.
bool bFoundAnyCrashTargets = false;
float flNearest = MAX_TRACE_LENGTH * MAX_TRACE_LENGTH;
CTargetGunshipCrash *pNearest = NULL;
CBaseEntity *pEnt = NULL;
while( (pEnt = gEntList.FindEntityByClassname(pEnt, "info_target_gunshipcrash")) != NULL )
{
CTargetGunshipCrash *pCrashTarget = assert_cast<CTargetGunshipCrash*>(pEnt);
if ( pCrashTarget->IsDisabled() )
continue;
bFoundAnyCrashTargets = true;
float flDist = ( pEnt->WorldSpaceCenter() - WorldSpaceCenter() ).LengthSqr();
if( flDist < flNearest )
{
trace_t tr;
UTIL_TraceLine( WorldSpaceCenter(), pEnt->WorldSpaceCenter(), MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &tr );
if( tr.fraction == 1.0 )
{
pNearest = pCrashTarget;
flNearest = flDist;
}
else if ( g_debug_gunship.GetInt() )
{
NDebugOverlay::Line( WorldSpaceCenter(), tr.endpos, 255,0,0, true, 99);
}
}
}
if ( !pNearest )
{
// If we found a gunship crash, but none near enough, claim we did find one, so that we
// don't blow up yet. This will give us 3 seconds to attempt to find one before dying.
if ( !m_hCrashTarget && bFoundAnyCrashTargets )
{
m_flNextGunshipCrashFind = gpGlobals->curtime + 0.5;
m_flEndDestructTime = gpGlobals->curtime + 3.0;
return true;
}
return false;
}
// Fly to the crash point and destruct there
m_hCrashTarget = pNearest;
m_flNextGunshipCrashFind = gpGlobals->curtime + 0.5;
m_flEndDestructTime = 0;
if ( g_debug_gunship.GetInt() )
{
NDebugOverlay::Line(GetAbsOrigin(), m_hCrashTarget->GetAbsOrigin(), 0,255,0, true, 0.5);
NDebugOverlay::Box( m_hCrashTarget->GetAbsOrigin(), -Vector(200,200,200), Vector(200,200,200), 0,255,0, 128, 0.5 );
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: I'm now ready to die. Create my ragdoll & hide myself.
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::BeginDestruct( void )
{
m_flEndDestructTime = gpGlobals->curtime + 3.0;
// Clamp velocity
if( hl2_episodic.GetBool() && GetAbsVelocity().Length() > 700.0f )
{
Vector vecVelocity = GetAbsVelocity();
VectorNormalize( vecVelocity );
SetAbsVelocity( vecVelocity * 700.0f );
}
CTakeDamageInfo info;
info.SetDamage( 40000 );
CalculateExplosiveDamageForce( &info, GetAbsVelocity(), GetAbsOrigin() );
// Don't create a ragdoll if we're going to explode into gibs
if ( !m_hCrashTarget )
return;
// Switch to damaged skin
m_nSkin = 1;
if ( HasSpawnFlags( SF_GUNSHIP_USE_CHOPPER_MODEL ) )
{
Chopper_BecomeChunks( this );
SetThink( &CNPC_CombineGunship::SUB_Remove );
SetNextThink( gpGlobals->curtime + 0.1f );
AddEffects( EF_NODRAW );
return;
}
// Create the ragdoll
m_hRagdoll = CreateServerRagdoll( this, 0, info, COLLISION_GROUP_NONE );
if ( !m_hRagdoll )
{
// Failed, just explode
SelfDestruct();
return;
}
m_hRagdoll->SetName( AllocPooledString( UTIL_VarArgs("%s_ragdoll", STRING(GetEntityName()) ) ) );
// Tell the smoke trail to follow the ragdoll
CreateSmokeTrail();
if ( m_pSmokeTrail )
{
// Force the smoke trail to stay on, and tell it to follow the ragdoll
m_pSmokeTrail->SetLifetime( -1 );
m_pSmokeTrail->FollowEntity( m_hRagdoll );
m_pSmokeTrail->m_StartSize = 64;
m_pSmokeTrail->m_EndSize = 128;
m_pSmokeTrail->m_Opacity = 0.5f;
}
/*
// ROBIN: Disabled this for now.
//
// Create the crashing controller and attach it to the ragdoll physics objects
m_pCrashingController = physenv->CreateMotionController( &m_crashCallback );
IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT];
int count = m_hRagdoll->VPhysicsGetObjectList( pList, ARRAYSIZE(pList) );
for ( int i = 0; i < count; i++ )
{
m_pCrashingController->AttachObject( pList[i], false );
}
*/
// Hide myself, because the ragdoll's now taken my place
AddEffects( EF_NODRAW );
AddSolidFlags( FSOLID_NOT_SOLID );
}
//-----------------------------------------------------------------------------
// Purpose: Create a smoke trail
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::CreateSmokeTrail( void )
{
if ( m_pSmokeTrail )
return;
m_pSmokeTrail = SmokeTrail::CreateSmokeTrail();
if ( m_pSmokeTrail )
{
m_pSmokeTrail->m_SpawnRate = 48;
m_pSmokeTrail->m_ParticleLifetime = 2.5f;
m_pSmokeTrail->m_StartColor.Init( 0.25f, 0.25f, 0.25f );
m_pSmokeTrail->m_EndColor.Init( 0.0, 0.0, 0.0 );
m_pSmokeTrail->m_StartSize = 24;
m_pSmokeTrail->m_EndSize = 128;
m_pSmokeTrail->m_SpawnRadius = 4;
m_pSmokeTrail->m_MinSpeed = 8;
m_pSmokeTrail->m_MaxSpeed = 64;
m_pSmokeTrail->m_Opacity = 0.2f;
m_pSmokeTrail->SetLifetime( -1 );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::ApplyGeneralDrag( void )
{
Vector vecNewVelocity = GetAbsVelocity();
// See if we need to stop more quickly
if ( m_bIsGroundAttacking )
{
vecNewVelocity *= 0.95f;
}
else
{
vecNewVelocity *= 0.995;
}
SetAbsVelocity( vecNewVelocity );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::Flight( void )
{
if( GetFlags() & FL_ONGROUND )
{
//This would be really bad.
SetGroundEntity( NULL );
}
if ( g_debug_gunship.GetInt() == GUNSHIP_DEBUG_PATH )
{
NDebugOverlay::Line(GetLocalOrigin(), GetDesiredPosition(), 0,0,255, true, 0.1);
}
// calc desired acceleration
float dt = 1.0f;
Vector accel;
float accelRate = GUNSHIP_ACCEL_RATE;
float maxSpeed = GetMaxSpeed();
if ( m_lifeState == LIFE_DYING && m_hCrashTarget != NULL )
{
// Gunship can fly faster to the place where it's supposed to crash, but
// maintain normal speeds if we haven't found a place to crash.
accelRate *= 2.0;
maxSpeed *= 4.0;
}
float flCurrentSpeed = GetAbsVelocity().Length();
float flDist = MIN( flCurrentSpeed + accelRate, maxSpeed );
Vector deltaPos;
if ( m_lifeState == LIFE_DYING || m_hGroundAttackTarget )
{
// Move directly to the target point
deltaPos = GetDesiredPosition();
}
else
{
ComputeActualTargetPosition( flDist, dt, 0.0f, &deltaPos );
}
deltaPos -= GetAbsOrigin();
// calc goal linear accel to hit deltaPos in dt time.
accel.x = 2.0 * (deltaPos.x - GetAbsVelocity().x * dt) / (dt * dt);
accel.y = 2.0 * (deltaPos.y - GetAbsVelocity().y * dt) / (dt * dt);
accel.z = 2.0 * (deltaPos.z - GetAbsVelocity().z * dt + 0.5 * 384 * dt * dt) / (dt * dt);
float flDistFromPath = 0.0f;
Vector vecPoint, vecDelta;
if ( m_lifeState != LIFE_DYING && IsOnPathTrack() )
{
// Also, add in a little force to get us closer to our current line segment if we can
ClosestPointToCurrentPath( &vecPoint );
VectorSubtract( vecPoint, GetAbsOrigin(), vecDelta );
flDistFromPath = VectorNormalize( vecDelta );
if ( flDistFromPath > GUNSHIP_OUTER_NAV_DIST )
{
// Strongly constrain to an n unit pipe around the current path
// by damping out all impulse forces that would push us further from the pipe
float flAmount = (flDistFromPath - GUNSHIP_OUTER_NAV_DIST) / 200.0f;
flAmount = clamp( flAmount, 0, 1 );
VectorMA( accel, flAmount * 200.0f, vecDelta, accel );
}
}
Vector vecAvoidForce;
CAvoidSphere::ComputeAvoidanceForces( this, 350.0f, 2.0f, &vecAvoidForce );
accel += vecAvoidForce;
CAvoidBox::ComputeAvoidanceForces( this, 350.0f, 2.0f, &vecAvoidForce );
accel += vecAvoidForce;
if ( m_lifeState != LIFE_DYING || m_hCrashTarget == NULL )
{
// don't fall faster than 0.2G or climb faster than 2G
accel.z = clamp( accel.z, 384 * 0.2, 384 * 2.0 );
}
Vector forward, right, up;
GetVectors( &forward, &right, &up );
Vector goalUp = accel;
VectorNormalize( goalUp );
// calc goal orientation to hit linear accel forces
float goalPitch = RAD2DEG( asin( DotProduct( forward, goalUp ) ) );
float goalYaw = UTIL_VecToYaw( m_vecDesiredFaceDir );
float goalRoll = RAD2DEG( asin( DotProduct( right, goalUp ) ) );
// clamp goal orientations
goalPitch = clamp( goalPitch, -45, 60 );
goalRoll = clamp( goalRoll, -45, 45 );
// calc angular accel needed to hit goal pitch in dt time.
dt = 0.6;
QAngle goalAngAccel;
goalAngAccel.x = 2.0 * (AngleDiff( goalPitch, AngleNormalize( GetLocalAngles().x ) ) - GetLocalAngularVelocity().x * dt) / (dt * dt);
goalAngAccel.y = 2.0 * (AngleDiff( goalYaw, AngleNormalize( GetLocalAngles().y ) ) - GetLocalAngularVelocity().y * dt) / (dt * dt);
goalAngAccel.z = 2.0 * (AngleDiff( goalRoll, AngleNormalize( GetLocalAngles().z ) ) - GetLocalAngularVelocity().z * dt) / (dt * dt);
goalAngAccel.x = clamp( goalAngAccel.x, -300, 300 );
//goalAngAccel.y = clamp( goalAngAccel.y, -60, 60 );
goalAngAccel.y = clamp( goalAngAccel.y, -120, 120 );
goalAngAccel.z = clamp( goalAngAccel.z, -300, 300 );
// limit angular accel changes to similate mechanical response times
dt = 0.1;
QAngle angAccelAccel;
angAccelAccel.x = (goalAngAccel.x - m_vecAngAcceleration.x) / dt;
angAccelAccel.y = (goalAngAccel.y - m_vecAngAcceleration.y) / dt;
angAccelAccel.z = (goalAngAccel.z - m_vecAngAcceleration.z) / dt;
angAccelAccel.x = clamp( angAccelAccel.x, -1000, 1000 );
angAccelAccel.y = clamp( angAccelAccel.y, -1000, 1000 );
angAccelAccel.z = clamp( angAccelAccel.z, -1000, 1000 );
m_vecAngAcceleration += angAccelAccel * 0.1;
// DevMsg( "pitch %6.1f (%6.1f:%6.1f) ", goalPitch, GetLocalAngles().x, m_vecAngVelocity.x );
// DevMsg( "roll %6.1f (%6.1f:%6.1f) : ", goalRoll, GetLocalAngles().z, m_vecAngVelocity.z );
// DevMsg( "%6.1f %6.1f %6.1f : ", goalAngAccel.x, goalAngAccel.y, goalAngAccel.z );
// DevMsg( "%6.0f %6.0f %6.0f\n", angAccelAccel.x, angAccelAccel.y, angAccelAccel.z );
ApplySidewaysDrag( right );
ApplyGeneralDrag();
QAngle angVel = GetLocalAngularVelocity();
angVel += m_vecAngAcceleration * 0.1;
//angVel.y = clamp( angVel.y, -60, 60 );
//angVel.y = clamp( angVel.y, -120, 120 );
angVel.y = clamp( angVel.y, -120, 120 );
SetLocalAngularVelocity( angVel );
m_flForce = m_flForce * 0.8 + (accel.z + fabs( accel.x ) * 0.1 + fabs( accel.y ) * 0.1) * 0.1 * 0.2;
Vector vecImpulse = m_flForce * up;
if ( !m_hCrashTarget && m_lifeState == LIFE_DYING && !hl2_episodic.GetBool() )
{
// Force gunship to the ground if it doesn't have a specific place to crash.
// EXCEPT In episodic, where forcing it to the ground means it crashes where the player can't see (attic showdown) (sjb)
vecImpulse.z = -10;
}
else
{
vecImpulse.z -= 38.4; // 32ft/sec
}
// Find our current velocity
Vector vecVelDir = GetAbsVelocity();
VectorNormalize( vecVelDir );
if ( flDistFromPath > GUNSHIP_INNER_NAV_DIST )
{
// Strongly constrain to an n unit pipe around the current path
// by damping out all impulse forces that would push us further from the pipe
float flDot = DotProduct( vecImpulse, vecDelta );
if ( flDot < 0.0f )
{
VectorMA( vecImpulse, -flDot * 0.1f, vecDelta, vecImpulse );
}
// Also apply an extra impulse to compensate for the current velocity
flDot = DotProduct( vecVelDir, vecDelta );
if ( flDot < 0.0f )
{
VectorMA( vecImpulse, -flDot * 0.1f, vecDelta, vecImpulse );
}
}
// Find our acceleration direction
Vector vecAccelDir = vecImpulse;
VectorNormalize( vecAccelDir );
// Level out our plane of movement
vecAccelDir.z = 0.0f;
vecVelDir.z = 0.0f;
forward.z = 0.0f;
right.z = 0.0f;
// Find out how "fast" we're moving in relation to facing and acceleration
float speed = m_flForce * DotProduct( vecVelDir, vecAccelDir );// * DotProduct( forward, vecVelDir );
// Apply the acceleration blend to the fins
float finAccelBlend = SimpleSplineRemapVal( speed, -60, 60, -1, 1 );
float curFinAccel = GetPoseParameter( m_poseFin_Accel );
curFinAccel = UTIL_Approach( finAccelBlend, curFinAccel, 0.5f );
SetPoseParameter( m_poseFin_Accel, curFinAccel );
speed = m_flForce * DotProduct( vecVelDir, right );
// Apply the spin sway to the fins
float finSwayBlend = SimpleSplineRemapVal( speed, -60, 60, -1, 1 );
float curFinSway = GetPoseParameter( m_poseFin_Sway );
curFinSway = UTIL_Approach( finSwayBlend, curFinSway, 0.5f );
SetPoseParameter( m_poseFin_Sway, curFinSway );
if ( g_debug_gunship.GetInt() == GUNSHIP_DEBUG_PATH )
{
NDebugOverlay::Line(GetLocalOrigin(), GetLocalOrigin() + vecImpulse, 255,0,0, true, 0.1);
}
// Add in our velocity pulse for this frame
ApplyAbsVelocityImpulse( vecImpulse );
}
//------------------------------------------------------------------------------
// Updates the facing direction
//------------------------------------------------------------------------------
void CNPC_CombineGunship::UpdateFacingDirection( void )
{
if ( GetEnemy() )
{
if ( !IsCrashing() && m_flLastSeen + 5 > gpGlobals->curtime )
{
// If we've seen the target recently, face the target.
//Msg( "Facing Target \n" );
m_vecDesiredFaceDir = m_vecTargetPosition - GetAbsOrigin();
}
else
{
// Remain facing the way you were facing...
}
}
else
{
// Face our desired position.
if ( GetDesiredPosition().DistToSqr( GetAbsOrigin() ) > 1 )
{
m_vecDesiredFaceDir = GetDesiredPosition() - GetAbsOrigin();
}
else
{
GetVectors( &m_vecDesiredFaceDir, NULL, NULL );
}
}
VectorNormalize( m_vecDesiredFaceDir );
}
//------------------------------------------------------------------------------
// Purpose : Fire up the Gunships 'second' rotor sound. The Search sound.
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_CombineGunship::InitializeRotorSound( void )
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
CPASAttenuationFilter filter( this );
m_pCannonSound = controller.SoundCreate( filter, entindex(), "NPC_CombineGunship.CannonSound" );
m_pRotorSound = controller.SoundCreate( filter, entindex(), "NPC_CombineGunship.RotorSound" );
m_pAirExhaustSound = controller.SoundCreate( filter, entindex(), "NPC_CombineGunship.ExhaustSound" );
m_pAirBlastSound = controller.SoundCreate( filter, entindex(), "NPC_CombineGunship.RotorBlastSound" );
controller.Play( m_pCannonSound, 0.0, 100 );
controller.Play( m_pAirExhaustSound, 0.0, 100 );
controller.Play( m_pAirBlastSound, 0.0, 100 );
BaseClass::InitializeRotorSound();
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_CombineGunship::UpdateRotorSoundPitch( int iPitch )
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
// Apply the pitch to both sounds.
controller.SoundChangePitch( m_pAirExhaustSound, iPitch, 0.1 );
// FIXME: Doesn't work in multiplayer
CBaseEntity *pPlayer = UTIL_PlayerByIndex(1);
if (pPlayer)
{
Vector pos;
Vector up;
GetAttachment( "rotor", pos, NULL, NULL, &up );
float flDistance = (pPlayer->WorldSpaceCenter() - pos).Length2DSqr();
// Fade in exhaust when we're far from the player
float flVolume = clamp( RemapVal( flDistance, (900*900), (1800*1800), 1, 0 ), 0, 1 );
controller.SoundChangeVolume( m_pAirExhaustSound, flVolume * GetRotorVolume(), 0.1 );
// Fade in the blast when it's close to the player (in 2D)
flVolume = clamp( RemapVal( flDistance, (600*600), (700*700), 1, 0 ), 0, 1 );
controller.SoundChangeVolume( m_pAirBlastSound, flVolume * GetRotorVolume(), 0.1 );
}
BaseClass::UpdateRotorSoundPitch( iPitch );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::ApplySidewaysDrag( const Vector &vecRight )
{
Vector vecVelocity = GetAbsVelocity();
if( m_lifeState == LIFE_ALIVE )
{
vecVelocity.x *= (1.0 - fabs( vecRight.x ) * 0.04);
vecVelocity.y *= (1.0 - fabs( vecRight.y ) * 0.04);
vecVelocity.z *= (1.0 - fabs( vecRight.z ) * 0.04);
}
else
{
vecVelocity.x *= (1.0 - fabs( vecRight.x ) * 0.03);
vecVelocity.y *= (1.0 - fabs( vecRight.y ) * 0.03);
vecVelocity.z *= (1.0 - fabs( vecRight.z ) * 0.09);
}
SetAbsVelocity( vecVelocity );
}
//------------------------------------------------------------------------------
// Purpose: Explode the gunship.
//------------------------------------------------------------------------------
void CNPC_CombineGunship::SelfDestruct( void )
{
SetThink( NULL );
m_lifeState = LIFE_DEAD;
StopLoopingSounds();
StopCannonBurst();
Vector vecVelocity = GetAbsVelocity();
vecVelocity.z = 0.0; // stop falling.
SetAbsVelocity( vecVelocity );
CBaseEntity *pBreakEnt = this;
// If we've ragdolled, play the explosions on the ragdoll instead
Vector vecOrigin;
if ( m_hRagdoll )
{
m_hRagdoll->EmitSound( "NPC_CombineGunship.Explode" );
vecOrigin = m_hRagdoll->GetAbsOrigin();
pBreakEnt = m_hRagdoll;
}
else
{
EmitSound( "NPC_CombineGunship.Explode" );
vecOrigin = GetAbsOrigin();
}
// Create some explosions on the gunship body
Vector vecDelta;
for( int i = 0 ; i < 6 ; i++ )
{
vecDelta = RandomVector( -200,200 );
ExplosionCreate( vecOrigin + vecDelta, QAngle( -90, 0, 0 ), this, 10, 10, false );
}
AR2Explosion *pExplosion = AR2Explosion::CreateAR2Explosion( vecOrigin );
if ( pExplosion )
{
pExplosion->SetLifetime( 10 );
}
// If we don't have a crash target, explode into chunks
if ( !m_hCrashTarget )
{
Vector angVelocity;
QAngleToAngularImpulse( pBreakEnt->GetLocalAngularVelocity(), angVelocity );
PropBreakableCreateAll( pBreakEnt->GetModelIndex(), pBreakEnt->VPhysicsGetObject(), pBreakEnt->GetAbsOrigin(), pBreakEnt->GetAbsAngles(), pBreakEnt->GetAbsVelocity(), angVelocity, 1.0, 800, COLLISION_GROUP_NPC, pBreakEnt );
// Throw out some small chunks too
CPVSFilter filter( GetAbsOrigin() );
for ( int i = 0; i < 20; i++ )
{
Vector gibVelocity = RandomVector(-100,100) * 10;
int iModelIndex = modelinfo->GetModelIndex( g_PropDataSystem.GetRandomChunkModel( "MetalChunks" ) );
te->BreakModel( filter, 0.0, GetAbsOrigin(), vec3_angle, Vector(40,40,40), gibVelocity, iModelIndex, 400, 1, 2.5, BREAK_METAL );
}
if ( m_hRagdoll )
{
UTIL_Remove( m_hRagdoll );
}
}
else
{
if ( m_pSmokeTrail )
{
// If we have a ragdoll, let it smoke for a few more seconds
if ( m_hRagdoll )
{
m_pSmokeTrail->SetLifetime(3.0f);
}
else
{
m_pSmokeTrail->SetLifetime(0.1f);
}
m_pSmokeTrail = NULL;
}
}
UTIL_Remove( this );
// Record this so a nearby citizen can respond.
if ( GetCitizenResponse() )
{
GetCitizenResponse()->AddResponseTrigger( CR_PLAYER_KILLED_GUNSHIP );
}
#ifdef HL2_EPISODIC
NPCEventResponse()->TriggerEvent( "TLK_CITIZEN_RESPONSE_KILLED_GUNSHIP", false, false );
#endif
}
//------------------------------------------------------------------------------
// Purpose : Explode the gunship.
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_CombineGunship::InputSelfDestruct( inputdata_t &inputdata )
{
BeginCrash();
}
//------------------------------------------------------------------------------
// Purpose : Shrink the gunship's bbox so that it fits in docking bays
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_CombineGunship::InputSetDockingBBox( inputdata_t &inputdata )
{
Vector vecSize( 32, 32, 32 );
UTIL_SetSize( this, vecSize * -1, vecSize );
}
//------------------------------------------------------------------------------
// Purpose : Set the gunship BBox to normal size
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_CombineGunship::InputSetNormalBBox( inputdata_t &inputdata )
{
Vector vecBBMin, vecBBMax;
ExtractBbox( SelectHeaviestSequence( ACT_GUNSHIP_PATROL ), vecBBMin, vecBBMax );
// Trim the bounding box a bit. It's huge.
#define GUNSHIP_TRIM_BOX 38
vecBBMin.x += GUNSHIP_TRIM_BOX;
vecBBMax.x -= GUNSHIP_TRIM_BOX;
vecBBMin.y += GUNSHIP_TRIM_BOX;
vecBBMax.y -= GUNSHIP_TRIM_BOX;
UTIL_SetSize( this, vecBBMin, vecBBMax );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::InputEnableGroundAttack( inputdata_t &inputdata )
{
m_bCanGroundAttack = true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::InputDisableGroundAttack( inputdata_t &inputdata )
{
m_bCanGroundAttack = false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::InputDoGroundAttack( inputdata_t &inputdata )
{
// Was a target node specified?
CBaseEntity *pEntity = gEntList.FindEntityByName( NULL, inputdata.value.StringID(), NULL, inputdata.pActivator, inputdata.pCaller );
if ( pEntity )
{
// Mapmaker wants us to ground attack a specific target
m_hGroundAttackTarget = pEntity;
}
else
{
StartGroundAttack();
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &vGunPosition -
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::UpdateEnemyTarget( void )
{
Vector vGunPosition;
GetAttachment( "muzzle", vGunPosition );
// Follow mode
Vector enemyPos;
bool bTargettingPlayer;
if ( GetEnemy() != NULL )
{
CBaseCombatCharacter *pCCEnemy = GetEnemy()->MyCombatCharacterPointer();
if ( pCCEnemy != NULL && pCCEnemy->IsInAVehicle() )
{
// Update against a driving target
enemyPos = GetEnemy()->WorldSpaceCenter();
}
else
{
enemyPos = GetEnemy()->EyePosition();
}
bTargettingPlayer = GetEnemy()->IsPlayer();
}
else
{
enemyPos = m_vecAttackPosition;
bTargettingPlayer = false;
}
// Direction towards the enemy
Vector targetDir = enemyPos - m_vecAttackPosition;
VectorNormalize( targetDir );
// Direction from the gunship to the enemy
Vector enemyDir = enemyPos - vGunPosition;
VectorNormalize( enemyDir );
float lastSpeed = VectorNormalize( m_vecAttackVelocity );
QAngle chaseAngles, lastChaseAngles;
VectorAngles( targetDir, chaseAngles );
VectorAngles( m_vecAttackVelocity, lastChaseAngles );
// Debug info
if ( g_debug_gunship.GetInt() == GUNSHIP_DEBUG_STITCHING )
{
// Final position
NDebugOverlay::Cross3D( m_vecAttackPosition, -Vector(2,2,2), Vector(2,2,2), 0, 0, 255, true, 4.0f );
}
float yawDiff = UTIL_AngleDiff( lastChaseAngles[YAW], chaseAngles[YAW] );
int maxYaw;
if ( bTargettingPlayer )
{
maxYaw = 6;
}
else
{
maxYaw = 30;
}
yawDiff = clamp( yawDiff, -maxYaw, maxYaw );
chaseAngles[PITCH] = 0.0f;
chaseAngles[ROLL] = 0.0f;
bool bMaxHits = ( m_iBurstHits >= GUNSHIP_MAX_HITS_PER_BURST || (GetEnemy() && !GetEnemy()->IsAlive()) );
if ( bMaxHits )
{
// We've hit our target. Stop chasing, and return to max speed.
chaseAngles[YAW] = lastChaseAngles[YAW];
lastSpeed = BASE_STITCH_VELOCITY;
}
else
{
// Move towards the target yaw
chaseAngles[YAW] = UTIL_AngleMod( lastChaseAngles[YAW] - yawDiff );
}
// If we've hit the target already, or we're not close enough to it, then just stitch along
if ( bMaxHits || ( m_vecAttackPosition - enemyPos ).LengthSqr() > (64 * 64) )
{
AngleVectors( chaseAngles, &targetDir );
// Update our new velocity
m_vecAttackVelocity = targetDir * lastSpeed;
if ( g_debug_gunship.GetInt() == GUNSHIP_DEBUG_STITCHING )
{
NDebugOverlay::Line( m_vecAttackPosition, m_vecAttackPosition + (m_vecAttackVelocity * 0.1), 255, 0, 0, true, 4.0f );
}
// Move along that velocity for this step in time
m_vecAttackPosition += ( m_vecAttackVelocity * 0.1f );
m_vecAttackPosition.z = enemyPos.z;
}
else
{
// Otherwise always continue to hit an NPC when close enough
m_vecAttackPosition = enemyPos;
}
}
//------------------------------------------------------------------------------
// Purpose: Utility function to aim the helicopter gun at the direction
//------------------------------------------------------------------------------
bool CNPC_CombineGunship::PoseGunTowardTargetDirection( const Vector &vTargetDir )
{
Vector vecOut;
VectorIRotate( vTargetDir, EntityToWorldTransform(), vecOut );
QAngle angles;
VectorAngles(vecOut, angles);
angles.y = AngleNormalize( angles.y );
angles.x = AngleNormalize( angles.x );
if (angles.x > m_angGun.x)
{
m_angGun.x = MIN( angles.x, m_angGun.x + 12 );
}
if (angles.x < m_angGun.x)
{
m_angGun.x = MAX( angles.x, m_angGun.x - 12 );
}
if (angles.y > m_angGun.y)
{
m_angGun.y = MIN( angles.y, m_angGun.y + 12 );
}
if (angles.y < m_angGun.y)
{
m_angGun.y = MAX( angles.y, m_angGun.y - 12 );
}
SetPoseParameter( m_poseWeapon_Pitch, -m_angGun.x );
SetPoseParameter( m_poseWeapon_Yaw, m_angGun.y );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Vector
//-----------------------------------------------------------------------------
Vector CNPC_CombineGunship::GetMissileTarget( void )
{
return GetEnemy()->GetAbsOrigin();
}
//------------------------------------------------------------------------------
// Purpose : Get the target position for the enemy- the position we fire upon.
// this is often modified by m_flAttackOffset to provide the 'stitching'
// behavior that's so popular with the kids these days (sjb)
//
// Input : vGunPosition - location of gunship's muzzle
// : pTarget = vector to paste enemy target into.
// Output :
//------------------------------------------------------------------------------
Vector CNPC_CombineGunship::GetEnemyTarget( void )
{
// Make sure we have an enemy
if ( GetEnemy() == NULL )
return m_vecAttackPosition;
// If we're locked onto a missile, use special code to try and destroy it
if ( IsTargettingMissile() )
return GetMissileTarget();
return m_vecAttackPosition;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &tr -
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::DoImpactEffect( trace_t &tr, int nDamageType )
{
UTIL_ImpactTrace( &tr, nDamageType, "ImpactGunship" );
// These glow effects don't sort properly, so they're cut for E3 2003 (sjb)
#if 0
CEffectData data;
data.m_vOrigin = tr.endpos;
data.m_vNormal = vec3_origin;
data.m_vAngles = vec3_angle;
DispatchEffect( "GunshipImpact", data );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Make the gunship's signature blue tracer!
// Input : &vecTracerSrc -
// &tr -
// iTracerType -
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType )
{
switch ( iTracerType )
{
case TRACER_LINE:
{
float flTracerDist;
Vector vecDir;
Vector vecEndPos;
vecDir = tr.endpos - vecTracerSrc;
flTracerDist = VectorNormalize( vecDir );
UTIL_Tracer( vecTracerSrc, tr.endpos, 0, TRACER_DONT_USE_ATTACHMENT, 8000, true, "GunshipTracer" );
}
break;
default:
BaseClass::MakeTracer( vecTracerSrc, tr, iTracerType );
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &info -
// &vecDir -
// *ptr -
// Output : int
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
{
// Reflect bullets
if ( info.GetDamageType() & DMG_BULLET )
{
if ( random->RandomInt( 0, 2 ) == 0 )
{
Vector vecRicochetDir = vecDir * -1;
vecRicochetDir.x += random->RandomFloat( -0.5, 0.5 );
vecRicochetDir.y += random->RandomFloat( -0.5, 0.5 );
vecRicochetDir.z += random->RandomFloat( -0.5, 0.5 );
VectorNormalize( vecRicochetDir );
Vector end = ptr->endpos + vecRicochetDir * 1024;
UTIL_Tracer( ptr->endpos, end, entindex(), TRACER_DONT_USE_ATTACHMENT, 3500 );
}
// If this is from a player, record it so a nearby citizen can respond.
if ( info.GetAttacker()->IsPlayer() )
{
if ( GetCitizenResponse() )
{
GetCitizenResponse()->AddResponseTrigger( CR_PLAYER_SHOT_GUNSHIP );
}
#ifdef HL2_EPISODIC
NPCEventResponse()->TriggerEvent( "TLK_CITIZEN_RESPONSE_SHOT_GUNSHIP", false, false );
#endif
}
return;
}
BaseClass::TraceAttack( info, vecDir, ptr, pAccumulator );
}
//-----------------------------------------------------------------------------
// Purpose: This is necessary to ensure that the game doesn't break if a mapmaker has outputs that
// must be fired on gunships, and the player switches skill levels
// midway through a gunship battle.
// Input : iDamageNumber -
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::FireDamageOutputsUpto( int iDamageNumber )
{
for ( int i = 0; i <= iDamageNumber; i++ )
{
if ( !m_bDamageOutputsFired[i] )
{
m_bDamageOutputsFired[i] = true;
switch ( i )
{
case 0:
//Msg("Fired first\n");
m_OnFirstDamage.FireOutput( this, this );
break;
case 1:
//Msg("Fired second\n");
m_OnSecondDamage.FireOutput( this, this );
break;
case 2:
//Msg("Fired third\n");
m_OnThirdDamage.FireOutput( this, this );
break;
case 3:
//Msg("Fired fourth\n");
m_OnFourthDamage.FireOutput( this, this );
break;
}
}
}
}
//------------------------------------------------------------------------------
// Damage filtering
//------------------------------------------------------------------------------
int CNPC_CombineGunship::OnTakeDamage_Alive( const CTakeDamageInfo &inputInfo )
{
// Allow npc_kill to kill me
if ( inputInfo.GetDamageType() != DMG_GENERIC )
{
// Ignore mundane bullet damage.
if ( ( inputInfo.GetDamageType() & DMG_BLAST ) == false )
return 0;
// Ignore blasts less than this amount
if ( inputInfo.GetDamage() < GUNSHIP_MIN_DAMAGE_THRESHOLD )
return 0;
}
// Only take blast damage
CTakeDamageInfo info = inputInfo;
// Make a pain sound
if ( !HasSpawnFlags( SF_GUNSHIP_USE_CHOPPER_MODEL ) )
{
EmitSound( "NPC_CombineGunship.Pain" );
}
Vector damageDir = info.GetDamageForce();
VectorNormalize( damageDir );
// Don't get knocked around if I'm ground attacking
if ( !m_bIsGroundAttacking )
{
ApplyAbsVelocityImpulse( damageDir * 200.0f );
}
if ( m_bInvulnerable == false )
{
// Take a percentage of our health away
// Adjust health for damage
int iHealthIncrements = sk_gunship_health_increments.GetInt();
if ( g_pGameRules->IsSkillLevel( SKILL_EASY ) )
{
iHealthIncrements = ceil( iHealthIncrements * 0.5 );
}
else if ( g_pGameRules->IsSkillLevel( SKILL_HARD ) )
{
iHealthIncrements = floor( iHealthIncrements * 1.5 );
}
info.SetDamage( ( GetMaxHealth() / (float)iHealthIncrements ) + 1 );
// Find out which "stage" we're at in our health
int healthIncrement = iHealthIncrements - ( GetHealth() / (float)(( GetMaxHealth() / (float)iHealthIncrements )) );
switch ( healthIncrement )
{
case 1:
// If we're on Easy, we're half dead now, so fire the rest of our outputs too
// This is done in case the mapmaker's connected those inputs to something important
// that has to happen before the gunship dies.
if ( g_pGameRules->IsSkillLevel( SKILL_EASY ) )
{
FireDamageOutputsUpto( 3 );
}
else
{
FireDamageOutputsUpto( 1 );
}
break;
default:
FireDamageOutputsUpto( healthIncrement );
break;
}
// Start smoking when we're almost dead
CreateSmokeTrail();
if ( m_pSmokeTrail )
{
if ( healthIncrement < 2 )
{
m_pSmokeTrail->SetLifetime( 8.0 );
}
m_pSmokeTrail->FollowEntity( this, "exhaustl" );
}
// Move with the target
Vector gibVelocity = GetAbsVelocity() + (-damageDir * 200.0f);
// Dump out metal gibs
CPVSFilter filter( GetAbsOrigin() );
for ( int i = 0; i < 10; i++ )
{
int iModelIndex = modelinfo->GetModelIndex( g_PropDataSystem.GetRandomChunkModel( "MetalChunks" ) );
te->BreakModel( filter, 0.0, GetAbsOrigin(), vec3_angle, Vector(40,40,40), gibVelocity, iModelIndex, 400, 1, 2.5, BREAK_METAL );
}
}
return BaseClass::OnTakeDamage_Alive( info );
}
//------------------------------------------------------------------------------
// Purpose : The proper way to begin the gunship cannon firing at the enemy.
// Input : iBurstSize - the size of the burst, in rounds.
//------------------------------------------------------------------------------
void CNPC_CombineGunship::StartCannonBurst( int iBurstSize )
{
m_iBurstSize = iBurstSize;
m_iBurstHits = 0;
m_flTimeNextAttack = gpGlobals->curtime;
// Start up the cannon sound.
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundChangeVolume( m_pCannonSound, 1.0, 0 );
m_bIsFiring = true;
// Setup the initial position of the burst
if ( GetEnemy() )
{
// Follow mode
Vector enemyPos;
UTIL_PredictedPosition( GetEnemy(), 2.0f, &enemyPos );
QAngle offsetAngles;
Vector offsetDir = ( WorldSpaceCenter() - enemyPos );
VectorNormalize( offsetDir );
VectorAngles( offsetDir, offsetAngles );
int angleOffset = random->RandomInt( 15, 30 );
if ( random->RandomInt( 0, 1 ) )
{
angleOffset *= -1;
}
offsetAngles[YAW] += angleOffset;
offsetAngles[PITCH] = 0;
offsetAngles[ROLL] = 0;
AngleVectors( offsetAngles, &offsetDir );
float stitchOffset;
float enemyDist = GroundDistToPosition( GetEnemy()->GetAbsOrigin() );
if ( enemyDist < ( sk_gunship_burst_dist.GetFloat() + GUNSHIP_STITCH_MIN ) )
{
stitchOffset = GUNSHIP_STITCH_MIN;
}
else
{
stitchOffset = sk_gunship_burst_dist.GetFloat();
}
// Move out to the start of our stitch run
m_vecAttackPosition = enemyPos + ( offsetDir * stitchOffset );
m_vecAttackPosition.z = enemyPos.z;
// Point at our target
m_vecAttackVelocity = -offsetDir * BASE_STITCH_VELOCITY;
CSoundEnt::InsertSound( SOUND_DANGER | SOUND_CONTEXT_REACT_TO_SOURCE, enemyPos, 512, 0.2f, this );
}
}
//------------------------------------------------------------------------------
// Purpose : The proper way to cease the gunship cannon firing.
//------------------------------------------------------------------------------
void CNPC_CombineGunship::StopCannonBurst( void )
{
m_iBurstHits = 0;
m_bIsFiring = false;
m_bPreFire = false;
// Reduce the burst time when we get lower in health
float flPerc = (float)GetHealth() / (float)GetMaxHealth();
float flDelay = clamp( flPerc * m_flBurstDelay, 0.5, m_flBurstDelay );
// If we didn't finish the burst, don't wait so long
flPerc = 1.0 - (m_iBurstSize / sk_gunship_burst_size.GetFloat());
flDelay *= flPerc;
m_flTimeNextAttack = gpGlobals->curtime + flDelay;
m_iBurstSize = 0;
// Stop the cannon sound.
if ( m_pCannonSound != NULL )
{
CSoundEnvelopeController::GetController().SoundChangeVolume( m_pCannonSound, 0.0, 0.05 );
}
EmitSound( "NPC_CombineGunship.CannonStopSound" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::StopLoopingSounds( void )
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
if ( m_pCannonSound )
{
controller.SoundDestroy( m_pCannonSound );
m_pCannonSound = NULL;
}
if ( m_pRotorSound )
{
controller.SoundDestroy( m_pRotorSound );
m_pRotorSound = NULL;
}
if ( m_pAirExhaustSound )
{
controller.SoundDestroy( m_pAirExhaustSound );
m_pAirExhaustSound = NULL;
}
if ( m_pAirBlastSound )
{
controller.SoundDestroy( m_pAirBlastSound );
m_pAirBlastSound = NULL;
}
BaseClass::StopLoopingSounds();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pEnemy -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_CombineGunship::IsValidEnemy( CBaseEntity *pEnemy )
{
// Always track missiles
if ( pEnemy->IsAlive() && !pEnemy->MyNPCPointer() && FClassnameIs( pEnemy, "rpg_missile" ) )
return true;
// If we're shooting off a burst, don't pick up a new enemy
if ( ( m_bIsFiring ) && ( ( GetEnemy() == NULL ) || ( GetEnemy() != pEnemy ) ) )
return false;
return BaseClass::IsValidEnemy( pEnemy );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::GatherEnemyConditions( CBaseEntity *pEnemy )
{
BaseClass::GatherEnemyConditions(pEnemy);
// If we can't see the enemy for a few seconds, consider him unreachable
if ( !HasCondition(COND_SEE_ENEMY) )
{
if ( gpGlobals->curtime - GetEnemyLastTimeSeen() >= 3.0f )
{
MarkEnemyAsEluded();
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Tells us whether or not we're targetting an incoming missile
//-----------------------------------------------------------------------------
bool CNPC_CombineGunship::IsTargettingMissile( void )
{
if ( GetEnemy() == NULL )
return false;
if ( FClassnameIs( GetEnemy(), "rpg_missile" ) == false )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::InputBecomeInvulnerable( inputdata_t &input )
{
m_bInvulnerable = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CombineGunship::InputBecomeVulnerable( inputdata_t &input )
{
m_bInvulnerable = false;
}
AI_BEGIN_CUSTOM_NPC( npc_combinegunship, CNPC_CombineGunship )
// DECLARE_TASK( )
DECLARE_ACTIVITY( ACT_GUNSHIP_PATROL );
DECLARE_ACTIVITY( ACT_GUNSHIP_HOVER );
DECLARE_ACTIVITY( ACT_GUNSHIP_CRASH );
//DECLARE_CONDITION( COND_ )
//=========================================================
// DEFINE_SCHEDULE
// (
// SCHED_DUMMY,
//
// " Tasks"
// " TASK_FACE_ENEMY 0"
// " "
// " Interrupts"
// )
AI_END_CUSTOM_NPC()