350 lines
12 KiB
C++
350 lines
12 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#ifndef VEHICLE_BASE_H
|
|
#define VEHICLE_BASE_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "entityblocker.h"
|
|
#include "fourwheelvehiclephysics.h"
|
|
#include "iservervehicle.h"
|
|
#include "phys_controller.h"
|
|
#include "props.h"
|
|
#include "vehicle_baseserver.h"
|
|
#include "vehicle_sounds.h"
|
|
#include "vehicle_viewblend_shared.h"
|
|
#include "vphysics/vehicles.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
|