1HEADmaster

1 files changed, 272 insertions, 0 deletions

diff --git a/game/shared/tf2/basetfvehicle.h b/game/shared/tf2/basetfvehicle.h
new file mode 100644
index 0000000..47c5dae
--- /dev/null
+++ b/game/shared/tf2/basetfvehicle.h
@@ -0,0 +1,272 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: A base vehicle class
+//
+//=============================================================================//
+
+#ifndef BASETFVEHICLE_H
+#define BASETFVEHICLE_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "basetfplayer_shared.h"
+#include "baseobject_shared.h"
+#include "tf_obj_basedrivergun_shared.h"
+
+#if defined( CLIENT_DLL )
+#include "iclientvehicle.h"
+#else
+#include "IServerVehicle.h"
+#endif
+
+
+class CMoveData;
+class CUserCmd;
+class CBasePlayer;
+
+#if defined( CLIENT_DLL )
+#define CBaseTFVehicle C_BaseTFVehicle
+#endif
+
+class CBaseTFVehicle;
+class CBaseObjectDriverGun;
+
+struct VehicleBaseMoveData_t
+{
+	CBaseTFVehicle	*m_pVehicle;
+};
+
+// ------------------------------------------------------------------------ //
+// The base class that all vehicles in tf2 will derive from
+// ------------------------------------------------------------------------ //
+#if defined( CLIENT_DLL )
+class CBaseTFVehicle : public CBaseObject, public IClientVehicle
+#else
+class CBaseTFVehicle : public CBaseObject, public IServerVehicle
+#endif
+{
+	DECLARE_CLASS( CBaseTFVehicle, CBaseObject );
+
+public:
+
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CBaseTFVehicle();
+
+#if !defined (CLIENT_DLL)
+	// CBaseEntity overrides
+	virtual void	FinishedBuilding( void );
+	virtual void	DestroyObject( );
+	virtual void	Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	virtual bool	UseAttachedItem( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	virtual void	GetVectors(Vector* pForward, Vector* pRight, Vector* pUp) const;
+
+	virtual bool	ClientCommand( CBaseTFPlayer *pPlayer, const CCommand &args );
+
+	// IVehicle overrides
+	virtual IServerVehicle*	GetServerVehicle() { return this; }
+
+	virtual CBaseEntity* GetVehicleEnt();
+
+	// Get and set the current driver.
+	virtual void SetPassenger( int nRole, CBasePlayer *pEnt );
+
+	// Where do we get out of the vehicle?
+	virtual bool GetPassengerExitPoint( int nRole, Vector *pExitPoint, QAngle *pAngles );
+
+	virtual Class_T			ClassifyPassenger( CBasePlayer *pPassenger, Class_T defaultClassification ) { return defaultClassification; }
+	virtual float			DamageModifier ( CTakeDamageInfo &info ) { return 1.0; }
+	virtual const vehicleparams_t	*GetVehicleParams( void ) { return NULL; }
+
+	virtual bool			IsVehicleUpright( void ) { return true; }
+	virtual bool			IsPassengerEntering( void ) { Assert( 0 ); return true; }
+	virtual bool			IsPassengerExiting( void ) { Assert( 0 ); return true; }
+
+	// NPC Driving
+	virtual bool			NPC_CanDrive( void ) { return true; }
+	virtual void			NPC_SetDriver( CNPC_VehicleDriver *pDriver ) { return; }
+	virtual void			NPC_DriveVehicle( void ) { return; }
+	virtual void			NPC_ThrottleCenter( void ) { return; }
+	virtual void			NPC_ThrottleReverse( void ) { return; }
+	virtual void			NPC_ThrottleForward( void ) { return; }
+	virtual void			NPC_Brake( void ) { return; }
+	virtual void			NPC_TurnLeft( float flDegrees ) { return; }
+	virtual void			NPC_TurnRight( float flDegrees ) { return; }
+	virtual void			NPC_TurnCenter( void ) { return; }
+	virtual void			NPC_PrimaryFire( void ) { return; }
+	virtual void			NPC_SecondaryFire( void ) { return; }
+	virtual bool			NPC_HasPrimaryWeapon( void ) { return false; }
+	virtual bool			NPC_HasSecondaryWeapon( void ) { return false; }
+	virtual void			NPC_AimPrimaryWeapon( Vector vecTarget ) { return; }
+	virtual void			NPC_AimSecondaryWeapon( Vector vecTarget ) { return; }
+
+	// Weapon handling
+	virtual void			Weapon_PrimaryRanges( float *flMinRange, float *flMaxRange ) { *flMinRange = 0; *flMaxRange = 0; }
+	virtual void			Weapon_SecondaryRanges( float *flMinRange, float *flMaxRange ) { *flMinRange = 0; *flMaxRange = 0; }
+	virtual float			Weapon_PrimaryCanFireAt( void ) { return gpGlobals->curtime; }		// Return the time at which this vehicle's primary weapon can fire again
+	virtual float			Weapon_SecondaryCanFireAt( void ) { return gpGlobals->curtime; }	// Return the time at which this vehicle's secondary weapon can fire again
+
+	// Vehicles dont want to attach to anything they're built upon
+	virtual bool ShouldAttachToParent( void ) { return false; }
+
+	virtual bool	MustNotBeBuiltInConstructionYard( void ) const { return false; }
+
+	// Purpose: Try to board the vehicle
+	void AttemptToBoardVehicle( CBaseTFPlayer *pPlayer );
+
+	// Figure out which role of a parent vehicle this vehicle is sitting in..
+	int GetParentVehicleRole();
+
+	// Purpose: 
+	void GetPassengerExitPoint( CBasePlayer *pPlayer, int nRole, Vector *pAbsPosition, QAngle *pAbsAngles );
+	int	 GetEntryAnimForPoint( const Vector &vecPoint );
+	int  GetExitAnimToUse( Vector &vecEyeExitEndpoint, bool &bAllPointsBlocked );
+	void HandleEntryExitFinish( bool bExitAnimOn, bool bResetAnim );
+	void HandlePassengerEntry( CBasePlayer *pPlayer, bool bAllowEntryOutsideZone = false );
+	bool HandlePassengerExit( CBasePlayer *pPlayer );
+
+	// Deterioration
+	void	VehicleDeteriorationThink( void );
+	void	VehiclePassengerThink( void );
+
+#endif
+
+	bool	IsReadyToDrive( void );
+
+	virtual bool	IsAVehicle( void ) { return true; }
+
+	// Get a position in *local space* inside the vehicle for the player to start at
+	virtual void GetPassengerStartPoint( int nRole, Vector *pPoint, QAngle *pAngles );
+
+#if defined( CLIENT_DLL )
+	// C_BaseEntity overrides
+	virtual IClientVehicle*	GetClientVehicle() { return this; }
+
+	virtual C_BaseEntity	*GetVehicleEnt();
+
+	virtual void ClientThink();
+
+	// Fills in the unperterbed view position for a particular role.
+
+	// Prediction
+	virtual bool	ShouldPredict( void );
+	virtual bool	IsPredicted( void ) const { return true; }
+
+	// IClientVehicle
+
+	// Called at time player enters vehicle
+	virtual void	GetVehicleFOV( float &flFOV ) { return; }
+	virtual void	DrawHudElements( void );
+
+	// Get the angles that a player in the specified role should be using for visuals
+	virtual QAngle	GetPassengerAngles( QAngle angCurrent, int nRole );
+
+	// Allows the vehicle to restrict view angles
+	virtual void	UpdateViewAngles( C_BasePlayer *pLocalPlayer, CUserCmd *pCmd ) {}
+	virtual void	GetVehicleClipPlanes( float &flZNear, float &flZFar ) const {}
+
+	bool			IsBoostable( void )		{ return m_bBoostUpgrade; }
+
+	// Hud
+	virtual void	DrawHudBoostData( void );
+	virtual void	SetupCrosshair( void );
+
+#endif
+
+	int		LocateEntryPoint( CBaseTFPlayer *pPlayer, float* fBest2dDistanceSqr= NULL );
+
+	// This lets the object decide whether or not it wants to use the ThirdPersonCameraOrigin attachment for its view.
+	// The manned guns use first-person when they're on the ground and third-person when they're in a vehicle.
+	virtual bool	ShouldUseThirdPersonVehicleView();
+	virtual void	GetVehicleViewPosition( int nRole, Vector *pOrigin, QAngle *pAngles, float *pFOV = NULL );
+	virtual bool	GetRoleViewPosition( int nRole, Vector *pVehicleEyeOrigin, QAngle *pVehicleEyeAngles );
+	virtual bool	GetRoleAbsViewPosition( int nRole, Vector *pAbsVehicleEyeOrigin, QAngle *pAbsVehicleEyeAngles );
+
+	// Can a given passenger take damage?
+	virtual bool	IsPassengerDamagable( int nRole ) { return (nRole != VEHICLE_DRIVER); }
+
+
+	virtual void	Spawn();
+	virtual void	SetupMove( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move );
+	virtual void	ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMove ) {}
+	virtual void	FinishMove( CBasePlayer *player, CUserCmd *ucmd, CMoveData *move );
+	virtual void	ItemPostFrame( CBasePlayer *pPassenger );
+
+	virtual CBasePlayer* GetPassenger( int nRole = VEHICLE_DRIVER );
+	virtual int		GetPassengerRole( CBasePlayer *pEnt );
+
+	// Does the player use his normal weapons while in this mode?
+	virtual bool	IsPassengerUsingStandardWeapons( int nRole = VEHICLE_DRIVER ) { return false; }
+
+	virtual Vector GetSoundEmissionOrigin() const;
+
+	// Returns the driver as a tfplayer pointer
+	CBaseTFPlayer *GetDriverPlayer();
+	
+	int	GetMaxPassengerCount() const;
+	int GetPassengerCount() const;
+
+	// Is a particular player in the vehicle?
+	bool IsPlayerInVehicle( CBaseTFPlayer *pPlayer );
+
+	void	ResetDeteriorationTime( void );
+
+	// Driver controlled guns
+	void	SetDriverGun( CBaseObjectDriverGun *pGun );
+	void	VehicleDriverGunThink( void );
+
+protected:
+	enum
+	{
+		MAX_PASSENGERS = 4,
+		MAX_PASSENGER_BITS = 3
+	};
+
+	// Can we get into the vehicle?
+	virtual bool CanGetInVehicle( CBaseTFPlayer *pPlayer );
+
+	// Here's where we deal with weapons
+	virtual void OnItemPostFrame( CBaseTFPlayer *pDriver );
+
+	// Specify the number of roles we can have
+	void SetMaxPassengerCount( int nMaxPassengers );
+
+	bool	IsValidExitPoint( int nRole, Vector *pExitPoint, QAngle *pAngles );
+	int 	GetEmptyRole( void );
+
+private:
+#if !defined (CLIENT_DLL)
+	// Get the parent vehicle of this vehicle..
+	CBaseTFVehicle *GetParentVehicle();
+
+	// Get a position in *world space* inside the vehicle for the player to exit at
+	void GetInitialPassengerExitPoint( int nRole, Vector *pAbsPoint, QAngle *pAbsAngles );
+
+	// Figure out which role of a vehicle a child vehicle is sitting in..
+	int GetChildVehicleRole( CBaseTFVehicle *pChild );
+#endif
+
+private:
+	typedef CHandle<CBaseTFPlayer> CPlayerHandle;
+	CNetworkArray( CPlayerHandle, m_hPassengers, MAX_PASSENGERS );
+	CNetworkVar( int, m_nMaxPassengers );
+
+	// Driver controlled gun
+	CNetworkHandle( CBaseObjectDriverGun, m_hDriverGun );
+
+#if defined( CLIENT_DLL )
+
+	CHudTexture			*m_pIconDefaultCrosshair;
+
+	bool			m_bBoostUpgrade;
+	int				m_nBoostTimeLeft;
+
+private:
+	CBaseTFVehicle( const CBaseTFVehicle & ); // not defined, not accessible
+#endif
+};
+
+#endif // BASETFVEHICLE_H