Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

294 lines
8.9 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Base class for helicopters & helicopter-type vehicles
//
// $NoKeywords: $
//=============================================================================//
#ifndef CBASEHELICOPTER_H
#define CBASEHELICOPTER_H
#ifdef _WIN32
#pragma once
#endif
#include "ai_basenpc.h"
#include "ai_trackpather.h"
//---------------------------------------------------------
// Helicopter flags
//---------------------------------------------------------
enum HelicopterFlags_t
{
BITS_HELICOPTER_GUN_ON = 0x00000001, // Gun is on and aiming
BITS_HELICOPTER_MISSILE_ON = 0x00000002, // Missile turrets are on and aiming
};
//---------------------------------------------------------
//---------------------------------------------------------
#define SF_NOWRECKAGE 0x08
#define SF_NOROTORWASH 0x20
#define SF_AWAITINPUT 0x40
//---------------------------------------------------------
//---------------------------------------------------------
// Pathing data
#define BASECHOPPER_LEAD_DISTANCE 800.0f
#define BASECHOPPER_MIN_CHASE_DIST_DIFF 128.0f // Distance threshold used to determine when a target has moved enough to update our navigation to it
#define BASECHOPPER_AVOID_DIST 256.0f
#define BASECHOPPER_MAX_SPEED 400.0f
#define BASECHOPPER_MAX_FIRING_SPEED 250.0f
#define BASECHOPPER_MIN_ROCKET_DIST 1000.0f
#define BASECHOPPER_MAX_GUN_DIST 2000.0f
//---------------------------------------------------------
// Physics rotor pushing
#define BASECHOPPER_WASH_RADIUS 256
#define BASECHOPPER_WASH_PUSH_MIN 30 // Initial force * their mass applied to objects in the wash
#define BASECHOPPER_WASH_PUSH_MAX 40 // Maximum force * their mass applied to objects in the wash
#define BASECHOPPER_WASH_RAMP_TIME 1.0 // Time it takes to ramp from the initial to the max force on an object in the wash (at the center of the wash)
#define BASECHOPPER_WASH_MAX_MASS 300 // Don't attempt to push anything over this mass
#define BASECHOPPER_WASH_MAX_OBJECTS 6 // Maximum number of objects the wash will push at once
// Wash physics pushing
struct washentity_t
{
DECLARE_DATADESC();
EHANDLE hEntity;
float flWashStartTime;
};
#define BASECHOPPER_WASH_ALTITUDE 1024.0f
//=========================================================
//=========================================================
class CBaseHelicopter : public CAI_TrackPather
{
public:
DECLARE_CLASS( CBaseHelicopter, CAI_TrackPather );
DECLARE_DATADESC();
DECLARE_SERVERCLASS();
CBaseHelicopter( void );
void Spawn( void );
void Precache( void );
virtual void UpdateOnRemove();
void Event_Killed( const CTakeDamageInfo &info );
void StopLoopingSounds();
int BloodColor( void ) { return DONT_BLEED; }
void GibMonster( void );
Class_T Classify ( void ) { return CLASS_COMBINE; }
void CallDyingThink( void ) { DyingThink(); }
bool HasEnemy( void ) { return GetEnemy() != NULL; }
virtual void GatherEnemyConditions( CBaseEntity *pEnemy );
virtual bool ChooseEnemy( void );
virtual void HelicopterPostThink( void ) { };
virtual void FlyTouch( CBaseEntity *pOther );
virtual void CrashTouch( CBaseEntity *pOther );
virtual void HelicopterThink( void );
virtual void DyingThink( void );
virtual void NullThink( void );
virtual void Startup ( void );
virtual void Flight( void );
virtual void ShowDamage( void ) {};
void UpdatePlayerDopplerShift( void );
virtual void Hunt( void );
virtual bool IsCrashing( void ) { return m_lifeState != LIFE_ALIVE; }
virtual float GetAcceleration( void ) { return 5; }
virtual void ApplySidewaysDrag( const Vector &vecRight );
virtual void ApplyGeneralDrag( void );
void TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator );
virtual bool FireGun( void );
virtual float GetRotorVolume( void );
virtual void InitializeRotorSound( void );
virtual void UpdateRotorSoundPitch( int iPitch );
virtual void AimRocketGun(void) {};
virtual void FireRocket( Vector vLaunchPos, Vector vLaunchDir ) {};
virtual bool GetTrackPatherTarget( Vector *pPos );
virtual CBaseEntity *GetTrackPatherTargetEnt();
void DrawDebugGeometryOverlays(void);
// Rotor washes
virtual void DrawRotorWash( float flAltitude, const Vector &vecRotorOrigin );
void DoRotorPhysicsPush( const Vector &vecRotorOrigin, float flAltitude );
bool DoWashPush( washentity_t *pWash, const Vector &vecWashOrigin );
void StopRotorWash( void );
// Purpose: Marks the entity for deletion
void InputKill( inputdata_t &inputdata );
void DelayedKillThink( );
virtual void SetTransmit( CCheckTransmitInfo *pInfo, bool bAlways );
// Helicopters never burn
virtual void Ignite( float flFlameLifetime, bool bNPCOnly, float flSize, bool bCalledByLevelDesigner ) { return; }
protected:
void HelicopterMove( );
// Updates the enemy
void UpdateEnemy();
// Override the desired position if your derived helicopter is doing something special
virtual void UpdateDesiredPosition( void );
// Updates the facing direction
virtual void UpdateFacingDirection();
// Fire weapons
void FireWeapons();
// Computes the actual position to fly to
void ComputeActualTargetPosition( float flSpeed, float flTime, float flPerpDist, Vector *pDest, bool bApplyNoise = true );
// Gets the max speed of the helicopter
virtual float GetMaxSpeed();
virtual float GetMaxSpeedFiring();
// Updates the enemy
virtual float EnemySearchDistance( );
// Rotor wash think
void RotorWashThink( void );
// Purpose: Push an airboat in our wash
void DoWashPushOnAirboat( CBaseEntity *pAirboat, const Vector &vecWashToAirboat, float flWashAmount );
// Updates the rotor wash volume
virtual void UpdateRotorWashVolume();
// Rotor sound
void InputEnableRotorSound( inputdata_t &inputdata );
void InputDisableRotorSound( inputdata_t &inputdata );
protected:
CSoundPatch *m_pRotorSound; // Rotor loop played when the player can see the helicopter
CSoundPatch *m_pRotorBlast; // Sound played when the helicopter's pushing around physics objects
float m_flForce;
int m_fHelicopterFlags;
Vector m_vecDesiredFaceDir;
float m_flLastSeen;
float m_flPrevSeen;
int m_iSoundState; // don't save this
Vector m_vecTargetPosition;
float m_flMaxSpeed; // Maximum speed of the helicopter.
float m_flMaxSpeedFiring; // Maximum speed of the helicopter whilst firing guns.
float m_flGoalSpeed; // Goal speed
float m_flInitialSpeed;
float m_flRandomOffsetTime;
Vector m_vecRandomOffset;
float m_flRotorWashEntitySearchTime;
bool m_bSuppressSound;
EHANDLE m_hRotorWash; // Attached rotorwash entity
// Inputs
void InputActivate( inputdata_t &inputdata );
// Inputs
void InputGunOn( inputdata_t &inputdata );
void InputGunOff( inputdata_t &inputdata );
void InputMissileOn( inputdata_t &inputdata );
void InputMissileOff( inputdata_t &inputdata );
void InputEnableRotorWash( inputdata_t &inputdata );
void InputDisableRotorWash( inputdata_t &inputdata );
void InputMoveTopSpeed( inputdata_t &inputdata ); // Causes the helicopter to immediately accelerate to its desired velocity
void InputMoveSpecifiedSpeed( inputdata_t &inputdata );
void InputSetAngles( inputdata_t &inputdata ); // Sets the angles of the helicopter
protected:
// Custom conservative collision volumes
Vector m_cullBoxMins;
Vector m_cullBoxMaxs;
// Wash physics pushing
CUtlVector< washentity_t > m_hEntitiesPushedByWash;
void SetStartupTime( float time ) { m_flStartupTime = time; }
private:
CNetworkVar( float, m_flStartupTime );
};
//-----------------------------------------------------------------------------
// This entity is used to create little force spheres that the helicopter
// should avoid.
//-----------------------------------------------------------------------------
class CAvoidSphere : public CBaseEntity
{
DECLARE_DATADESC();
public:
DECLARE_CLASS( CAvoidSphere, CBaseEntity );
void Init( float flRadius );
virtual void Activate();
virtual void UpdateOnRemove();
static void ComputeAvoidanceForces( CBaseEntity *pEntity, float flEntityRadius, float flAvoidTime, Vector *pVecAvoidForce );
private:
typedef CHandle<CAvoidSphere> AvoidSphereHandle_t;
float m_flRadius;
static CUtlVector< AvoidSphereHandle_t > s_AvoidSpheres;
};
//-----------------------------------------------------------------------------
// This entity is used to create little force boxes that the helicopter
// should avoid.
//-----------------------------------------------------------------------------
class CAvoidBox : public CBaseEntity
{
DECLARE_DATADESC();
public:
DECLARE_CLASS( CAvoidBox, CBaseEntity );
virtual void Spawn( );
virtual void Activate();
virtual void UpdateOnRemove();
static void ComputeAvoidanceForces( CBaseEntity *pEntity, float flEntityRadius, float flAvoidTime, Vector *pVecAvoidForce );
private:
typedef CHandle<CAvoidBox> AvoidBoxHandle_t;
static CUtlVector< AvoidBoxHandle_t > s_AvoidBoxes;
};
#endif // CBASEHELICOPTER_H