diff options
Diffstat (limited to 'game/server/hl2/npc_combinegunship.cpp')
| -rw-r--r-- | game/server/hl2/npc_combinegunship.cpp | 3228 |
1 files changed, 3228 insertions, 0 deletions
diff --git a/game/server/hl2/npc_combinegunship.cpp b/game/server/hl2/npc_combinegunship.cpp new file mode 100644 index 0000000..2583105 --- /dev/null +++ b/game/server/hl2/npc_combinegunship.cpp @@ -0,0 +1,3228 @@ +//========= 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() + |