//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: A base vehicle class
//
//=============================================================================//

#include "cbase.h"
#include "basetfvehicle.h"
#include "tf_movedata.h"
#include "in_buttons.h"
#include "baseplayer_shared.h"

#if defined( CLIENT_DLL )
	#include "hud_vehicle_role.h"
	#include "hud.h"
	#include "hud_crosshair.h"
#else
	#include "tf_team.h"
	#include "tf_gamerules.h"
	#include "tf_func_construction_yard.h"
	#include "ndebugoverlay.h"
#endif

IMPLEMENT_NETWORKCLASS_ALIASED( BaseTFVehicle, DT_BaseTFVehicle );

BEGIN_NETWORK_TABLE( CBaseTFVehicle, DT_BaseTFVehicle )
#if !defined( CLIENT_DLL )
	SendPropInt( SENDINFO(m_nMaxPassengers), CBaseTFVehicle::MAX_PASSENGER_BITS, SPROP_UNSIGNED ),
	SendPropArray( SendPropEHandle(SENDINFO_ARRAY(m_hPassengers)), m_hPassengers ),
	SendPropEHandle( SENDINFO(m_hDriverGun) ),
#else
	RecvPropInt( RECVINFO(m_nMaxPassengers) ),
	RecvPropArray( RecvPropEHandle(RECVINFO(m_hPassengers[0])), m_hPassengers ),
	RecvPropEHandle( RECVINFO(m_hDriverGun) ),
#endif
END_NETWORK_TABLE()

BEGIN_PREDICTION_DATA( CBaseTFVehicle )

	DEFINE_PRED_ARRAY( m_hPassengers, FIELD_EHANDLE, CBaseTFVehicle::MAX_PASSENGERS, FTYPEDESC_INSENDTABLE ),

END_PREDICTION_DATA()

extern float RemapAngleRange( float startInterval, float endInterval, float value );
extern ConVar road_feel;

ConVar vehicle_view_offset_forward( "vehicle_view_offset_forward", "-280", FCVAR_REPLICATED );
ConVar vehicle_view_offset_right( "vehicle_view_offset_right", "0", FCVAR_REPLICATED );
ConVar vehicle_view_offset_up( "vehicle_view_offset_up", "50", FCVAR_REPLICATED );
ConVar vehicle_thirdperson( "vehicle_thirdperson", "1", FCVAR_REPLICATED, "Enable/disable thirdperson camera view in vehicles" );

ConVar vehicle_attach_eye_angles( "vehicle_attach_eye_angles", "0", FCVAR_REPLICATED, "Attach player eye angles to vehicle attachments" );

#define PITCH_CURVE_ZERO		10	// pitch less than this is clamped to zero
#define PITCH_CURVE_LINEAR		45	// pitch greater than this is copied out

#define ROLL_CURVE_ZERO		5		// roll less than this is clamped to zero
#define ROLL_CURVE_LINEAR	45		// roll greater than this is copied out

#if defined( CLIENT_DLL )
	ConVar road_feel( "road_feel", "0.1", FCVAR_NOTIFY | FCVAR_REPLICATED );
#else
	// Deterioration
	#define DETERIORATION_THINK_CONTEXT			"VehicleDeteriorationThink"
	#define PASSENGER_THINK_CONTEXT				"VehiclePassengerThink"
	ConVar  vehicle_deterioration_start_time( "vehicle_deterioration_start_time", "90", 0, "Time it takes for a vehicle to start deteriorating after being left alone." );

	#define DETERIORATION_DISTANCE				(600 * 600)		// Never deteriorate if team mates are within this distance

