353 lines
12 KiB
C++
353 lines
12 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================//
|
|
|
|
#ifndef FUNC_TANK_H
|
|
#define FUNC_TANK_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "triggers.h"
|
|
|
|
#define SF_TANK_ACTIVE 0x0001
|
|
#define SF_TANK_PLAYER 0x0002
|
|
#define SF_TANK_HUMANS 0x0004
|
|
#define SF_TANK_ALIENS 0x0008
|
|
#define SF_TANK_LINEOFSIGHT 0x0010
|
|
#define SF_TANK_CANCONTROL 0x0020
|
|
#define SF_TANK_DAMAGE_KICK 0x0040 // Kick when take damage
|
|
#define SF_TANK_AIM_AT_POS 0x0080 // Aim at a particular position
|
|
#define SF_TANK_AIM_ASSISTANCE 0x0100
|
|
#define SF_TANK_NPC 0x0200
|
|
#define SF_TANK_NPC_CONTROLLABLE 0x0400 // 1024
|
|
#define SF_TANK_NPC_SET_CONTROLLER 0x0800 // 2048
|
|
#define SF_TANK_ALLOW_PLAYER_HITS 0x1000 // 4096 Allow friendly NPCs to fire upon enemies near the player
|
|
#define SF_TANK_IGNORE_RANGE_IN_VIEWCONE 0x2000 // 8192 Don't use range as a factor in determining if something is in view cone
|
|
#define SF_TANK_NOTSOLID 0x8000 // 32768
|
|
#define SF_TANK_SOUNDON 0x10000 // FIXME: This is not really a spawnflag! It holds transient state!!!
|
|
#define SF_TANK_HACKPLAYERHIT 0x20000 // 131072 Make this func_tank cheat and hit the player regularly
|
|
|
|
#define FUNCTANK_DISTANCE_MAX 1200 // 100 ft.
|
|
#define FUNCTANK_DISTANCE_MIN_TO_ENEMY 180
|
|
#define FUNCTANK_FIREVOLUME 1000
|
|
#define FUNCTANK_NPC_ROUTE_TIME 5.0f
|
|
|
|
// Effect handling
|
|
// If the func_tank has a chosen method of handling effects, use that
|
|
// instead of the individual effect settings. (muzzleflash, sound, tracer, etc)
|
|
enum FUNCTANK_EFFECT_HANDLING
|
|
{
|
|
EH_NONE, // Use the effect settings
|
|
EH_AR2, // Use AR2 effects
|
|
EH_COMBINE_CANNON // Large Combine cannon
|
|
};
|
|
|
|
enum TANKBULLET
|
|
{
|
|
TANK_BULLET_NONE = 0,
|
|
TANK_BULLET_SMALL = 1,
|
|
TANK_BULLET_MEDIUM = 2,
|
|
TANK_BULLET_LARGE = 3,
|
|
};
|
|
|
|
#define MORTAR_BLAST_RADIUS 350
|
|
|
|
|
|
// Custom damage
|
|
// env_laser (duration is 0.5 rate of fire)
|
|
// rockets
|
|
// explosion?
|
|
|
|
class CFuncTank : public CBaseEntity
|
|
{
|
|
|
|
DECLARE_CLASS( CFuncTank, CBaseEntity );
|
|
|
|
public:
|
|
|
|
CFuncTank();
|
|
~CFuncTank();
|
|
void Spawn( void );
|
|
void Activate( void );
|
|
void Precache( void );
|
|
bool CreateVPhysics( void );
|
|
bool KeyValue( const char *szKeyName, const char *szValue );
|
|
void UpdateOnRemove();
|
|
|
|
void SetYawRate( float flYawRate ) { m_yawRate = flYawRate; }
|
|
void SetPitchRate( float flPitchRate ) { m_pitchRate = flPitchRate; }
|
|
|
|
int ObjectCaps( void )
|
|
{
|
|
return ( BaseClass::ObjectCaps() | FCAP_IMPULSE_USE | FCAP_USE_IN_RADIUS );
|
|
}
|
|
|
|
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
|
|
|
virtual void FuncTankPreThink() { return; }
|
|
void Think( void );
|
|
virtual void FuncTankPostThink() { return; }
|
|
|
|
int GetAmmoCount( void ) { return m_iAmmoCount; }
|
|
|
|
// NPC
|
|
bool NPC_FindManPoint( Vector &vecPos );
|
|
bool NPC_HasEnemy( void );
|
|
void NPC_Fire( void );
|
|
void NPC_InterruptRoute( void );
|
|
void NPC_JustSawPlayer( CBaseEntity *pTarget );
|
|
void NPC_SetInRoute( bool bInRoute ) { m_bNPCInRoute = bInRoute; }
|
|
void NPC_SetIdleAngle( Vector vecIdle ) { m_vecNPCIdleTarget = vecIdle; }
|
|
|
|
// LOS
|
|
bool IsEntityInViewCone( CBaseEntity *pEntity );
|
|
bool HasLOSTo( CBaseEntity *pEntity );
|
|
|
|
// Controller
|
|
CBaseCombatCharacter *GetController( void );
|
|
bool StartControl( CBaseCombatCharacter *pController );
|
|
void StopControl( void );
|
|
Vector GetTargetPosition() { return m_vTargetPosition; }
|
|
void SetTargetPosition( const Vector &vecPos ) { m_vTargetPosition = vecPos; }
|
|
|
|
const float YawCenter() const { return m_yawCenter; }
|
|
const float YawCenterWorld() const { return m_yawCenterWorld; }
|
|
const float YawRange() const { return m_yawRange; }
|
|
const float PitchCenter() const { return m_pitchCenter; }
|
|
const float PitchCenterWorld() const { return m_pitchCenterWorld; }
|
|
const float PitchRange() const { return m_pitchRange; }
|
|
|
|
virtual void PhysicsSimulate( void );
|
|
|
|
virtual void OnStartControlled() {}
|
|
virtual void OnStopControlled() {}
|
|
|
|
// SF Tests.
|
|
inline bool IsControllable( void ) { return ( m_spawnflags & SF_TANK_CANCONTROL ) ? true : false; }
|
|
inline bool IsActive( void ) { return ( m_spawnflags & SF_TANK_ACTIVE ) ? true : false; }
|
|
inline bool IsNPCControllable( void ) { return ( m_spawnflags & SF_TANK_NPC_CONTROLLABLE ) ? true : false; }
|
|
inline bool IsNPCSetController( void ) { return ( m_spawnflags & SF_TANK_NPC_SET_CONTROLLER ) ? true : false; }
|
|
|
|
virtual void DoMuzzleFlash( void );
|
|
virtual const char *GetTracerType( void );
|
|
|
|
protected:
|
|
virtual float GetShotSpeed() { return 0; }
|
|
|
|
virtual Vector WorldBarrelPosition( void );
|
|
void UpdateMatrix( void );
|
|
|
|
float GetNextAttack() const { return m_flNextAttack; }
|
|
virtual void SetNextAttack( float flWait ) { m_flNextAttack = flWait; }
|
|
|
|
virtual void Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker, bool bIgnoreSpread );
|
|
void TankTrace( const Vector &vecStart, const Vector &vecForward, const Vector &vecSpread, trace_t &tr );
|
|
int GetRandomBurst( void );
|
|
float GetRandomFireTime( void );
|
|
|
|
void CalcPlayerCrosshairTarget( Vector *pVecTarget );
|
|
void CalcNPCEnemyTarget( Vector *pVecTarget );
|
|
|
|
inline bool IsPlayerManned( void ) { return m_hController && m_hController->IsPlayer() && ( m_spawnflags & SF_TANK_PLAYER ); }
|
|
inline bool IsNPCManned( void ) { return m_hController && m_hController->MyNPCPointer() && ( m_spawnflags & SF_TANK_NPC ); }
|
|
|
|
private:
|
|
void TrackTarget( void );
|
|
int DrawDebugTextOverlays(void);
|
|
void DrawDebugGeometryOverlays(void);
|
|
|
|
virtual void FiringSequence( const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker );
|
|
|
|
void StartRotSound( void );
|
|
void StopRotSound( void );
|
|
|
|
// Input handlers.
|
|
void InputActivate( inputdata_t &inputdata );
|
|
void InputDeactivate( inputdata_t &inputdata );
|
|
void InputSetFireRate( inputdata_t &inputdata );
|
|
void InputSetDamage( inputdata_t &inputdata );
|
|
void InputSetTargetDir( inputdata_t &inputdata );
|
|
void InputSetTargetPosition( inputdata_t &inputdata );
|
|
void InputSetTargetEntityName( inputdata_t &inputdata );
|
|
|
|
protected:
|
|
virtual void InputSetTargetEntity( inputdata_t &inputdata );
|
|
virtual void InputClearTargetEntity( inputdata_t &inputdata );
|
|
|
|
private:
|
|
void InputFindNPCToManTank( inputdata_t &inputdata );
|
|
void InputStopFindingNPCs( inputdata_t &inputdata );
|
|
void InputStartFindingNPCs( inputdata_t &inputdata );
|
|
void InputForceNPCOff( inputdata_t &inputdata );
|
|
void InputSetMaxRange( inputdata_t &inputdata );
|
|
|
|
inline bool CanFire( void );
|
|
bool InRange( float range );
|
|
bool InRange2( float flRange2 );
|
|
|
|
void TraceAttack( CBaseEntity *pAttacker, float flDamage, const Vector &vecDir, trace_t *ptr, int bitsDamageType);
|
|
|
|
QAngle AimBarrelAt( const Vector &parentTarget );
|
|
|
|
DECLARE_DATADESC();
|
|
|
|
bool OnControls( CBaseEntity *pTest );
|
|
bool HasController( void );
|
|
|
|
CBaseEntity *FindTarget( string_t targetName, CBaseEntity *pActivator );
|
|
|
|
// NPC
|
|
void NPC_FindController( void );
|
|
bool NPC_InRoute( void ) { return m_bNPCInRoute; }
|
|
bool NPC_InterruptController( void );
|
|
|
|
// Aim the tank at the player crosshair
|
|
void AimBarrelAtPlayerCrosshair( QAngle *pAngles );
|
|
|
|
// Aim the tank at the NPC's enemy
|
|
void AimBarrelAtNPCEnemy( QAngle *pAngles );
|
|
|
|
// Aim the tank at the func_tank's enemy
|
|
void AimFuncTankAtTarget( void );
|
|
|
|
// Returns true if the desired angles are out of range
|
|
bool RotateTankToAngles( const QAngle &angles, float *pDistX = NULL, float *pDistY = NULL );
|
|
|
|
// We lost our target!
|
|
void LostTarget( void );
|
|
|
|
// Purpose:
|
|
void ComputeLeadingPosition( const Vector &vecShootPosition, CBaseEntity *pTarget, Vector *pLeadPosition );
|
|
|
|
protected:
|
|
virtual void ControllerPostFrame( void );
|
|
|
|
virtual void TankActivate(void);
|
|
virtual void TankDeactivate(void);
|
|
|
|
float m_fireLast; // Last time I fired
|
|
float m_fireRate; // How many rounds/second
|
|
|
|
EHANDLE m_hTarget;
|
|
|
|
TANKBULLET m_bulletType; // Bullet type
|
|
int m_iBulletDamage; // 0 means use Bullet type's default damage
|
|
int m_iBulletDamageVsPlayer; // Damage vs player. 0 means use m_iBulletDamage
|
|
|
|
#ifdef HL2_EPISODIC
|
|
string_t m_iszAmmoType; // The name of the ammodef that we use when we fire. Bullet damage still comes from keyvalues.
|
|
int m_iAmmoType; // The cached index of the ammodef that we use when we fire.
|
|
#else
|
|
int m_iSmallAmmoType;
|
|
int m_iMediumAmmoType;
|
|
int m_iLargeAmmoType;
|
|
#endif // HL2_EPISODIC
|
|
|
|
int m_spread; // firing spread
|
|
|
|
EntityMatrix m_parentMatrix;
|
|
|
|
Vector m_sightOrigin; // Last sight of target
|
|
EHANDLE m_hFuncTankTarget;
|
|
|
|
int m_nBulletCount;
|
|
|
|
private:
|
|
|
|
// This is either the player manning the func_tank, or an NPC. The NPC is either manning the tank, or running
|
|
// to the man point. If he's en-route, m_bNPCInRoute will be true.
|
|
CHandle<CBaseCombatCharacter> m_hController;
|
|
|
|
float m_flNextAttack;
|
|
Vector m_vecControllerUsePos;
|
|
|
|
float m_yawCenter; // "Center" yaw
|
|
float m_yawCenterWorld; // "Center" yaw in world space
|
|
float m_yawRate; // Max turn rate to track targets
|
|
float m_yawRange; // Range of turning motion (one-sided: 30 is +/- 30 degress from center)
|
|
// Zero is full rotation
|
|
float m_yawTolerance; // Tolerance angle
|
|
|
|
float m_pitchCenter; // "Center" pitch
|
|
float m_pitchCenterWorld; // "Center" pitch in world space
|
|
float m_pitchRate; // Max turn rate on pitch
|
|
float m_pitchRange; // Range of pitch motion as above
|
|
float m_pitchTolerance; // Tolerance angle
|
|
|
|
float m_fireTime; // How much time has been used to fire the weapon so far.
|
|
float m_lastSightTime;// Last time I saw target
|
|
float m_persist; // Persistence of firing (how long do I shoot when I can't see)
|
|
float m_persist2; // Secondary persistence of firing (randomly shooting when I can't see)
|
|
float m_persist2burst;// How long secondary persistence burst lasts
|
|
float m_minRange; // Minimum range to aim/track
|
|
float m_maxRange; // Max range to aim/track
|
|
float m_flMinRange2;
|
|
float m_flMaxRange2;
|
|
int m_iAmmoCount; // ammo
|
|
|
|
Vector m_barrelPos; // Length of the freakin barrel
|
|
float m_spriteScale; // Scale of any sprites we shoot
|
|
string_t m_iszSpriteSmoke;
|
|
string_t m_iszSpriteFlash;
|
|
|
|
string_t m_iszMaster; // Master entity (game_team_master or multisource)
|
|
|
|
string_t m_soundStartRotate;
|
|
string_t m_soundStopRotate;
|
|
string_t m_soundLoopRotate;
|
|
|
|
float m_flPlayerGracePeriod;
|
|
float m_flIgnoreGraceUpto;
|
|
float m_flPlayerLockTimeBeforeFire;
|
|
float m_flLastSawNonPlayer;
|
|
|
|
string_t m_targetEntityName;
|
|
Vector m_vTargetPosition;
|
|
Vector m_vecNPCIdleTarget;
|
|
|
|
// Used for when the gun is attached to another entity
|
|
string_t m_iszBarrelAttachment;
|
|
int m_nBarrelAttachment;
|
|
string_t m_iszBaseAttachment;
|
|
|
|
// Used when the gun is actually a part of the parent entity, and pose params aim it
|
|
string_t m_iszYawPoseParam;
|
|
string_t m_iszPitchPoseParam;
|
|
float m_flYawPoseCenter;
|
|
float m_flPitchPoseCenter;
|
|
bool m_bUsePoseParameters;
|
|
|
|
// Lead the target?
|
|
bool m_bPerformLeading;
|
|
float m_flStartLeadFactor;
|
|
float m_flStartLeadFactorTime;
|
|
float m_flNextLeadFactor;
|
|
float m_flNextLeadFactorTime;
|
|
|
|
COutputEvent m_OnFire;
|
|
COutputEvent m_OnLoseTarget;
|
|
COutputEvent m_OnAquireTarget;
|
|
COutputEvent m_OnAmmoDepleted;
|
|
COutputEvent m_OnGotController;
|
|
COutputEvent m_OnLostController;
|
|
COutputEvent m_OnGotPlayerController;
|
|
COutputEvent m_OnLostPlayerController;
|
|
COutputEvent m_OnReadyToFire;
|
|
|
|
CHandle<CBaseTrigger> m_hControlVolume;
|
|
string_t m_iszControlVolume;
|
|
|
|
float m_flNextControllerSearch;
|
|
bool m_bShouldFindNPCs;
|
|
bool m_bNPCInRoute;
|
|
string_t m_iszNPCManPoint;
|
|
|
|
bool m_bReadyToFire;
|
|
|
|
int m_iEffectHandling;
|
|
};
|
|
|
|
#endif // FUNC_TANK_H
|