314 lines
11 KiB
C++
314 lines
11 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#ifndef VEHICLE_BASE_H
|
|
#define VEHICLE_BASE_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "vphysics/vehicles.h"
|
|
#include "iservervehicle.h"
|
|
#include "fourwheelvehiclephysics.h"
|
|
#include "props.h"
|
|
#include "vehicle_sounds.h"
|
|
#include "phys_controller.h"
|
|
#include "entityblocker.h"
|
|
#include "vehicle_baseserver.h"
|
|
#include "vehicle_viewblend_shared.h"
|
|
|
|
class CNPC_VehicleDriver;
|
|
class CFourWheelVehiclePhysics;
|
|
class CPropVehicleDriveable;
|
|
class CSoundPatch;
|
|
|
|
// the tires are considered to be skidding if they have sliding velocity of 10 in/s or more
|
|
const float DEFAULT_SKID_THRESHOLD = 10.0f;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Four wheel physics vehicle server vehicle
|
|
//-----------------------------------------------------------------------------
|
|
class CFourWheelServerVehicle : public CBaseServerVehicle
|
|
{
|
|
DECLARE_CLASS( CFourWheelServerVehicle, CBaseServerVehicle );
|
|
|
|
// IServerVehicle
|
|
public:
|
|
virtual ~CFourWheelServerVehicle( void )
|
|
{
|
|
}
|
|
|
|
CFourWheelServerVehicle( void );
|
|
virtual bool IsVehicleUpright( void );
|
|
virtual bool IsVehicleBodyInWater( void );
|
|
virtual void GetVehicleViewPosition( int nRole, Vector *pOrigin, QAngle *pAngles, float *pFOV = NULL );
|
|
IPhysicsVehicleController *GetVehicleController();
|
|
const vehicleparams_t *GetVehicleParams( void );
|
|
const vehicle_controlparams_t *GetVehicleControlParams( void );
|
|
const vehicle_operatingparams_t *GetVehicleOperatingParams( void );
|
|
|
|
// NPC Driving
|
|
void NPC_SetDriver( CNPC_VehicleDriver *pDriver );
|
|
void NPC_DriveVehicle( void );
|
|
|
|
CPropVehicleDriveable *GetFourWheelVehicle( void );
|
|
bool GetWheelContactPoint( int nWheelIndex, Vector &vecPos );
|
|
|
|
public:
|
|
virtual void SetVehicle( CBaseEntity *pVehicle );
|
|
void InitViewSmoothing( const Vector &vecStartOrigin, const QAngle &vecStartAngles );
|
|
bool IsPassengerEntering( void );
|
|
bool IsPassengerExiting( void );
|
|
|
|
DECLARE_SIMPLE_DATADESC();
|
|
|
|
private:
|
|
CFourWheelVehiclePhysics *GetFourWheelVehiclePhysics( void );
|
|
|
|
ViewSmoothingData_t m_ViewSmoothing;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Base class for four wheel physics vehicles
|
|
//-----------------------------------------------------------------------------
|
|
class CPropVehicle : public CBaseProp, public CDefaultPlayerPickupVPhysics
|
|
{
|
|
DECLARE_CLASS( CPropVehicle, CBaseProp );
|
|
public:
|
|
CPropVehicle();
|
|
virtual ~CPropVehicle();
|
|
|
|
void SetVehicleType( unsigned int nVehicleType ) { m_nVehicleType = nVehicleType; }
|
|
unsigned int GetVehicleType( void ) { return m_nVehicleType; }
|
|
|
|
// CBaseEntity
|
|
void Spawn( void );
|
|
virtual int Restore( IRestore &restore );
|
|
void VPhysicsUpdate( IPhysicsObject *pPhysics );
|
|
void DrawDebugGeometryOverlays();
|
|
int DrawDebugTextOverlays();
|
|
void Teleport( const Vector *newPosition, const QAngle *newAngles, const Vector *newVelocity );
|
|
virtual void Think( void );
|
|
CFourWheelVehiclePhysics *GetPhysics( void ) { return &m_VehiclePhysics; }
|
|
CBasePlayer *HasPhysicsAttacker( float dt );
|
|
void OnPhysGunPickup( CBasePlayer *pPhysGunUser, PhysGunPickup_t reason );
|
|
|
|
Vector GetSmoothedVelocity( void ); //Save and update our smoothed velocity for prediction
|
|
|
|
virtual void DampenEyePosition( Vector &vecVehicleEyePos, QAngle &vecVehicleEyeAngles ) {}
|
|
|
|
// Inputs
|
|
void InputThrottle( inputdata_t &inputdata );
|
|
void InputSteering( inputdata_t &inputdata );
|
|
void InputAction( inputdata_t &inputdata );
|
|
void InputHandBrakeOn( inputdata_t &inputdata );
|
|
void InputHandBrakeOff( inputdata_t &inputdata );
|
|
|
|
DECLARE_DATADESC();
|
|
|
|
#ifdef HL2_EPISODIC
|
|
void AddPhysicsChild( CBaseEntity *pChild );
|
|
void RemovePhysicsChild( CBaseEntity *pChild );
|
|
#endif //HL2_EPISODIC
|
|
|
|
protected:
|
|
// engine sounds
|
|
void SoundInit();
|
|
void SoundShutdown();
|
|
void SoundUpdate( const vehicle_operatingparams_t ¶ms, const vehicleparams_t &vehicle );
|
|
void CalcWheelData( vehicleparams_t &vehicle );
|
|
void ResetControls();
|
|
|
|
// Upright strength of the controller (angular limit)
|
|
virtual float GetUprightStrength( void ) { return 8.0f; }
|
|
virtual float GetUprightTime( void ) { return 5.0f; }
|
|
|
|
protected:
|
|
CFourWheelVehiclePhysics m_VehiclePhysics;
|
|
unsigned int m_nVehicleType;
|
|
string_t m_vehicleScript;
|
|
|
|
#ifdef HL2_EPISODIC
|
|
CUtlVector<EHANDLE> m_hPhysicsChildren; // List of entities who wish to get physics callbacks from the vehicle
|
|
#endif //HL2_EPISODIC
|
|
|
|
private:
|
|
Vector m_vecSmoothedVelocity;
|
|
|
|
CHandle<CBasePlayer> m_hPhysicsAttacker;
|
|
|
|
float m_flLastPhysicsInfluenceTime;
|
|
};
|
|
|
|
//=============================================================================
|
|
// NPC Passenger Carrier interface
|
|
|
|
class INPCPassengerCarrier
|
|
{
|
|
public:
|
|
virtual bool NPC_CanEnterVehicle( CAI_BaseNPC *pPassenger, bool bCompanion ) = 0;
|
|
virtual bool NPC_CanExitVehicle( CAI_BaseNPC *pPassenger, bool bCompanion ) = 0;
|
|
virtual bool NPC_AddPassenger( CAI_BaseNPC *pPassenger, string_t strRoleName, int nSeatID ) = 0;
|
|
virtual bool NPC_RemovePassenger( CAI_BaseNPC *pPassenger ) = 0;
|
|
virtual void NPC_FinishedEnterVehicle( CAI_BaseNPC *pPassenger, bool bCompanion ) = 0;
|
|
virtual void NPC_FinishedExitVehicle( CAI_BaseNPC *pPassenger, bool bCompanion ) = 0;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Drivable four wheel physics vehicles
|
|
//-----------------------------------------------------------------------------
|
|
class CPropVehicleDriveable : public CPropVehicle, public IDrivableVehicle, public INPCPassengerCarrier
|
|
{
|
|
DECLARE_CLASS( CPropVehicleDriveable, CPropVehicle );
|
|
DECLARE_SERVERCLASS();
|
|
DECLARE_DATADESC();
|
|
public:
|
|
CPropVehicleDriveable( void );
|
|
~CPropVehicleDriveable( void );
|
|
|
|
virtual void Precache( void );
|
|
virtual void Spawn( void );
|
|
virtual int Restore( IRestore &restore );
|
|
virtual void OnRestore();
|
|
virtual void CreateServerVehicle( void );
|
|
virtual int ObjectCaps( void ) { return BaseClass::ObjectCaps() | FCAP_IMPULSE_USE; };
|
|
virtual void GetVectors(Vector* pForward, Vector* pRight, Vector* pUp) const;
|
|
virtual void VehicleAngleVectors( const QAngle &angles, Vector *pForward, Vector *pRight, Vector *pUp );
|
|
virtual void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
|
virtual void Think( void );
|
|
virtual void TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator );
|
|
virtual void Event_KilledOther( CBaseEntity *pVictim, const CTakeDamageInfo &info );
|
|
|
|
// Vehicle handling
|
|
virtual void VPhysicsCollision( int index, gamevcollisionevent_t *pEvent );
|
|
virtual int VPhysicsGetObjectList( IPhysicsObject **pList, int listMax );
|
|
|
|
// Inputs
|
|
void InputLock( inputdata_t &inputdata );
|
|
void InputUnlock( inputdata_t &inputdata );
|
|
void InputTurnOn( inputdata_t &inputdata );
|
|
void InputTurnOff( inputdata_t &inputdata );
|
|
|
|
// Locals
|
|
void ResetUseKey( CBasePlayer *pPlayer );
|
|
|
|
// Driving
|
|
void DriveVehicle( CBasePlayer *pPlayer, CUserCmd *ucmd ); // Player driving entrypoint
|
|
virtual void DriveVehicle( float flFrameTime, CUserCmd *ucmd, int iButtonsDown, int iButtonsReleased ); // Driving Button handling
|
|
|
|
virtual bool IsOverturned( void );
|
|
virtual bool IsVehicleBodyInWater( void ) { return false; }
|
|
|
|
// Engine handling
|
|
void StartEngine( void );
|
|
void StopEngine( void );
|
|
bool IsEngineOn( void );
|
|
|
|
// IDrivableVehicle
|
|
public:
|
|
virtual CBaseEntity *GetDriver( void );
|
|
virtual void ItemPostFrame( CBasePlayer *pPlayer ) { return; }
|
|
virtual void SetupMove( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move );
|
|
virtual void ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMoveData ) { return; }
|
|
virtual void FinishMove( CBasePlayer *player, CUserCmd *ucmd, CMoveData *move ) { return; }
|
|
virtual bool CanEnterVehicle( CBaseEntity *pEntity );
|
|
virtual bool CanExitVehicle( CBaseEntity *pEntity );
|
|
virtual void SetVehicleEntryAnim( bool bOn ) { m_bEnterAnimOn = bOn; }
|
|
virtual void SetVehicleExitAnim( bool bOn, Vector vecEyeExitEndpoint ) { m_bExitAnimOn = bOn; if ( bOn ) m_vecEyeExitEndpoint = vecEyeExitEndpoint; }
|
|
virtual void EnterVehicle( CBaseCombatCharacter *pPassenger );
|
|
|
|
virtual bool AllowBlockedExit( CBaseCombatCharacter *pPassenger, int nRole ) { return true; }
|
|
virtual bool AllowMidairExit( CBaseCombatCharacter *pPassenger, int nRole ) { return false; }
|
|
virtual void PreExitVehicle( CBaseCombatCharacter *pPassenger, int nRole ) {}
|
|
virtual void ExitVehicle( int nRole );
|
|
virtual string_t GetVehicleScriptName() { return m_vehicleScript; }
|
|
|
|
virtual bool PassengerShouldReceiveDamage( CTakeDamageInfo &info ) { return true; }
|
|
|
|
// If this is a vehicle, returns the vehicle interface
|
|
virtual IServerVehicle *GetServerVehicle() { return m_pServerVehicle; }
|
|
|
|
protected:
|
|
|
|
virtual bool ShouldThink() { return ( GetDriver() != NULL ); }
|
|
|
|
inline bool HasGun();
|
|
void DestroyServerVehicle();
|
|
|
|
// Contained IServerVehicle
|
|
CFourWheelServerVehicle *m_pServerVehicle;
|
|
|
|
COutputEvent m_playerOn;
|
|
COutputEvent m_playerOff;
|
|
|
|
COutputEvent m_pressedAttack;
|
|
COutputEvent m_pressedAttack2;
|
|
|
|
COutputFloat m_attackaxis;
|
|
COutputFloat m_attack2axis;
|
|
|
|
CNetworkHandle( CBasePlayer, m_hPlayer );
|
|
public:
|
|
|
|
CNetworkVar( int, m_nSpeed );
|
|
CNetworkVar( int, m_nRPM );
|
|
CNetworkVar( float, m_flThrottle );
|
|
CNetworkVar( int, m_nBoostTimeLeft );
|
|
CNetworkVar( int, m_nHasBoost );
|
|
|
|
CNetworkVector( m_vecEyeExitEndpoint );
|
|
CNetworkVector( m_vecGunCrosshair );
|
|
CNetworkVar( bool, m_bUnableToFire );
|
|
CNetworkVar( bool, m_bHasGun );
|
|
|
|
CNetworkVar( bool, m_nScannerDisabledWeapons );
|
|
CNetworkVar( bool, m_nScannerDisabledVehicle );
|
|
|
|
// NPC Driver
|
|
CHandle<CNPC_VehicleDriver> m_hNPCDriver;
|
|
EHANDLE m_hKeepUpright;
|
|
|
|
// --------------------------------
|
|
// NPC Passengers
|
|
public:
|
|
|
|
virtual bool NPC_CanEnterVehicle( CAI_BaseNPC *pPassenger, bool bCompanion );
|
|
virtual bool NPC_CanExitVehicle( CAI_BaseNPC *pPassenger, bool bCompanion );
|
|
virtual bool NPC_AddPassenger( CAI_BaseNPC *pPassenger, string_t strRoleName, int nSeatID );
|
|
virtual bool NPC_RemovePassenger( CAI_BaseNPC *pPassenger );
|
|
virtual void NPC_FinishedEnterVehicle( CAI_BaseNPC *pPassenger, bool bCompanion ) {}
|
|
virtual void NPC_FinishedExitVehicle( CAI_BaseNPC *pPassenger, bool bCompanion ) {}
|
|
|
|
// NPC Passengers
|
|
// --------------------------------
|
|
|
|
bool IsEnterAnimOn( void ) { return m_bEnterAnimOn; }
|
|
bool IsExitAnimOn( void ) { return m_bExitAnimOn; }
|
|
const Vector &GetEyeExitEndpoint( void ) { return m_vecEyeExitEndpoint; }
|
|
|
|
protected:
|
|
// Entering / Exiting
|
|
bool m_bEngineLocked; // Mapmaker override on whether the vehicle's allowed to be turned on/off
|
|
bool m_bLocked;
|
|
float m_flMinimumSpeedToEnterExit;
|
|
CNetworkVar( bool, m_bEnterAnimOn );
|
|
CNetworkVar( bool, m_bExitAnimOn );
|
|
|
|
// Used to turn the keepupright off after a short time
|
|
float m_flTurnOffKeepUpright;
|
|
float m_flNoImpactDamageTime;
|
|
};
|
|
|
|
|
|
inline bool CPropVehicleDriveable::HasGun()
|
|
{
|
|
return m_bHasGun;
|
|
}
|
|
|
|
|
|
#endif // VEHICLE_BASE_H
|