#endif // CLIENT_DLL

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CBaseTFVehicle::CBaseTFVehicle()
{
	SetPredictionEligible( true );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBaseTFVehicle::Spawn()
{
	BaseClass::Spawn();
	CollisionProp()->SetSurroundingBoundsType( USE_OBB_COLLISION_BOUNDS );

#if defined( CLIENT_DLL )
	SetNextClientThink( CLIENT_THINK_ALWAYS );
	m_pIconDefaultCrosshair = NULL;
#else
	m_fObjectFlags |= OF_DOESNT_NEED_POWER | OF_MUST_BE_BUILT_ON_ATTACHMENT;
	SetContextThink( VehiclePassengerThink, 2.0, PASSENGER_THINK_CONTEXT );
#endif
}


//-----------------------------------------------------------------------------
// Vehicle overrides
//-----------------------------------------------------------------------------
CBaseEntity* CBaseTFVehicle::GetVehicleEnt()
{
	return this;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBaseTFVehicle::SetupMove( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move )
{
	// animate + update attachment points
#ifdef CLIENT_DLL
	StudioFrameAdvance();
#else
	StudioFrameAdvance();
	// This calls StudioFrameAdvance, then we use the results from that to determine where to move.
	DispatchAnimEvents( this );
#endif
	
	CTFMoveData *pMoveData = (CTFMoveData*)move; 
	Assert( sizeof(VehicleBaseMoveData_t) <= pMoveData->VehicleDataMaxSize() );

	VehicleBaseMoveData_t *pVehicleData = (VehicleBaseMoveData_t*)pMoveData->VehicleData();
	pVehicleData->m_pVehicle = this;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBaseTFVehicle::FinishMove( CBasePlayer *player, CUserCmd *ucmd, CMoveData *move )
{
	VehicleDriverGunThink();
}

//-----------------------------------------------------------------------------
// Purpose: Returns the driver as a tfplayer pointer
//-----------------------------------------------------------------------------
CBaseTFPlayer *CBaseTFVehicle::GetDriverPlayer()
{
	return m_hPassengers[VEHICLE_DRIVER].Get();
}

//-----------------------------------------------------------------------------
// Purpose: Can we get into the vehicle?
//-----------------------------------------------------------------------------
bool CBaseTFVehicle::CanGetInVehicle( CBaseTFPlayer *pPlayer )
{
	if ( !IsPowered() )
		return false;

	if ( !InSameTeam( pPlayer ) )
		return false;

	// Player/Class-specific query.
	return pPlayer->CanGetInVehicle();
}

//-----------------------------------------------------------------------------
// Purpose: Here's where we deal with weapons
//-----------------------------------------------------------------------------
void CBaseTFVehicle::OnItemPostFrame( CBaseTFPlayer *pDriver )
{
	// If we have a gun for the driver, handle it
	if ( m_hDriverGun )
	{
		if ( GetPassengerRole(pDriver) != VEHICLE_DRIVER )
			return;

		if ( pDriver->m_nButtons & (IN_ATTACK | IN_ATTACK2) )
		{
			// Time to fire?
			if ( m_hDriverGun->CanFireNow() )
			{
				m_hDriverGun->Fire( pDriver );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CBaseTFVehicle::GetPassengerRole( CBasePlayer *pEnt )
{
	Assert( pEnt->IsPlayer() );
	for ( int i = m_nMaxPassengers; --i >= 0; )
	{
		if (m_hPassengers[i] == pEnt)
		{
			return i;
		}
	}
	return -1;
}

Vector CBaseTFVehicle::GetSoundEmissionOrigin() const
{
	return WorldSpaceCenter() + Vector( 0, 0, 64 );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CBasePlayer* CBaseTFVehicle::GetPassenger( int nRole )
{
	return m_hPassengers[nRole].Get();
}


//-----------------------------------------------------------------------------
// Is a particular player in the vehicle?
//-----------------------------------------------------------------------------
bool CBaseTFVehicle::IsPlayerInVehicle( CBaseTFPlayer *pPlayer )
{
	return (GetPassengerRole( pPlayer ) >= 0);
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CBaseTFVehicle::GetPassengerCount() const
{
	// FIXME: Cache this off!
	int nCount = 0;
	for (int i = m_nMaxPassengers; --i >= 0; )
	{
		if (m_hPassengers[i].Get())
		{
			++nCount;
		}
	}
	return nCount;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CBaseTFVehicle::GetMaxPassengerCount() const
{
	return m_nMaxPassengers;
}

//-----------------------------------------------------------------------------
// Process input
//-----------------------------------------------------------------------------
void CBaseTFVehicle::ItemPostFrame( CBasePlayer *pPassenger )
{
#ifndef CLIENT_DLL
	Assert( GetPassengerRole( pPassenger ) != -1 );
	if (pPassenger->m_afButtonPressed & (IN_USE /*| IN_JUMP*/)) 
	{
		// Get the player out..
		pPassenger->LeaveVehicle();
		return;
	}
#endif

	OnItemPostFrame( static_cast<CBaseTFPlayer*>(pPassenger) );
}

//-----------------------------------------------------------------------------
// Purpose: Reset the time before this vehicle begins to deteriorate
//-----------------------------------------------------------------------------
void CBaseTFVehicle::ResetDeteriorationTime( void )
{
#if !defined (CLIENT_DLL)
	SetContextThink( VehicleDeteriorationThink, gpGlobals->curtime + vehicle_deterioration_start_time.GetFloat(), DETERIORATION_THINK_CONTEXT );
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Prevent driving in construction yards
//-----------------------------------------------------------------------------
bool CBaseTFVehicle::IsReadyToDrive( void )
{
#if !defined( CLIENT_DLL )
	return ( PointInConstructionYard( GetAbsOrigin() ) == false );
#else
	return true;
#endif
}


//-----------------------------------------------------------------------------
// Process input
//-----------------------------------------------------------------------------
void CBaseTFVehicle::SetMaxPassengerCount( int nCount )
{
#if !defined( CLIENT_DLL )
	Assert( (nCount >= 1) && (nCount <= MAX_PASSENGERS) );
	m_nMaxPassengers = nCount;
#endif
}

//-----------------------------------------------------------------------------
//
// Server-only code here
//
//-----------------------------------------------------------------------------

#if !defined (CLIENT_DLL)
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBaseTFVehicle::FinishedBuilding( void )
{
	BaseClass::FinishedBuilding();

	// See if we've finished building on a vehicle that has a passenger slot assigned to my buildpoint.
	CBaseObject	*pParent = GetParentObject();
	if ( pParent && pParent->IsAVehicle() )
	{
		CBaseTFVehicle *pVehicle = static_cast<CBaseTFVehicle*>(pParent);
		int iRole = pVehicle->GetChildVehicleRole( this );
		if ( iRole != -1 )
		{
			// Is there a player in the role assigned to this buildpoint?
			CBaseTFPlayer *pExistingPlayer = static_cast<CBaseTFPlayer*>( pVehicle->GetPassenger( iRole ) );
			if ( pExistingPlayer )
			{
				// Remove the player from my parent vehicle and put them in me
				pExistingPlayer->LeaveVehicle();

				// Get in the vehicle.
				pExistingPlayer->GetInVehicle( this, VEHICLE_DRIVER );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBaseTFVehicle::VehicleDeteriorationThink( void )
{
	StartDeteriorating();

	SetContextThink( NULL, gpGlobals->curtime + vehicle_deterioration_start_time.GetFloat(), DETERIORATION_THINK_CONTEXT );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBaseTFVehicle::VehiclePassengerThink( void )
{
	SetNextThink( gpGlobals->curtime + 10.0, PASSENGER_THINK_CONTEXT );

	if ( IsPlacing() )
	{
		ResetDeteriorationTime();
		return;
	}

	// If there are any passengers in the vehicle, push off deterioration time
	if ( GetPassengerCount() )
	{
		ResetDeteriorationTime();
		return;
	}

	// See if there are any team members nearby
	if ( GetTeam() )
	{
		int iNumPlayers = GetTFTeam()->GetNumPlayers();
		for ( int i = 0; i < iNumPlayers; i++ )
		{
			if ( GetTFTeam()->GetPlayer(i) )
			{
				Vector vecOrigin = GetTFTeam()->GetPlayer(i)->GetAbsOrigin();
				if ( (vecOrigin - GetAbsOrigin()).LengthSqr() < DETERIORATION_DISTANCE )
				{
					// Found one nearby, reset our deterioration time
					ResetDeteriorationTime();
					return;
				}
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Figure out which role of a vehicle a child vehicle is sitting in..
//-----------------------------------------------------------------------------
int CBaseTFVehicle::GetChildVehicleRole( CBaseTFVehicle *pChild )
{
	int nBuildPoints = GetNumBuildPoints();
	for( int i = 0; i < nBuildPoints; i++ )
	{	
		CBaseObject* pObject = GetBuildPointObject(i);
		if (pObject == pChild)
		{
			return GetBuildPointPassenger(i);
		}
	}

	return -1;
}


//-----------------------------------------------------------------------------
// Purpose: Vehicles are permanently oriented off angle for vphysics.
//-----------------------------------------------------------------------------
void CBaseTFVehicle::GetVectors(Vector* pForward, Vector* pRight, Vector* pUp) const
{
	// This call is necessary to cause m_rgflCoordinateFrame to be recomputed
	const matrix3x4_t &entityToWorld = EntityToWorldTransform();

	if (pForward != NULL)
	{
		MatrixGetColumn( entityToWorld, 1, *pForward ); 
	}

	if (pRight != NULL)
	{
		MatrixGetColumn( entityToWorld, 0, *pRight ); 
	}

	if (pUp != NULL)
	{
		MatrixGetColumn( entityToWorld, 2, *pUp ); 
	}
}

//-----------------------------------------------------------------------------
// Purpose: Get into the vehicle
//-----------------------------------------------------------------------------
void CBaseTFVehicle::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
	BaseClass::Use( pActivator, pCaller, useType, value );

	if ( useType == USE_ON )
	{
		CBaseTFPlayer *pPlayer = dynamic_cast<CBaseTFPlayer*>(pActivator);
		if ( pPlayer && InSameTeam(pPlayer) )
		{
			// Check to see if we are really using nearby build points:
			if( !UseAttachedItem( pActivator, pCaller, useType, value ) )
			{
				// Attempt to board the vehicle:
				AttemptToBoardVehicle( pPlayer );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Figure out if I should be using an attached item rather than this vehicle itself.
//-----------------------------------------------------------------------------
bool CBaseTFVehicle::UseAttachedItem( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
	CBaseTFPlayer* pPlayer = dynamic_cast<CBaseTFPlayer*>(pActivator);
	if ( !pPlayer || !InSameTeam(pPlayer) )
		return false;

	Vector vecPlayerOrigin = pPlayer->GetAbsOrigin();
	int nBestBuildPoint = -1;
	float fBestDistance = FLT_MAX;

	// Get the closest regular entry point:
	int nRole = LocateEntryPoint( pPlayer, &fBestDistance );

	// Iterate through each of the build points, if any, and see which we are closest to.
	int nBuildPoints = GetNumBuildPoints();
	for( int i = 0; i < nBuildPoints; i++ )
	{	
		CBaseObject* pObject = GetBuildPointObject(i);

		// If there's something in the build point that isn't in the process of being built or placed:
		if( pObject && !pObject->IsPlacing() && !pObject->IsBuilding() ) 
		{
			Vector vecOrigin;
			QAngle vecAngles;

			// If the build point is the default point for this role, just take it 
			if (GetBuildPointPassenger(i) == nRole)
			{
				nBestBuildPoint = i;
				break;
			}

			// And I can get the build point.
			if( GetBuildPoint( i, vecOrigin, vecAngles )  )
			{
				float fLength2dSqr = (vecOrigin - vecPlayerOrigin).AsVector2D().LengthSqr();
				if( fLength2dSqr < fBestDistance )
				{
					nBestBuildPoint = i;
					fBestDistance = fLength2dSqr; 
				}
			}
		}
	}

	if( nBestBuildPoint >= 0 )
	{
		// They're using an item on me, so push out the deterioration time
		ResetDeteriorationTime();
		GetBuildPointObject(nBestBuildPoint)->Use( pActivator, pCaller, useType, value );
		return true;
	}

	return false;
}


//-----------------------------------------------------------------------------
// Purpose: Object has been removed...
//-----------------------------------------------------------------------------
void CBaseTFVehicle::DestroyObject( void )
{
	for (int i = m_nMaxPassengers; --i >= 0; )
	{
		if (m_hPassengers[i])
		{
			m_hPassengers[i]->LeaveVehicle();
		}
	}

	BaseClass::DestroyObject();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CBaseTFVehicle::GetEmptyRole( void )
{
	for ( int iPassenger = 0; iPassenger < m_nMaxPassengers; ++iPassenger )
	{
		if ( !m_hPassengers[iPassenger].Get() )
			return iPassenger;
	}

	return -1;	
}


//-----------------------------------------------------------------------------
// Purpose: Try to board the vehicle
//-----------------------------------------------------------------------------
void CBaseTFVehicle::AttemptToBoardVehicle( CBaseTFPlayer *pPlayer )
{
	if ( !CanGetInVehicle( pPlayer ) )
		return;

	// Locate the entry point.
	int nRole = LocateEntryPoint( pPlayer );
	if ( nRole != -1 )
	{
		// Set the owner flag.
		bool bOwner = ( pPlayer == GetOwner() );
		if ( bOwner )
		{
			// Check to see if a player exists at this location (role).
			CBaseTFPlayer *pExistingPlayer = static_cast<CBaseTFPlayer*>( GetPassenger( nRole ) );
			if ( pExistingPlayer )
			{
				pExistingPlayer->LeaveVehicle();

				// Get in the vehicle.
				pPlayer->GetInVehicle( this, nRole );

				// Then see if we can move the other player to another slot in this vehicle
				int nEmptyRole = GetEmptyRole();
				if ( nEmptyRole != -1 )
				{
					pExistingPlayer->GetInVehicle( this, nEmptyRole );
				}
				return;
			}
		}

		// Get in the vehicle.
		pPlayer->GetInVehicle( this, nRole );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Handle commands sent from vgui panels on the client 
//-----------------------------------------------------------------------------
bool CBaseTFVehicle::ClientCommand( CBaseTFPlayer *pPlayer, const CCommand &args )
{
	ResetDeteriorationTime();

	if ( FStrEq( pCmd, "toggle_use" ) )
	{
		AttemptToBoardVehicle( pPlayer );
		return true;
	}

	return BaseClass::ClientCommand( pPlayer, args );
}

//-----------------------------------------------------------------------------
// Get a position in *world space* inside the vehicle for the player to exit at
// NOTE: This doesn't check for obstructions
//-----------------------------------------------------------------------------
void CBaseTFVehicle::GetInitialPassengerExitPoint( int nRole, Vector *pAbsPoint, QAngle *pAbsAngles )
{
	char pAttachmentName[32];
	Q_snprintf( pAttachmentName, sizeof( pAttachmentName ), "vehicle_exit_passenger%d", nRole );
	int exitAttachmentIndex = LookupAttachment(pAttachmentName);
	if (exitAttachmentIndex <= 0)
	{
		// bad attachment, just return the origin
		*pAbsPoint = GetAbsOrigin();
		pAbsPoint->z += WorldAlignMaxs()[2] + 50.0f;
		return;
	}

	QAngle vehicleExitAngles;
	if( !pAbsAngles )
	{
		pAbsAngles = &vehicleExitAngles;
	}

	GetAttachment( exitAttachmentIndex, *pAbsPoint, *pAbsAngles );
}


//-----------------------------------------------------------------------------
// Get a point to leave the vehicle from
//-----------------------------------------------------------------------------
bool CBaseTFVehicle::IsValidExitPoint( int nRole, Vector *pExitPoint, QAngle *pAngles )
{
	GetInitialPassengerExitPoint( nRole, pExitPoint, pAngles );

	// Check the exit point:
	Vector vecStart = *pExitPoint;
	Vector vecEnd = *pExitPoint + Vector(0,0,20);
	trace_t tr;
	UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);
	if ( (tr.fraction < 1.f)  )
		return false;

	vecEnd = *pExitPoint + Vector(20,20,20);
	UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);
	if ( (tr.fraction < 1.f)  )
		return false;

	vecEnd = *pExitPoint + Vector(-20,-20,20);
	UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);
	if ( (tr.fraction < 1.f)  )
		return false;

	vecEnd = *pExitPoint + Vector(20,-20,20);
	UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);
	if ( (tr.fraction < 1.f)  )
		return false;

	vecEnd = *pExitPoint + Vector(-20,20,20);
	UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);
	if ( (tr.fraction < 1.f)  )
		return false;

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBaseTFVehicle::GetPassengerExitPoint( CBasePlayer *pPlayer, int nRole, Vector *pAbsPosition, QAngle *pAbsAngles )
{

	// Deal with vehicles built on other vehicles
	CBaseTFVehicle *pParentVehicle = dynamic_cast<CBaseTFVehicle*>(GetMoveParent());
	if (pParentVehicle)
	{
		int nParentVehicleRole = pParentVehicle->GetChildVehicleRole( this );
		if (nParentVehicleRole >= 0)
		{
			pParentVehicle->GetPassengerExitPoint( pPlayer, nParentVehicleRole, pAbsPosition, pAbsAngles );
			return;
		}
	}

	// Deal with vehicles build on objects
	IHasBuildPoints *pMount = dynamic_cast<IHasBuildPoints*>(GetMoveParent());
	if (pMount)
	{
		int nBuildPoint = pMount->FindObjectOnBuildPoint( this );
		if (nBuildPoint >= 0)
		{
			pMount->GetExitPoint( pPlayer, nBuildPoint, pAbsPosition, pAbsAngles );
			return;
		}
	}

	Vector vNewPos;
	GetInitialPassengerExitPoint( nRole, pAbsPosition, pAbsAngles );
	if ( EntityPlacementTest(pPlayer, *pAbsPosition, vNewPos, true) )
	{
		*pAbsPosition = vNewPos;
		return;
	}

	// Find the first valid exit point
	for( int iExitPoint = 0; iExitPoint < m_nMaxPassengers; ++iExitPoint )
	{
		if (iExitPoint == nRole)
			continue;

		GetInitialPassengerExitPoint( iExitPoint, pAbsPosition, pAbsAngles );
		if ( EntityPlacementTest(pPlayer, *pAbsPosition, vNewPos, true) )
		{
			*pAbsPosition = vNewPos;
			return;
		}
	}

	// Worst case, we will be returning the vehicle's origin + 50z here
	*pAbsPosition = GetAbsOrigin();
	pAbsPosition->z = WorldAlignMaxs()[2] + 150.0f;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CBaseTFVehicle::GetPassengerExitPoint( int nRole, Vector *pAbsPosition, QAngle *pAbsAngles )
{
	// FIXME: Clean this up
	CBasePlayer *pPlayer = GetPassenger(nRole);
	GetPassengerExitPoint( pPlayer, nRole, pAbsPosition, pAbsAngles );
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CBaseTFVehicle::GetEntryAnimForPoint( const Vector &vecPoint )
{
	return ACTIVITY_NOT_AVAILABLE;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CBaseTFVehicle::GetExitAnimToUse( Vector &vecEyeExitEndpoint, bool &bAllPointsBlocked )
{
	bAllPointsBlocked = false;
	return ACTIVITY_NOT_AVAILABLE;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBaseTFVehicle::HandleEntryExitFinish( bool bExitAnimOn, bool bResetAnim )
{
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pPlayer - 
//			false - 
//-----------------------------------------------------------------------------
void CBaseTFVehicle::HandlePassengerEntry( CBasePlayer *pPlayer, bool bAllowEntryOutsideZone )
{
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pPlayer - 
//-----------------------------------------------------------------------------
bool CBaseTFVehicle::HandlePassengerExit( CBasePlayer *pPlayer )
{
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Get and set the current driver.
//-----------------------------------------------------------------------------
void CBaseTFVehicle::SetPassenger( int nRole, CBasePlayer *pEnt )
{
	Assert( !pEnt || pEnt->IsPlayer() );
	Assert( nRole >= 0 && nRole < m_nMaxPassengers );
	Assert( !m_hPassengers[nRole].Get() || !pEnt );
	m_hPassengers.Set( nRole, dynamic_cast<CBaseTFPlayer*>(pEnt) );

	// If the vehicle's deteriorating, I get to own it now
	if ( IsDeteriorating() )
	{
		StopDeteriorating();
		SetBuilder( (CBaseTFPlayer*)pEnt, true );
	}

	ResetDeteriorationTime();
}

#endif

//-----------------------------------------------------------------------------
// Get a position in *world space* inside the vehicle for the player to start at
//-----------------------------------------------------------------------------
void CBaseTFVehicle::GetPassengerStartPoint( int nRole, Vector *pAbsPoint, QAngle *pAbsAngles )
{
	char pAttachmentName[32];
	Q_snprintf( pAttachmentName, sizeof( pAttachmentName ), "vehicle_feet_passenger%d", nRole );
	int nFeetAttachmentIndex = LookupAttachment(pAttachmentName);
	GetAttachment( nFeetAttachmentIndex, *pAbsPoint, *pAbsAngles );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
#define INITIAL_MAX_DISTANCE  999999.0f

int CBaseTFVehicle::LocateEntryPoint( CBaseTFPlayer *pPlayer, float* fBest2dDistanceSqr )
{
	// Get the players origin and compare it to all the entry points on the
	// vehicle.
	Vector vecPlayerPos = pPlayer->GetAbsOrigin();
	Vector vecEntryPos;
	QAngle vecEntryAngle;

	int   iMinEntry = -1;
	float flMinDistance2 = INITIAL_MAX_DISTANCE;

	// Is the player the owner of the vehicle?
	bool bOwner = ( pPlayer == GetOwner() );

	char szPassengerEyes[32];
	for( int iEntryPoint = 0; iEntryPoint < m_nMaxPassengers; ++iEntryPoint )
	{
		// If not the owner, check to see if the entry point is available.  The
		// entry point is always available for the owner.
		bool bOccupied = ( GetPassenger( iEntryPoint ) != NULL );

		// Also check for child vehicles...

		if ( bOccupied && !bOwner )
			continue;
	
		// FIXME: Cache off the entry point
		Q_snprintf( szPassengerEyes, sizeof( szPassengerEyes ), "vehicle_feet_passenger%d", iEntryPoint );
		int nAttachmentIndex = LookupAttachment( szPassengerEyes );

		float flDistance2;
		if (nAttachmentIndex > 0)
		{
			GetAttachment( nAttachmentIndex, vecEntryPos, vecEntryAngle );
			Vector vecDelta = vecEntryPos - vecPlayerPos;
			flDistance2 = vecDelta.AsVector2D().LengthSqr();
		}
		else
		{
			// No attachment? Choose it if we must as a last resort
			flDistance2 = INITIAL_MAX_DISTANCE - 1;
		}

		if ( flDistance2 < flMinDistance2 )
		{
			flMinDistance2 = flDistance2;
			iMinEntry = iEntryPoint;
		}
	}

	if( fBest2dDistanceSqr )
	{
		*fBest2dDistanceSqr = flMinDistance2;
	}
	return iMinEntry;
}

//-----------------------------------------------------------------------------
// Purpose: Set a gun that the driver can control
//-----------------------------------------------------------------------------
void CBaseTFVehicle::SetDriverGun( CBaseObjectDriverGun *pGun )
{
	m_hDriverGun = pGun;
}

//-----------------------------------------------------------------------------
// Purpose: Update the driver's gun
//-----------------------------------------------------------------------------
void CBaseTFVehicle::VehicleDriverGunThink( void )
{
	if ( !m_hDriverGun )
		return;

	// No driver?
	CBaseTFPlayer *pDriver = GetDriverPlayer();
	if ( !pDriver )
		return;

	QAngle vecTargetAngles = m_hDriverGun->GetCurrentAngles();

	// Cast a ray out of the view to see where the player is looking.
	trace_t trace;
	Vector vecForward;
	Vector vecSrc;
	QAngle angEyeAngles;
	GetVehicleViewPosition( VEHICLE_DRIVER, &vecSrc, &angEyeAngles, NULL );
	AngleVectors( angEyeAngles, &vecForward, NULL, NULL );
	Vector vecEnd = vecSrc + (vecForward * 10000);
	UTIL_TraceLine( vecSrc, vecEnd, MASK_OPAQUE, this, COLLISION_GROUP_NONE, &trace );

	//NDebugOverlay::Box( vecSrc, -Vector(10,10,10), Vector(10,10,10), 255,0,0,8, 5 );
	//NDebugOverlay::Box( vecEnd, -Vector(10,10,10), Vector(10,10,10), 0,255,0,8, 5 );
	//NDebugOverlay::Box( trace.endpos, -Vector(10,10,10), Vector(10,10,10), 255,255,255,8, 0.1 );

	if ( trace.fraction < 1 )
	{
		// Figure out what angles our turret needs to be at in order to hit the target.
		Vector vFireOrigin = m_hDriverGun->GetFireOrigin();

		//NDebugOverlay::Box( vFireOrigin, -Vector(10,10,10), Vector(10,10,10), 0,255,0,8, 0.1 );

		// Get a direction vector that points at the target.
		Vector vTo = trace.endpos - vFireOrigin;

		// Transform it into the tank's local space.
		matrix3x4_t tankToWorld;
		AngleMatrix( GetAbsAngles(), tankToWorld );
		
		Vector vLocalTo;
		VectorITransform( vTo, tankToWorld, vLocalTo );

		// Now figure out what the angles are in local space.
		QAngle localAngles;
		VectorAngles( vLocalTo, localAngles );

		vecTargetAngles[YAW] = localAngles[YAW] - 90;
		vecTargetAngles[PITCH] = anglemod( localAngles[PITCH] );
	}

	// Set the gun's angles
	m_hDriverGun->SetTargetAngles( vecTargetAngles );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseTFVehicle::ShouldUseThirdPersonVehicleView()
{
	return true;
}

//-----------------------------------------------------------------------------
// Returns the unperterbed view position for a particular role
//-----------------------------------------------------------------------------
bool CBaseTFVehicle::GetRoleViewPosition( int nRole, Vector *pVehicleEyeOrigin, QAngle *pVehicleEyeAngles )
{
	// Generate the view position in world space.
	Vector vAbsOrigin;
	QAngle vAbsAngle;
	bool bUsingThirdPersonCamera = GetRoleAbsViewPosition( nRole, &vAbsOrigin, &vAbsAngle );

	
	// Make a matrix for it.
	matrix3x4_t absMatrix;
	AngleMatrix( vAbsAngle, absMatrix );
	MatrixSetColumn( vAbsOrigin, 3, absMatrix );


	// Transform the matrix into local space.
	matrix3x4_t worldToEntity, local;
	MatrixInvert( EntityToWorldTransform(), worldToEntity );
	ConcatTransforms( worldToEntity, absMatrix, local ); 


	// Suck out the origin and angles.
	pVehicleEyeOrigin->Init( local[0][3], local[1][3], local[2][3] );
	MatrixAngles( local, *pVehicleEyeAngles );

	return bUsingThirdPersonCamera;
}

bool CBaseTFVehicle::GetRoleAbsViewPosition( int nRole, Vector *pAbsVehicleEyeOrigin, QAngle *pAbsVehicleEyeAngles )
{
	int iAttachment = LookupAttachment( "ThirdPersonCameraOrigin" );
	if ( ShouldUseThirdPersonVehicleView() && vehicle_thirdperson.GetInt() && nRole == VEHICLE_DRIVER && iAttachment > 0 )
	{
		// Ok, we're using third person. Leave their angles intact but rotate theirt view around the
		// ThirdPersonCameraOrigin attachment.
		Vector vAttachOrigin;
		QAngle vAttachAngles;
		GetAttachment( iAttachment, vAttachOrigin, vAttachAngles );

		Vector vForward, vRight, vUp;
		AngleVectors( *pAbsVehicleEyeAngles, &vForward, &vRight, &vUp );

		*pAbsVehicleEyeOrigin = vAttachOrigin + vForward * vehicle_view_offset_forward.GetFloat() + 
			vRight * vehicle_view_offset_right.GetFloat() + 
			vUp * vehicle_view_offset_up.GetFloat();
	
		// Returning true tells the caller that we're using a third-person camera origin.
		return true;
	}
	else
	{
		// Use the vehicle_eyes_passengerX attachments.
		Assert( nRole >= 0 );
		char pAttachmentName[32];
		Q_snprintf( pAttachmentName, sizeof( pAttachmentName ), "vehicle_eyes_passenger%d", nRole );
		int eyeAttachmentIndex = LookupAttachment(pAttachmentName);
		
		QAngle vTempAngles;
		GetAttachment( eyeAttachmentIndex, *pAbsVehicleEyeOrigin, vTempAngles );
		
		if ( vehicle_attach_eye_angles.GetInt() )
			*pAbsVehicleEyeAngles = vTempAngles;

		return false;
	}
}


//-----------------------------------------------------------------------------
// Purpose: Modify the player view/camera while in a vehicle
//-----------------------------------------------------------------------------
void CBaseTFVehicle::GetVehicleViewPosition( int nRole, Vector *pAbsOrigin, QAngle *pAbsAngles, float *pFOV /*= NULL*/ )
{
	// UNDONE: Use attachment point on the vehicle, not hardcoded player eyes
	Assert( nRole >= 0 );
	CBasePlayer *pPlayer = GetPassenger( nRole );
	Assert( pPlayer );

	Vector vehicleEyeOrigin;
	QAngle vehicleEyeAngles = pPlayer->LocalEyeAngles();
	
	GetRoleAbsViewPosition( nRole, &vehicleEyeOrigin, &vehicleEyeAngles ); 

	*pAbsOrigin = vehicleEyeOrigin;
	*pAbsAngles = vehicleEyeAngles;

	/*
 	if ( bUsingThirdPersonCamera )
	{
		*pAbsOrigin = vehicleEyeOrigin;
		*pAbsAngles = vehicleEyeAngles;
	}
	else
	{
		matrix3x4_t vehicleEyePosToWorld;

		AngleMatrix( vehicleEyeAngles, vehicleEyePosToWorld );

		// Compute the relative rotation between the unperterbed eye attachment + the eye angles
		matrix3x4_t cameraToWorld;
		AngleMatrix( *pAbsAngles, cameraToWorld );

		matrix3x4_t worldToEyePos;
		MatrixInvert( vehicleEyePosToWorld, worldToEyePos );

		matrix3x4_t vehicleCameraToEyePos;
		ConcatTransforms( worldToEyePos, cameraToWorld, vehicleCameraToEyePos );

		// Now perterb the attachment point
		if( inv_demo.GetInt() )
		{
			vehicleEyeAngles.x = RemapAngleRange( PITCH_CURVE_ZERO * road_feel.GetFloat(), PITCH_CURVE_LINEAR, vehicleEyeAngles.x );
			vehicleEyeAngles.z = RemapAngleRange( ROLL_CURVE_ZERO * road_feel.GetFloat(), ROLL_CURVE_LINEAR, vehicleEyeAngles.z );
		} 
		else
		{
			vehicleEyeAngles.x = RemapAngleRange( PITCH_CURVE_ZERO, PITCH_CURVE_LINEAR, vehicleEyeAngles.x );
			vehicleEyeAngles.z = RemapAngleRange( ROLL_CURVE_ZERO, ROLL_CURVE_LINEAR, vehicleEyeAngles.z );
		}

		AngleMatrix( vehicleEyeAngles, vehicleEyeOrigin, vehicleEyePosToWorld );

		// Now treat the relative eye angles as being relative to this new, perterbed view position...
		matrix3x4_t newCameraToWorld;
		ConcatTransforms( vehicleEyePosToWorld, vehicleCameraToEyePos, newCameraToWorld );

		// output new view abs angles
		MatrixAngles( newCameraToWorld, *pAbsAngles );

		// UNDONE: *pOrigin would already be correct in single player if the HandleView() on the server ran after vphysics
		MatrixGetColumn( newCameraToWorld, 3, *pAbsOrigin );
	}
	*/
}


//-----------------------------------------------------------------------------
//
// Client-only code here
//
//-----------------------------------------------------------------------------

#if defined (CLIENT_DLL)

void CBaseTFVehicle::ClientThink()
{
	BaseClass::ClientThink();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CBaseTFVehicle::ShouldPredict( void )
{
	// Only predict vehicles driven by local players
	return GetDriverPlayer() ? GetDriverPlayer()->IsLocalPlayer() : false;
}

//-----------------------------------------------------------------------------
// Purpose: Get the angles that a player in the specified role should be using for visuals
//-----------------------------------------------------------------------------
QAngle CBaseTFVehicle::GetPassengerAngles( QAngle angCurrent, int nRole )
{
	// Just use your current angles
	return angCurrent;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBaseTFVehicle::DrawHudElements( void )
{
	// If we've got a driver gun, tell it to draw it's elements
	if ( m_hDriverGun )
	{
		m_hDriverGun->DrawHudElements();
	}

	DrawHudBoostData();
	SetupCrosshair();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFVehicle::DrawHudBoostData( void )
{
#define HUD_IMAGE_LEFT	XRES( 568 )

	// Boostable vehicle
	if ( IsBoostable() )
	{
		// Set our color
		CHudTexture *pVehicleBoostLabel = gHUD.GetIcon( "no2" );
		if ( pVehicleBoostLabel )
		{
			int nScreenY = ScreenHeight() - YRES( 12 );
			float nOneHudHeight = ( YRES(10) + pVehicleBoostLabel->Height() );
			nScreenY -= ( nOneHudHeight * 3 );
		
			pVehicleBoostLabel->DrawSelf( HUD_IMAGE_LEFT, nScreenY - pVehicleBoostLabel->Height(), gHUD.m_clrNormal );
			gHUD.DrawProgressBar( HUD_IMAGE_LEFT, nScreenY + YRES( 4 ), XRES( 70 ), YRES( 4 ), m_nBoostTimeLeft / 100.0f, gHUD.m_clrNormal, CHud::HUDPB_HORIZONTAL_INV );
		}
	}

#undef HUD_IMAGE_LEFT
}

//-----------------------------------------------------------------------------
// Purpose: Set a crosshair when in a vehicle and we don't have a proper 
//          crosshair sprite (ie. a commando laser rifle).
//-----------------------------------------------------------------------------
void CBaseTFVehicle::SetupCrosshair( void )
{
	if ( !m_pIconDefaultCrosshair )
	{
		// Init the default crosshair the first time.
		CHudTexture newTexture;
		Q_strncpy( newTexture.szTextureFile, "sprites/crosshairs", sizeof( newTexture.szTextureFile ) );

		newTexture.rc.left		= 0;
		newTexture.rc.top		= 48;
		newTexture.rc.right		= newTexture.rc.left + 24;
		newTexture.rc.bottom	= newTexture.rc.top + 24;
		m_pIconDefaultCrosshair = gHUD.AddUnsearchableHudIconToList( newTexture );
	}

	CHudCrosshair *crosshair = GET_HUDELEMENT( CHudCrosshair );
	if ( crosshair )
	{
		if ( !crosshair->HasCrosshair() && m_pIconDefaultCrosshair )
		{
			crosshair->SetCrosshair( m_pIconDefaultCrosshair, gHUD.m_clrNormal );
		}
	}
}

#endif