First version of the SOurce SDK 2013

1 files changed, 1449 insertions, 0 deletions

diff --git a/mp/src/game/server/fourwheelvehiclephysics.cpp b/mp/src/game/server/fourwheelvehiclephysics.cpp
new file mode 100644
index 00000000..5655102b
--- /dev/null
+++ b/mp/src/game/server/fourwheelvehiclephysics.cpp
@@ -0,0 +1,1449 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: A moving vehicle that is used as a battering ram

+//

+// $NoKeywords: $

+//=============================================================================//

+

+#include "cbase.h"

+#include "fourwheelvehiclephysics.h"

+#include "engine/IEngineSound.h"

+#include "soundenvelope.h"

+#include "in_buttons.h"

+#include "player.h"

+#include "IEffects.h"

+#include "physics_saverestore.h"

+#include "vehicle_base.h"

+#include "isaverestore.h"

+#include "movevars_shared.h"

+#include "te_effect_dispatch.h"

+#include "particle_parse.h"

+

+// memdbgon must be the last include file in a .cpp file!!!

+#include "tier0/memdbgon.h"

+

+#define STICK_EXTENTS	400.0f

+

+

+#define DUST_SPEED			5		// speed at which dust starts

+#define REAR_AXLE			1		// indexes of axlex

+#define	FRONT_AXLE			0

+#define MAX_GUAGE_SPEED		100.0	// 100 mph is max speed shown on guage

+

+#define BRAKE_MAX_VALUE				1.0f

+#define BRAKE_BACK_FORWARD_SCALAR	2.0f

+

+ConVar r_vehicleBrakeRate( "r_vehicleBrakeRate", "1.5", FCVAR_CHEAT );

+

+ConVar xbox_throttlebias("xbox_throttlebias", "100", FCVAR_ARCHIVE );

+ConVar xbox_throttlespoof("xbox_throttlespoof", "200", FCVAR_ARCHIVE );

+ConVar xbox_autothrottle("xbox_autothrottle", "1", FCVAR_ARCHIVE );

+ConVar xbox_steering_deadzone( "xbox_steering_deadzone", "0.0" );

+

+// remaps an angular variable to a 3 band function:

+// 0 <= t < start :		f(t) = 0

+// start <= t <= end :	f(t) = end * spline(( t-start) / (end-start) )  // s curve between clamped and linear

+// end < t :			f(t) = t

+float RemapAngleRange( float startInterval, float endInterval, float value )

+{

+	// Fixup the roll

+	value = AngleNormalize( value );

+	float absAngle = fabs(value);

+

+	// beneath cutoff?

+	if ( absAngle < startInterval )

+	{

+		value = 0;

+	}

+	// in spline range?

+	else if ( absAngle <= endInterval )

+	{

+		float newAngle = SimpleSpline( (absAngle - startInterval) / (endInterval-startInterval) ) * endInterval;

+		// grab the sign from the initial value

+		if ( value < 0 )

+		{

+			newAngle *= -1;

+		}

+		value = newAngle;

+	}

+	// else leave it alone, in linear range

+	

+	return value;

+}

+

+enum vehicle_pose_params

+{

+	VEH_FL_WHEEL_HEIGHT=0,

+	VEH_FR_WHEEL_HEIGHT,

+	VEH_RL_WHEEL_HEIGHT,

+	VEH_RR_WHEEL_HEIGHT,

+	VEH_FL_WHEEL_SPIN,

+	VEH_FR_WHEEL_SPIN,

+	VEH_RL_WHEEL_SPIN,

+	VEH_RR_WHEEL_SPIN,

+	VEH_STEER,

+	VEH_ACTION,

+	VEH_SPEEDO,

+

+};

+

+

+BEGIN_DATADESC_NO_BASE( CFourWheelVehiclePhysics )

+

+// These two are reset every time 

+//	DEFINE_FIELD( m_pOuter, FIELD_EHANDLE ),

+//											m_pOuterServerVehicle;

+

+	// Quiet down classcheck

+	// DEFINE_FIELD( m_controls, vehicle_controlparams_t ),

+

+	// Controls

+	DEFINE_FIELD( m_controls.throttle, FIELD_FLOAT ),

+	DEFINE_FIELD( m_controls.steering, FIELD_FLOAT ),

+	DEFINE_FIELD( m_controls.brake, FIELD_FLOAT ),

+	DEFINE_FIELD( m_controls.boost, FIELD_FLOAT ),

+	DEFINE_FIELD( m_controls.handbrake, FIELD_BOOLEAN ),

+	DEFINE_FIELD( m_controls.handbrakeLeft, FIELD_BOOLEAN ),

+	DEFINE_FIELD( m_controls.handbrakeRight, FIELD_BOOLEAN ),

+	DEFINE_FIELD( m_controls.brakepedal, FIELD_BOOLEAN ),

+	DEFINE_FIELD( m_controls.bHasBrakePedal, FIELD_BOOLEAN ),

+

+	// This has to be handled by the containing class owing to 'owner' issues

+//	DEFINE_PHYSPTR( m_pVehicle ),

+

+	DEFINE_FIELD( m_nSpeed, FIELD_INTEGER ),

+	DEFINE_FIELD( m_nLastSpeed, FIELD_INTEGER ),

+	DEFINE_FIELD( m_nRPM, FIELD_INTEGER ),

+	DEFINE_FIELD( m_fLastBoost, FIELD_FLOAT ),

+	DEFINE_FIELD( m_nBoostTimeLeft, FIELD_INTEGER ),

+	DEFINE_FIELD( m_nHasBoost, FIELD_INTEGER ),

+

+	DEFINE_FIELD( m_maxThrottle, FIELD_FLOAT ),

+	DEFINE_FIELD( m_flMaxRevThrottle, FIELD_FLOAT ),

+	DEFINE_FIELD( m_flMaxSpeed, FIELD_FLOAT ),

+	DEFINE_FIELD( m_actionSpeed, FIELD_FLOAT ),

+

+	// This has to be handled by the containing class owing to 'owner' issues

+//	DEFINE_PHYSPTR_ARRAY( m_pWheels ),

+

+	DEFINE_FIELD( m_wheelCount, FIELD_INTEGER ),

+

+	DEFINE_ARRAY( m_wheelPosition, FIELD_VECTOR, 4 ),

+	DEFINE_ARRAY( m_wheelRotation, FIELD_VECTOR, 4 ),

+	DEFINE_ARRAY( m_wheelBaseHeight, FIELD_FLOAT, 4 ),

+	DEFINE_ARRAY( m_wheelTotalHeight, FIELD_FLOAT, 4 ),

+	DEFINE_ARRAY( m_poseParameters, FIELD_INTEGER, 12 ),

+	DEFINE_FIELD( m_actionValue, FIELD_FLOAT ),

+	DEFINE_KEYFIELD( m_actionScale, FIELD_FLOAT, "actionScale" ),

+	DEFINE_FIELD( m_debugRadius, FIELD_FLOAT ),

+	DEFINE_FIELD( m_throttleRate, FIELD_FLOAT ),

+	DEFINE_FIELD( m_throttleStartTime, FIELD_FLOAT ),

+	DEFINE_FIELD( m_throttleActiveTime, FIELD_FLOAT ),

+	DEFINE_FIELD( m_turboTimer, FIELD_FLOAT ),

+

+	DEFINE_FIELD( m_flVehicleVolume, FIELD_FLOAT ),

+	DEFINE_FIELD( m_bIsOn, FIELD_BOOLEAN ),

+	DEFINE_FIELD( m_bLastThrottle, FIELD_BOOLEAN ),

+	DEFINE_FIELD( m_bLastBoost, FIELD_BOOLEAN ),

+	DEFINE_FIELD( m_bLastSkid, FIELD_BOOLEAN ),

+END_DATADESC()

+

+

+//-----------------------------------------------------------------------------

+// Constructor

+//-----------------------------------------------------------------------------

+CFourWheelVehiclePhysics::CFourWheelVehiclePhysics( CBaseAnimating *pOuter )

+{

+	m_flVehicleVolume = 0.5;

+	m_pOuter = NULL;

+	m_pOuterServerVehicle = NULL;

+	m_flMaxSpeed = 30;

+}

+

+//-----------------------------------------------------------------------------

+// Destructor

+//-----------------------------------------------------------------------------

+CFourWheelVehiclePhysics::~CFourWheelVehiclePhysics ()

+{

+	physenv->DestroyVehicleController( m_pVehicle );

+}

+

+//-----------------------------------------------------------------------------

+// A couple wrapper methods to perform common operations

+//-----------------------------------------------------------------------------

+inline int CFourWheelVehiclePhysics::LookupPoseParameter( const char *szName )

+{

+	return m_pOuter->LookupPoseParameter( szName );

+}

+

+inline float CFourWheelVehiclePhysics::GetPoseParameter( int iParameter )

+{

+	return m_pOuter->GetPoseParameter( iParameter );

+}

+

+inline float CFourWheelVehiclePhysics::SetPoseParameter( int iParameter, float flValue )

+{

+	Assert(IsFinite(flValue));

+	return m_pOuter->SetPoseParameter( iParameter, flValue );

+}

+

+inline bool CFourWheelVehiclePhysics::GetAttachment( const char *szName, Vector &origin, QAngle &angles )

+{

+	return m_pOuter->GetAttachment( szName, origin, angles );

+}

+

+//-----------------------------------------------------------------------------

+// Methods related to spawn

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::InitializePoseParameters()

+{

+	m_poseParameters[VEH_FL_WHEEL_HEIGHT] = LookupPoseParameter( "vehicle_wheel_fl_height" );

+	m_poseParameters[VEH_FR_WHEEL_HEIGHT] = LookupPoseParameter( "vehicle_wheel_fr_height" );

+	m_poseParameters[VEH_RL_WHEEL_HEIGHT] = LookupPoseParameter( "vehicle_wheel_rl_height" );

+	m_poseParameters[VEH_RR_WHEEL_HEIGHT] = LookupPoseParameter( "vehicle_wheel_rr_height" );

+	m_poseParameters[VEH_FL_WHEEL_SPIN] = LookupPoseParameter( "vehicle_wheel_fl_spin" );

+	m_poseParameters[VEH_FR_WHEEL_SPIN] = LookupPoseParameter( "vehicle_wheel_fr_spin" );

+	m_poseParameters[VEH_RL_WHEEL_SPIN] = LookupPoseParameter( "vehicle_wheel_rl_spin" );

+	m_poseParameters[VEH_RR_WHEEL_SPIN] = LookupPoseParameter( "vehicle_wheel_rr_spin" );

+	m_poseParameters[VEH_STEER] = LookupPoseParameter( "vehicle_steer" );

+	m_poseParameters[VEH_ACTION] = LookupPoseParameter( "vehicle_action" );

+	m_poseParameters[VEH_SPEEDO] = LookupPoseParameter( "vehicle_guage" );

+

+

+	// move the wheels to a neutral position

+	SetPoseParameter( m_poseParameters[VEH_SPEEDO], 0 );

+	SetPoseParameter( m_poseParameters[VEH_STEER], 0 );

+	SetPoseParameter( m_poseParameters[VEH_FL_WHEEL_HEIGHT], 0 );

+	SetPoseParameter( m_poseParameters[VEH_FR_WHEEL_HEIGHT], 0 );

+	SetPoseParameter( m_poseParameters[VEH_RL_WHEEL_HEIGHT], 0 );

+	SetPoseParameter( m_poseParameters[VEH_RR_WHEEL_HEIGHT], 0 );

+	m_pOuter->InvalidateBoneCache();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Parses the vehicle's script

+//-----------------------------------------------------------------------------

+bool CFourWheelVehiclePhysics::ParseVehicleScript( const char *pScriptName, solid_t &solid, vehicleparams_t &vehicle)

+{

+	// Physics keeps a cache of these to share among spawns of vehicles or flush for debugging

+	PhysFindOrAddVehicleScript( pScriptName, &vehicle, NULL );

+

+	m_debugRadius = vehicle.axles[0].wheels.radius;

+	CalcWheelData( vehicle );

+

+	PhysModelParseSolid( solid, m_pOuter, m_pOuter->GetModelIndex() );

+	

+	// Allow the script to shift the center of mass

+	if ( vehicle.body.massCenterOverride != vec3_origin )

+	{

+		solid.massCenterOverride = vehicle.body.massCenterOverride;

+		solid.params.massCenterOverride = &solid.massCenterOverride;

+	}

+

+	// allow script to change the mass of the vehicle body

+	if ( vehicle.body.massOverride > 0 )

+	{

+		solid.params.mass = vehicle.body.massOverride;

+	}

+

+	return true;

+}

+

+void CFourWheelVehiclePhysics::CalcWheelData( vehicleparams_t &vehicle )

+{

+	const char *pWheelAttachments[4] = { "wheel_fl", "wheel_fr", "wheel_rl", "wheel_rr" };

+	Vector left, right;

+	QAngle dummy;

+	SetPoseParameter( m_poseParameters[VEH_FL_WHEEL_HEIGHT], 0 );

+	SetPoseParameter( m_poseParameters[VEH_FR_WHEEL_HEIGHT], 0 );

+	SetPoseParameter( m_poseParameters[VEH_RL_WHEEL_HEIGHT], 0 );

+	SetPoseParameter( m_poseParameters[VEH_RR_WHEEL_HEIGHT], 0 );

+	m_pOuter->InvalidateBoneCache();

+	if ( GetAttachment( "wheel_fl", left, dummy ) && GetAttachment( "wheel_fr", right, dummy ) )

+	{

+		VectorITransform( left, m_pOuter->EntityToWorldTransform(), left );

+		VectorITransform( right, m_pOuter->EntityToWorldTransform(), right );

+		Vector center = (left + right) * 0.5;

+		vehicle.axles[0].offset = center;

+		vehicle.axles[0].wheelOffset = right - center;

+		// Cache the base height of the wheels in body space

+		m_wheelBaseHeight[0] = left.z;

+		m_wheelBaseHeight[1] = right.z;

+	}

+

+	if ( GetAttachment( "wheel_rl", left, dummy ) && GetAttachment( "wheel_rr", right, dummy ) )

+	{

+		VectorITransform( left, m_pOuter->EntityToWorldTransform(), left );

+		VectorITransform( right, m_pOuter->EntityToWorldTransform(), right );

+		Vector center = (left + right) * 0.5;

+		vehicle.axles[1].offset = center;

+		vehicle.axles[1].wheelOffset = right - center;

+		// Cache the base height of the wheels in body space

+		m_wheelBaseHeight[2] = left.z;

+		m_wheelBaseHeight[3] = right.z;

+	}

+	SetPoseParameter( m_poseParameters[VEH_FL_WHEEL_HEIGHT], 1 );

+	SetPoseParameter( m_poseParameters[VEH_FR_WHEEL_HEIGHT], 1 );

+	SetPoseParameter( m_poseParameters[VEH_RL_WHEEL_HEIGHT], 1 );

+	SetPoseParameter( m_poseParameters[VEH_RR_WHEEL_HEIGHT], 1 );

+	m_pOuter->InvalidateBoneCache();

+	if ( GetAttachment( "wheel_fl", left, dummy ) && GetAttachment( "wheel_fr", right, dummy ) )

+	{

+		VectorITransform( left, m_pOuter->EntityToWorldTransform(), left );

+		VectorITransform( right, m_pOuter->EntityToWorldTransform(), right );

+		// Cache the height range of the wheels in body space

+		m_wheelTotalHeight[0] = m_wheelBaseHeight[0] - left.z;

+		m_wheelTotalHeight[1] = m_wheelBaseHeight[1] - right.z;

+		vehicle.axles[0].wheels.springAdditionalLength = m_wheelTotalHeight[0];

+	}

+

+	if ( GetAttachment( "wheel_rl", left, dummy ) && GetAttachment( "wheel_rr", right, dummy ) )

+	{

+		VectorITransform( left, m_pOuter->EntityToWorldTransform(), left );

+		VectorITransform( right, m_pOuter->EntityToWorldTransform(), right );

+		// Cache the height range of the wheels in body space

+		m_wheelTotalHeight[2] = m_wheelBaseHeight[0] - left.z;

+		m_wheelTotalHeight[3] = m_wheelBaseHeight[1] - right.z;

+		vehicle.axles[1].wheels.springAdditionalLength = m_wheelTotalHeight[2];

+	}

+	for ( int i = 0; i < 4; i++ )

+	{

+		if ( m_wheelTotalHeight[i] == 0.0f )

+		{

+			DevWarning("Vehicle %s has invalid wheel attachment for %s - no movement\n", STRING(m_pOuter->GetModelName()), pWheelAttachments[i]);

+			m_wheelTotalHeight[i] = 1.0f;

+		}

+	}

+

+	SetPoseParameter( m_poseParameters[VEH_FL_WHEEL_HEIGHT], 0 );

+	SetPoseParameter( m_poseParameters[VEH_FR_WHEEL_HEIGHT], 0 );

+	SetPoseParameter( m_poseParameters[VEH_RL_WHEEL_HEIGHT], 0 );

+	SetPoseParameter( m_poseParameters[VEH_RR_WHEEL_HEIGHT], 0 );

+	m_pOuter->InvalidateBoneCache();

+

+	// Get raytrace offsets if they exist.

+	if ( GetAttachment( "raytrace_fl", left, dummy ) && GetAttachment( "raytrace_fr", right, dummy ) )

+	{

+		VectorITransform( left, m_pOuter->EntityToWorldTransform(), left );

+		VectorITransform( right, m_pOuter->EntityToWorldTransform(), right );

+		Vector center = ( left + right ) * 0.5;

+		vehicle.axles[0].raytraceCenterOffset = center;

+		vehicle.axles[0].raytraceOffset = right - center;

+	}

+

+	if ( GetAttachment( "raytrace_rl", left, dummy ) && GetAttachment( "raytrace_rr", right, dummy ) )

+	{

+		VectorITransform( left, m_pOuter->EntityToWorldTransform(), left );

+		VectorITransform( right, m_pOuter->EntityToWorldTransform(), right );

+		Vector center = ( left + right ) * 0.5;

+		vehicle.axles[1].raytraceCenterOffset = center;

+		vehicle.axles[1].raytraceOffset = right - center;

+	}

+}

+

+

+//-----------------------------------------------------------------------------

+// Spawns the vehicle

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::Spawn( )

+{

+	Assert( m_pOuter );

+

+	m_actionValue = 0;

+	m_actionSpeed = 0;

+

+	m_bIsOn = false;

+	m_controls.handbrake = false;

+	m_controls.handbrakeLeft = false;

+	m_controls.handbrakeRight = false;

+	m_controls.bHasBrakePedal = true;

+	m_controls.bAnalogSteering = false;

+	

+	SetMaxThrottle( 1.0 );

+	SetMaxReverseThrottle( -1.0f );

+

+	InitializePoseParameters();

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Initializes the vehicle physics

+//			Called by our outer vehicle in it's Spawn()

+//-----------------------------------------------------------------------------

+bool CFourWheelVehiclePhysics::Initialize( const char *pVehicleScript, unsigned int nVehicleType )

+{

+	// Ok, turn on the simulation now

+	// FIXME: Disabling collisions here is necessary because we seem to be

+	// getting a one-frame collision between the old + new collision models

+	if ( m_pOuter->VPhysicsGetObject() )

+	{

+		m_pOuter->VPhysicsGetObject()->EnableCollisions(false);

+	}

+	m_pOuter->VPhysicsDestroyObject();

+

+	// Create the vphysics model + teleport it into position

+	solid_t solid;

+	vehicleparams_t vehicle;

+	if (!ParseVehicleScript( pVehicleScript, solid, vehicle ))

+	{

+		UTIL_Remove(m_pOuter);

+		return false;

+	}

+

+	// NOTE: this needs to be greater than your max framerate (so zero is still instant)

+	m_throttleRate = 10000.0;

+	if ( vehicle.engine.throttleTime > 0 )

+	{

+		m_throttleRate = 1.0 / vehicle.engine.throttleTime;

+	}

+

+	m_flMaxSpeed = vehicle.engine.maxSpeed;

+

+	IPhysicsObject *pBody = m_pOuter->VPhysicsInitNormal( SOLID_VPHYSICS, 0, false, &solid );

+	PhysSetGameFlags( pBody, FVPHYSICS_NO_SELF_COLLISIONS | FVPHYSICS_MULTIOBJECT_ENTITY );

+	m_pVehicle = physenv->CreateVehicleController( pBody, vehicle, nVehicleType, physgametrace );

+	m_wheelCount = m_pVehicle->GetWheelCount();

+	for ( int i = 0; i < m_wheelCount; i++ )

+	{

+		m_pWheels[i] = m_pVehicle->GetWheel( i );

+	}

+	return true;

+}

+

+

+//-----------------------------------------------------------------------------

+// Various steering parameters

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::SetThrottle( float flThrottle )

+{

+	m_controls.throttle = flThrottle;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::SetMaxThrottle( float flMaxThrottle )

+{

+	m_maxThrottle = flMaxThrottle;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::SetMaxReverseThrottle( float flMaxThrottle )

+{

+	m_flMaxRevThrottle = flMaxThrottle;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::SetSteering( float flSteering, float flSteeringRate )

+{

+	if ( !flSteeringRate )

+	{

+		m_controls.steering = flSteering;

+	}

+	else

+	{

+		m_controls.steering = Approach( flSteering, m_controls.steering, flSteeringRate );

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::SetSteeringDegrees( float flDegrees )

+{

+	vehicleparams_t &vehicleParams = m_pVehicle->GetVehicleParamsForChange();

+	vehicleParams.steering.degreesSlow = flDegrees;

+	vehicleParams.steering.degreesFast = flDegrees;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::SetAction( float flAction )

+{

+	m_actionSpeed = flAction;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::TurnOn( )

+{

+	if ( IsEngineDisabled() )

+		return;

+

+	if ( !m_bIsOn )

+	{

+		m_pOuterServerVehicle->SoundStart();

+		m_bIsOn = true;

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::TurnOff( )

+{

+	ResetControls();

+

+	if ( m_bIsOn )

+	{

+		m_pOuterServerVehicle->SoundShutdown();

+		m_bIsOn = false;

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::SetBoost( float flBoost )

+{

+	if ( !IsEngineDisabled() )

+	{

+		m_controls.boost = flBoost;

+	}

+}

+

+//------------------------------------------------------

+// UpdateBooster - Calls UpdateBooster() in the vphysics

+// code to allow the timer to be updated

+//

+// Returns: false if timer has expired (can use again and

+//			can stop think

+//			true if timer still running

+//------------------------------------------------------

+bool CFourWheelVehiclePhysics::UpdateBooster( void )

+{

+	float retval = m_pVehicle->UpdateBooster(gpGlobals->frametime );

+	return ( retval > 0 );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::SetHasBrakePedal( bool bHasBrakePedal )

+{

+	m_controls.bHasBrakePedal = bHasBrakePedal;

+}

+

+//-----------------------------------------------------------------------------

+// Teleport

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::Teleport( matrix3x4_t& relativeTransform )

+{

+	// We basically just have to make sure the wheels are in the right place

+	// after teleportation occurs

+

+	for ( int i = 0; i < m_wheelCount; i++ )

+	{

+		matrix3x4_t matrix, newMatrix;

+		m_pWheels[i]->GetPositionMatrix( &matrix );

+		ConcatTransforms( relativeTransform, matrix, newMatrix );

+		m_pWheels[i]->SetPositionMatrix( newMatrix, true );

+	}

+	

+	// Wake the vehicle back up after a teleport

+	if ( m_pOuterServerVehicle && m_pOuterServerVehicle->GetFourWheelVehicle() )

+	{

+		IPhysicsObject *pObj = m_pOuterServerVehicle->GetFourWheelVehicle()->VPhysicsGetObject();

+		if ( pObj )

+		{

+			pObj->Wake();

+		}

+	}

+}

+

+#if 1

+// For the #if 0 debug code below!

+#define HL2IVP_FACTOR	METERS_PER_INCH

+#define IVP2HL(x)		(float)(x * (1.0f/HL2IVP_FACTOR))

+#define HL2IVP(x)		(double)(x * HL2IVP_FACTOR)		

+#endif

+

+//-----------------------------------------------------------------------------

+// Debugging methods

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::DrawDebugGeometryOverlays()

+{

+	for ( int iWheel = 0; iWheel < m_wheelCount; iWheel++ )

+	{

+		IPhysicsObject *pWheel = m_pVehicle->GetWheel( iWheel );

+		float radius = pWheel->GetSphereRadius();

+		

+		Vector vecPos;

+		QAngle vecRot;

+		pWheel->GetPosition( &vecPos, &vecRot );

+		// draw the physics object position/orientation

+		NDebugOverlay::Sphere( vecPos, vecRot, radius, 0, 255, 0, 0, false, 0 );

+		// draw the animation position/orientation

+		NDebugOverlay::Sphere(m_wheelPosition[iWheel], m_wheelRotation[iWheel], radius, 255, 255, 0, 0, false, 0);

+	}

+

+	// Render vehicle data.

+	IPhysicsObject *pBody = m_pOuter->VPhysicsGetObject();

+	if ( pBody )

+	{

+		const vehicleparams_t vehicleParams = m_pVehicle->GetVehicleParams();

+

+		// Draw a red cube as the "center" of the vehicle.

+		Vector vecBodyPosition; 

+		QAngle angBodyDirection;

+		pBody->GetPosition( &vecBodyPosition, &angBodyDirection );

+		NDebugOverlay::BoxAngles( vecBodyPosition, Vector( -5, -5, -5 ), Vector( 5, 5, 5 ), angBodyDirection, 255, 0, 0, 0 ,0 );

+

+		matrix3x4_t matrix;

+		AngleMatrix( angBodyDirection, vecBodyPosition, matrix );

+

+		// Draw green cubes at axle centers.

+		Vector vecAxlePositions[2], vecAxlePositionsHL[2];

+		vecAxlePositions[0] = vehicleParams.axles[0].offset;

+		vecAxlePositions[1] = vehicleParams.axles[1].offset;

+

+		VectorTransform( vecAxlePositions[0], matrix, vecAxlePositionsHL[0] );		

+		VectorTransform( vecAxlePositions[1], matrix, vecAxlePositionsHL[1] );

+

+		NDebugOverlay::BoxAngles( vecAxlePositionsHL[0], Vector( -3, -3, -3 ), Vector( 3, 3, 3 ), angBodyDirection, 0, 255, 0, 0 ,0 );

+		NDebugOverlay::BoxAngles( vecAxlePositionsHL[1], Vector( -3, -3, -3 ), Vector( 3, 3, 3 ), angBodyDirection, 0, 255, 0, 0 ,0 );

+

+		// Draw wheel raycasts in yellow

+		vehicle_debugcarsystem_t debugCarSystem;

+		m_pVehicle->GetCarSystemDebugData( debugCarSystem );

+		for ( int iWheel = 0; iWheel < 4; ++iWheel )

+		{

+			Vector vecStart, vecEnd, vecImpact;

+

+			// Hack for now.

+			float tmpY = IVP2HL( debugCarSystem.vecWheelRaycasts[iWheel][0].z );

+			vecStart.z = -IVP2HL( debugCarSystem.vecWheelRaycasts[iWheel][0].y );

+			vecStart.y = tmpY;

+			vecStart.x = IVP2HL( debugCarSystem.vecWheelRaycasts[iWheel][0].x );

+

+			tmpY = IVP2HL( debugCarSystem.vecWheelRaycasts[iWheel][1].z );

+			vecEnd.z = -IVP2HL( debugCarSystem.vecWheelRaycasts[iWheel][1].y );

+			vecEnd.y = tmpY;

+			vecEnd.x = IVP2HL( debugCarSystem.vecWheelRaycasts[iWheel][1].x );

+

+			tmpY = IVP2HL( debugCarSystem.vecWheelRaycastImpacts[iWheel].z );

+			vecImpact.z = -IVP2HL( debugCarSystem.vecWheelRaycastImpacts[iWheel].y );

+			vecImpact.y = tmpY;

+			vecImpact.x = IVP2HL( debugCarSystem.vecWheelRaycastImpacts[iWheel].x );

+

+			NDebugOverlay::BoxAngles( vecStart, Vector( -1 , -1, -1 ), Vector( 1, 1, 1 ), angBodyDirection, 0, 255, 0, 0, 0  );

+			NDebugOverlay::Line( vecStart, vecEnd, 255, 255, 0, true, 0 );

+			NDebugOverlay::BoxAngles( vecEnd, Vector( -1, -1, -1 ), Vector( 1, 1, 1 ), angBodyDirection, 255, 0, 0, 0, 0 );

+

+			NDebugOverlay::BoxAngles( vecImpact, Vector( -0.5f , -0.5f, -0.5f ), Vector( 0.5f, 0.5f, 0.5f ), angBodyDirection, 0, 0, 255, 0, 0  );

+			DebugDrawContactPoints( m_pVehicle->GetWheel(iWheel) );

+		}

+	}

+}

+

+int CFourWheelVehiclePhysics::DrawDebugTextOverlays( int nOffset )

+{

+	const vehicle_operatingparams_t &params = m_pVehicle->GetOperatingParams();

+	char tempstr[512];

+	Q_snprintf( tempstr,sizeof(tempstr), "Speed %.1f  T/S/B (%.0f/%.0f/%.1f)", params.speed, m_controls.throttle, m_controls.steering, m_controls.brake );

+	m_pOuter->EntityText( nOffset, tempstr, 0 );

+	nOffset++;

+	Msg( "%s", tempstr );

+

+	Q_snprintf( tempstr,sizeof(tempstr), "Gear: %d, RPM %4d", params.gear, (int)params.engineRPM );

+	m_pOuter->EntityText( nOffset, tempstr, 0 );

+	nOffset++;

+	Msg( " %s\n", tempstr );

+

+	return nOffset;

+}

+

+//----------------------------------------------------

+// Place dust at vector passed in

+//----------------------------------------------------

+void CFourWheelVehiclePhysics::PlaceWheelDust( int wheelIndex, bool ignoreSpeed )

+{

+	// New vehicles handle this deeper into the base class

+	if ( hl2_episodic.GetBool() )

+		return;

+

+	// Old dust

+	Vector	vecPos, vecVel;

+	m_pVehicle->GetWheelContactPoint( wheelIndex, &vecPos, NULL );

+

+	vecVel.Random( -1.0f, 1.0f );

+	vecVel.z = random->RandomFloat( 0.3f, 1.0f );

+

+	VectorNormalize( vecVel );

+

+	// Higher speeds make larger dust clouds

+	float flSize;

+	if ( ignoreSpeed )

+	{

+		flSize = 1.0f;

+	}

+	else

+	{

+		flSize = RemapValClamped( m_nSpeed, DUST_SPEED, m_flMaxSpeed, 0.0f, 1.0f );

+	}

+

+	if ( flSize )

+	{

+		CEffectData	data;

+

+		data.m_vOrigin = vecPos;

+		data.m_vNormal = vecVel;

+		data.m_flScale = flSize;

+

+		DispatchEffect( "WheelDust", data );

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Frame-based updating 

+//-----------------------------------------------------------------------------

+bool CFourWheelVehiclePhysics::Think()

+{

+	if (!m_pVehicle)

+		return false;

+

+	// Update sound + physics state

+	const vehicle_operatingparams_t &carState = m_pVehicle->GetOperatingParams();

+	const vehicleparams_t &vehicleData = m_pVehicle->GetVehicleParams();

+

+	// Set save data.

+	float carSpeed = fabs( INS2MPH( carState.speed ) );

+	m_nLastSpeed = m_nSpeed;

+	m_nSpeed = ( int )carSpeed;

+	m_nRPM = ( int )carState.engineRPM;

+	m_nHasBoost = vehicleData.engine.boostDelay;	// if we have any boost delay, vehicle has boost ability

+

+	m_pVehicle->Update( gpGlobals->frametime, m_controls);

+

+	// boost sounds

+	if( IsBoosting() && !m_bLastBoost )

+	{

+		m_bLastBoost = true;

+		m_turboTimer = gpGlobals->curtime + 2.75f;		// min duration for turbo sound

+	}

+	else if( !IsBoosting() && m_bLastBoost )

+	{

+		if ( gpGlobals->curtime >= m_turboTimer )

+		{

+			m_bLastBoost = false;

+		}

+	}

+

+	m_fLastBoost = carState.boostDelay;

+	m_nBoostTimeLeft =  carState.boostTimeLeft;

+

+	// UNDONE: Use skid info from the physics system?

+	// Only check wheels if we're not being carried by a dropship

+	if ( m_pOuter->VPhysicsGetObject() && !m_pOuter->VPhysicsGetObject()->GetShadowController() )

+	{

+		const float skidFactor = 0.15f;

+		const float minSpeed = DEFAULT_SKID_THRESHOLD / skidFactor;

+		// we have to slide at least 15% of our speed at higher speeds to make the skid sound (otherwise it can be too frequent)

+		float skidThreshold = m_bLastSkid ? DEFAULT_SKID_THRESHOLD : (carState.speed * 0.15f);

+		if ( skidThreshold < DEFAULT_SKID_THRESHOLD )

+		{

+			// otherwise, ramp in the skid threshold to avoid the sound at really low speeds unless really skidding

+			skidThreshold = RemapValClamped( fabs(carState.speed), 0, minSpeed, DEFAULT_SKID_THRESHOLD*8, DEFAULT_SKID_THRESHOLD );

+		}

+		// check for skidding, if we're skidding, need to play the sound

+		if ( carState.skidSpeed > skidThreshold && m_bIsOn )

+		{

+			if ( !m_bLastSkid )	// only play sound once

+			{

+				m_bLastSkid = true;

+				CPASAttenuationFilter filter( m_pOuter );

+				m_pOuterServerVehicle->PlaySound( VS_SKID_FRICTION_NORMAL );

+			}

+

+			// kick up dust from the wheels while skidding

+			for ( int i = 0; i < 4; i++ )

+			{

+				PlaceWheelDust( i, true );

+			}

+		}

+		else if ( m_bLastSkid == true )

+		{

+			m_bLastSkid = false;

+			m_pOuterServerVehicle->StopSound( VS_SKID_FRICTION_NORMAL );

+		}

+

+		// toss dust up from the wheels of the vehicle if we're moving fast enough

+		if ( m_nSpeed >= DUST_SPEED && vehicleData.steering.dustCloud && m_bIsOn )

+		{

+			for ( int i = 0; i < 4; i++ )

+			{

+				PlaceWheelDust( i );

+			}

+		}

+	}

+

+	// Make the steering wheel match the input, with a little dampening.

+	#define STEER_DAMPING	0.8

+	float flSteer = GetPoseParameter( m_poseParameters[VEH_STEER] );

+	float flPhysicsSteer = carState.steeringAngle / vehicleData.steering.degreesSlow;

+	SetPoseParameter( m_poseParameters[VEH_STEER], (STEER_DAMPING * flSteer) + ((1 - STEER_DAMPING) * flPhysicsSteer) );

+

+	m_actionValue += m_actionSpeed * m_actionScale * gpGlobals->frametime;

+	SetPoseParameter( m_poseParameters[VEH_ACTION], m_actionValue );

+

+	// setup speedometer

+	if ( m_bIsOn == true )

+	{

+		float displaySpeed = m_nSpeed / MAX_GUAGE_SPEED;

+		SetPoseParameter( m_poseParameters[VEH_SPEEDO], displaySpeed );

+	}

+

+	return m_bIsOn;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+bool CFourWheelVehiclePhysics::VPhysicsUpdate( IPhysicsObject *pPhysics )

+{

+	// must be a wheel

+	if ( pPhysics == m_pOuter->VPhysicsGetObject() )

+		return true;

+

+	// This is here so we can make the pose parameters of the wheels

+	// reflect their current physics state

+	for ( int i = 0; i < m_wheelCount; i++ )

+	{

+		if ( pPhysics == m_pWheels[i] )

+		{

+			Vector tmp;

+			pPhysics->GetPosition( &m_wheelPosition[i], &m_wheelRotation[i] );

+

+			// transform the wheel into body space

+			VectorITransform( m_wheelPosition[i], m_pOuter->EntityToWorldTransform(), tmp );

+			SetPoseParameter( m_poseParameters[VEH_FL_WHEEL_HEIGHT + i], (m_wheelBaseHeight[i] - tmp.z) / m_wheelTotalHeight[i] );

+			SetPoseParameter( m_poseParameters[VEH_FL_WHEEL_SPIN + i], -m_wheelRotation[i].z );

+			return false;

+		}

+	}

+

+	return false;

+}

+

+

+//-----------------------------------------------------------------------------

+// Shared code to compute the vehicle view position

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::GetVehicleViewPosition( const char *pViewAttachment, float flPitchFactor, Vector *pAbsOrigin, QAngle *pAbsAngles )

+{

+	matrix3x4_t vehicleEyePosToWorld;

+	Vector vehicleEyeOrigin;

+	QAngle vehicleEyeAngles;

+	GetAttachment( pViewAttachment, vehicleEyeOrigin, vehicleEyeAngles );

+	AngleMatrix( vehicleEyeAngles, vehicleEyePosToWorld );

+

+#ifdef HL2_DLL

+	// View dampening.

+	if ( r_VehicleViewDampen.GetInt() )

+	{

+		m_pOuterServerVehicle->GetFourWheelVehicle()->DampenEyePosition( vehicleEyeOrigin, vehicleEyeAngles );

+	}

+#endif

+

+	// 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

+	vehicleEyeAngles.x = RemapAngleRange( PITCH_CURVE_ZERO * flPitchFactor, PITCH_CURVE_LINEAR, vehicleEyeAngles.x );

+	vehicleEyeAngles.z = RemapAngleRange( ROLL_CURVE_ZERO * flPitchFactor, 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 );

+}

+

+

+//-----------------------------------------------------------------------------

+// Control initialization

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::ResetControls()

+{

+	m_controls.handbrake = true;

+	m_controls.handbrakeLeft = false;

+	m_controls.handbrakeRight = false;

+	m_controls.boost = 0;

+	m_controls.brake = 0.0f;

+	m_controls.throttle = 0;

+	m_controls.steering = 0;

+}

+

+void CFourWheelVehiclePhysics::ReleaseHandbrake()

+{

+	m_controls.handbrake = false;

+}

+

+void CFourWheelVehiclePhysics::SetHandbrake( bool bBrake )

+{

+	m_controls.handbrake = bBrake;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::EnableMotion( void )

+{

+	for( int iWheel = 0; iWheel < m_wheelCount; ++iWheel )

+	{

+		m_pWheels[iWheel]->EnableMotion( true );

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::DisableMotion( void )

+{

+	Vector vecZero( 0.0f, 0.0f, 0.0f );

+	AngularImpulse angNone( 0.0f, 0.0f, 0.0f );

+

+	for( int iWheel = 0; iWheel < m_wheelCount; ++iWheel )

+	{

+		m_pWheels[iWheel]->SetVelocity( &vecZero, &angNone );

+		m_pWheels[iWheel]->EnableMotion( false );

+	}

+}

+

+float CFourWheelVehiclePhysics::GetHLSpeed() const

+{

+	const vehicle_operatingparams_t &carState = m_pVehicle->GetOperatingParams();

+	return carState.speed;

+}

+

+float CFourWheelVehiclePhysics::GetSteering() const

+{

+	return m_controls.steering;

+}

+

+float CFourWheelVehiclePhysics::GetSteeringDegrees() const

+{

+	const vehicleparams_t vehicleParams = m_pVehicle->GetVehicleParams();

+	return vehicleParams.steering.degreesSlow;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::SteeringRest( float carSpeed, const vehicleparams_t &vehicleData )

+{

+	float flSteeringRate = RemapValClamped( carSpeed, vehicleData.steering.speedSlow, vehicleData.steering.speedFast, 

+		vehicleData.steering.steeringRestRateSlow, vehicleData.steering.steeringRestRateFast );

+	m_controls.steering = Approach(0, m_controls.steering, flSteeringRate * gpGlobals->frametime );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::SteeringTurn( float carSpeed, const vehicleparams_t &vehicleData, bool bTurnLeft, bool bBrake, bool bThrottle )

+{

+	float flTargetSteering = bTurnLeft ? -1.0f : 1.0f;

+	// steering speeds are stored in MPH

+	float flSteeringRestRate = RemapValClamped( carSpeed, vehicleData.steering.speedSlow, vehicleData.steering.speedFast, 

+		vehicleData.steering.steeringRestRateSlow, vehicleData.steering.steeringRestRateFast );

+

+	float carSpeedIns = MPH2INS(carSpeed);

+	// engine speeds are stored in in/s

+	if ( carSpeedIns > vehicleData.engine.maxSpeed )

+	{

+		flSteeringRestRate = RemapValClamped( carSpeedIns, vehicleData.engine.maxSpeed, vehicleData.engine.boostMaxSpeed, vehicleData.steering.steeringRestRateFast, vehicleData.steering.steeringRestRateFast*0.5f );

+	}

+

+	const vehicle_operatingparams_t &carState = m_pVehicle->GetOperatingParams();

+	bool bIsBoosting = carState.isTorqueBoosting;

+

+	// if you're recovering from a boost and still going faster than max, use the boost steering values

+	bool bIsBoostRecover = (carState.boostTimeLeft == 100 || carState.boostTimeLeft == 0) ? false : true;

+	float boostMinSpeed = vehicleData.engine.maxSpeed * vehicleData.engine.autobrakeSpeedGain;

+	if ( !bIsBoosting && bIsBoostRecover && carSpeedIns > boostMinSpeed )

+	{

+		bIsBoosting = true;

+	}

+

+	if ( bIsBoosting )

+	{

+		flSteeringRestRate *= vehicleData.steering.boostSteeringRestRateFactor;

+	}

+	else if ( bThrottle )

+	{

+		flSteeringRestRate *= vehicleData.steering.throttleSteeringRestRateFactor;

+	}

+

+	float flSteeringRate = RemapValClamped( carSpeed, vehicleData.steering.speedSlow, vehicleData.steering.speedFast, 

+		vehicleData.steering.steeringRateSlow, vehicleData.steering.steeringRateFast );

+

+	if ( fabs(flSteeringRate) < flSteeringRestRate )

+	{

+		if ( Sign(flTargetSteering) != Sign(m_controls.steering) )

+		{

+			flSteeringRate = flSteeringRestRate;

+		}

+	}

+	if ( bIsBoosting )

+	{

+		flSteeringRate *= vehicleData.steering.boostSteeringRateFactor;

+	}

+	else if ( bBrake )

+	{

+		flSteeringRate *= vehicleData.steering.brakeSteeringRateFactor;

+	}

+	flSteeringRate *= gpGlobals->frametime;

+	m_controls.steering = Approach( flTargetSteering, m_controls.steering, flSteeringRate );

+	m_controls.bAnalogSteering = false;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::SteeringTurnAnalog( float carSpeed, const vehicleparams_t &vehicleData, float sidemove )

+{

+

+	// OLD Code

+#if 0

+	float flSteeringRate = STEERING_BASE_RATE;

+

+	float factor = clamp( fabs( sidemove ) / STICK_EXTENTS, 0.0f, 1.0f );

+

+	factor *= 30;

+	flSteeringRate *= log( factor );

+	flSteeringRate *= gpGlobals->frametime;

+

+	SetSteering( sidemove < 0.0f ? -1 : 1, flSteeringRate );

+#else

+	// This is tested with gamepads with analog sticks.  It gives full analog control allowing the player to hold shallow turns.

+	float steering = ( sidemove / STICK_EXTENTS );

+

+	float flSign = ( steering > 0 ) ? 1.0f : -1.0f;

+	float flSteerAdj = RemapValClamped( fabs( steering ), xbox_steering_deadzone.GetFloat(), 1.0f, 0.0f, 1.0f );

+

+	float flSteeringRate = RemapValClamped( carSpeed, vehicleData.steering.speedSlow, vehicleData.steering.speedFast, 

+		vehicleData.steering.steeringRateSlow, vehicleData.steering.steeringRateFast );

+	flSteeringRate *= vehicleData.steering.throttleSteeringRestRateFactor;

+

+	m_controls.bAnalogSteering = true;

+	SetSteering( flSign * flSteerAdj, flSteeringRate * gpGlobals->frametime );

+#endif

+}

+

+//-----------------------------------------------------------------------------

+// Methods related to actually driving the vehicle

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::UpdateDriverControls( CUserCmd *cmd, float flFrameTime )

+{

+	const float SPEED_THROTTLE_AS_BRAKE = 2.0f;

+	int nButtons = cmd->buttons;

+

+	// Get vehicle data.

+	const vehicle_operatingparams_t &carState = m_pVehicle->GetOperatingParams();

+	const vehicleparams_t &vehicleData = m_pVehicle->GetVehicleParams();

+

+	// Get current speed in miles/hour.

+	float flCarSign = 0.0f;

+	if (carState.speed >= SPEED_THROTTLE_AS_BRAKE) 

+	{

+		flCarSign = 1.0f;

+	}

+	else if ( carState.speed <= -SPEED_THROTTLE_AS_BRAKE )

+	{

+		flCarSign = -1.0f;

+	}

+	float carSpeed = fabs(INS2MPH(carState.speed));

+

+	// If going forward and turning hard, keep the throttle applied.

+	if( xbox_autothrottle.GetBool() && cmd->forwardmove > 0.0f )

+	{

+		if( carSpeed > GetMaxSpeed() * 0.75 )

+		{

+			if( fabs(cmd->sidemove) > cmd->forwardmove )

+			{

+				cmd->forwardmove = STICK_EXTENTS;

+			}

+		}

+	}

+

+	//Msg("F: %4.1f \tS: %4.1f!\tSTEER: %3.1f\n", cmd->forwardmove, cmd->sidemove, carState.steeringAngle);

+	// If changing direction, use default "return to zero" speed to more quickly transition.

+	if ( ( nButtons & IN_MOVELEFT ) || ( nButtons & IN_MOVERIGHT ) )

+	{

+		bool bTurnLeft = ( (nButtons & IN_MOVELEFT) != 0 );

+		bool bBrake = ((nButtons & IN_BACK) != 0);

+		bool bThrottleDown = ( (nButtons & IN_FORWARD) != 0 ) && !bBrake;

+		SteeringTurn( carSpeed, vehicleData, bTurnLeft, bBrake, bThrottleDown );

+	}

+	else if ( cmd->sidemove != 0.0f )

+	{

+		SteeringTurnAnalog( carSpeed, vehicleData, cmd->sidemove );

+	}

+	else

+	{

+		SteeringRest( carSpeed, vehicleData );

+	}

+

+	// Set vehicle control inputs.

+	m_controls.boost = 0;

+	m_controls.handbrake = false;

+	m_controls.handbrakeLeft = false;

+	m_controls.handbrakeRight = false;

+	m_controls.brakepedal = false;	

+	bool bThrottle;

+

+	//-------------------------------------------------------------------------

+	// Analog throttle biasing - This code gives the player a bit of control stick

+	// 'slop' in the opposite direction that they are driving. If a player is 

+	// driving forward and makes a hard turn in which the stick actually goes

+	// below neutral (toward reverse), this code continues to propel the car 

+	// forward unless the player makes a significant motion towards reverse.

+	// (The inverse is true when driving in reverse and the stick is moved slightly forward)

+	//-------------------------------------------------------------------------

+	CBaseEntity *pDriver = m_pOuterServerVehicle->GetDriver();

+	CBasePlayer *pPlayerDriver;

+	float flBiasThreshold = xbox_throttlebias.GetFloat();

+

+	if( pDriver && pDriver->IsPlayer() )

+	{

+		pPlayerDriver = dynamic_cast<CBasePlayer*>(pDriver);

+

+		if( cmd->forwardmove == 0.0f && (fabs(cmd->sidemove) < 200.0f) )

+		{

+			// If the stick goes neutral, clear out the bias. When the bias is neutral, it will begin biasing

+			// in whichever direction the user next presses the analog stick.

+			pPlayerDriver->SetVehicleAnalogControlBias( VEHICLE_ANALOG_BIAS_NONE );

+		}

+		else if( cmd->forwardmove > 0.0f)

+		{

+			if( pPlayerDriver->GetVehicleAnalogControlBias() == VEHICLE_ANALOG_BIAS_REVERSE )

+			{

+				// Player is pushing forward, but the controller is currently biased for reverse driving.

+				// Must pass a threshold to be accepted as forward input. Otherwise we just spoof a reduced reverse input 

+				// to keep the car moving in the direction the player probably expects.

+				if( cmd->forwardmove < flBiasThreshold )

+				{

+					cmd->forwardmove = -xbox_throttlespoof.GetFloat();

+				}

+				else

+				{

+					// Passed the threshold. Allow the direction change to occur.

+					pPlayerDriver->SetVehicleAnalogControlBias( VEHICLE_ANALOG_BIAS_FORWARD );

+				}

+			}

+			else if( pPlayerDriver->GetVehicleAnalogControlBias() == VEHICLE_ANALOG_BIAS_NONE )

+			{

+				pPlayerDriver->SetVehicleAnalogControlBias( VEHICLE_ANALOG_BIAS_FORWARD );

+			}

+		}

+		else if( cmd->forwardmove < 0.0f )

+		{

+			if( pPlayerDriver->GetVehicleAnalogControlBias() == VEHICLE_ANALOG_BIAS_FORWARD )

+			{

+				// Inverse of above logic

+				if( cmd->forwardmove > -flBiasThreshold )

+				{

+					cmd->forwardmove = xbox_throttlespoof.GetFloat();

+				}

+				else

+				{

+					pPlayerDriver->SetVehicleAnalogControlBias( VEHICLE_ANALOG_BIAS_REVERSE );

+				}

+			}

+			else if( pPlayerDriver->GetVehicleAnalogControlBias() == VEHICLE_ANALOG_BIAS_NONE )

+			{

+				pPlayerDriver->SetVehicleAnalogControlBias( VEHICLE_ANALOG_BIAS_REVERSE );

+			}

+		}

+	}

+

+	//=========================

+	// analog control

+	//=========================

+	if( cmd->forwardmove > 0.0f )

+	{

+		float flAnalogThrottle = cmd->forwardmove / STICK_EXTENTS;

+

+		flAnalogThrottle = clamp( flAnalogThrottle, 0.25f, 1.0f );

+

+		bThrottle = true;

+		if ( m_controls.throttle < 0 )

+		{

+			m_controls.throttle = 0;

+		}

+

+		float flMaxThrottle = MAX( 0.1, m_maxThrottle );

+		if ( m_controls.steering != 0 )

+		{

+			float flThrottleReduce = 0;

+

+			// ramp this in, don't just start at the slow speed reduction (helps accelerate from a stop)

+			if ( carSpeed < vehicleData.steering.speedSlow )

+			{

+				flThrottleReduce = RemapValClamped( carSpeed, 0, vehicleData.steering.speedSlow, 

+					0, vehicleData.steering.turnThrottleReduceSlow );

+			}

+			else

+			{

+				flThrottleReduce = RemapValClamped( carSpeed, vehicleData.steering.speedSlow, vehicleData.steering.speedFast, 

+					vehicleData.steering.turnThrottleReduceSlow, vehicleData.steering.turnThrottleReduceFast );

+			}

+

+			float limit = 1.0f - (flThrottleReduce * fabs(m_controls.steering));

+			if ( limit < 0 )

+				limit = 0;

+			flMaxThrottle = MIN( flMaxThrottle, limit );

+		}

+

+		m_controls.throttle = Approach( flMaxThrottle * flAnalogThrottle, m_controls.throttle, flFrameTime * m_throttleRate );

+

+		// Apply the brake.

+		if ( ( flCarSign < 0.0f ) && m_controls.bHasBrakePedal )

+		{

+			m_controls.brake = Approach( BRAKE_MAX_VALUE, m_controls.brake, flFrameTime * r_vehicleBrakeRate.GetFloat() * BRAKE_BACK_FORWARD_SCALAR );

+			m_controls.brakepedal = true;	

+			m_controls.throttle = 0.0f;

+			bThrottle = false;

+		}

+		else

+		{

+			m_controls.brake = 0.0f;

+		}

+	}

+	else if( cmd->forwardmove < 0.0f )

+	{

+		float flAnalogBrake = fabs(cmd->forwardmove / STICK_EXTENTS);

+

+		flAnalogBrake = clamp( flAnalogBrake, 0.25f, 1.0f );

+

+		bThrottle = true;

+		if ( m_controls.throttle > 0 )

+		{

+			m_controls.throttle = 0;

+		}

+

+		float flMaxThrottle = MIN( -0.1, m_flMaxRevThrottle  );

+		m_controls.throttle = Approach( flMaxThrottle * flAnalogBrake, m_controls.throttle, flFrameTime * m_throttleRate );

+

+		// Apply the brake.

+		if ( ( flCarSign > 0.0f ) && m_controls.bHasBrakePedal )

+		{

+			m_controls.brake = Approach( BRAKE_MAX_VALUE, m_controls.brake, flFrameTime * r_vehicleBrakeRate.GetFloat() );

+			m_controls.brakepedal = true;

+			m_controls.throttle = 0.0f;

+			bThrottle = false;

+		}

+		else

+		{

+			m_controls.brake = 0.0f;

+		}

+	}

+	// digital control

+	else if ( nButtons & IN_FORWARD )

+	{

+		bThrottle = true;

+		if ( m_controls.throttle < 0 )

+		{

+			m_controls.throttle = 0;

+		}

+

+		float flMaxThrottle = MAX( 0.1, m_maxThrottle );

+

+		if ( m_controls.steering != 0 )

+		{

+			float flThrottleReduce = 0;

+

+			// ramp this in, don't just start at the slow speed reduction (helps accelerate from a stop)

+			if ( carSpeed < vehicleData.steering.speedSlow )

+			{

+				flThrottleReduce = RemapValClamped( carSpeed, 0, vehicleData.steering.speedSlow, 

+					0, vehicleData.steering.turnThrottleReduceSlow );

+			}

+			else

+			{

+				flThrottleReduce = RemapValClamped( carSpeed, vehicleData.steering.speedSlow, vehicleData.steering.speedFast, 

+					vehicleData.steering.turnThrottleReduceSlow, vehicleData.steering.turnThrottleReduceFast );

+			}

+			

+			float limit = 1.0f - (flThrottleReduce * fabs(m_controls.steering));

+			if ( limit < 0 )

+				limit = 0;

+			flMaxThrottle = MIN( flMaxThrottle, limit );

+		}

+

+		m_controls.throttle = Approach( flMaxThrottle, m_controls.throttle, flFrameTime * m_throttleRate );

+

+		// Apply the brake.

+		if ( ( flCarSign < 0.0f ) && m_controls.bHasBrakePedal )

+		{

+			m_controls.brake = Approach( BRAKE_MAX_VALUE, m_controls.brake, flFrameTime * r_vehicleBrakeRate.GetFloat() * BRAKE_BACK_FORWARD_SCALAR );

+			m_controls.brakepedal = true;	

+			m_controls.throttle = 0.0f;

+			bThrottle = false;

+		}

+		else

+		{

+			m_controls.brake = 0.0f;

+		}

+	}

+	else if ( nButtons & IN_BACK )

+	{

+		bThrottle = true;

+		if ( m_controls.throttle > 0 )

+		{

+			m_controls.throttle = 0;

+		}

+

+		float flMaxThrottle = MIN( -0.1, m_flMaxRevThrottle );

+		m_controls.throttle = Approach( flMaxThrottle, m_controls.throttle, flFrameTime * m_throttleRate );

+

+		// Apply the brake.

+		if ( ( flCarSign > 0.0f ) && m_controls.bHasBrakePedal )

+		{

+			m_controls.brake = Approach( BRAKE_MAX_VALUE, m_controls.brake, flFrameTime * r_vehicleBrakeRate.GetFloat() );

+			m_controls.brakepedal = true;

+			m_controls.throttle = 0.0f;

+			bThrottle = false;

+		}

+		else

+		{

+			m_controls.brake = 0.0f;

+		}

+	}

+	else

+	{

+		bThrottle = false;

+		m_controls.throttle = 0;

+		m_controls.brake = 0.0f;

+	}

+

+	if ( ( nButtons & IN_SPEED ) && !IsEngineDisabled() && bThrottle )

+	{

+		m_controls.boost = 1.0f;

+	}

+

+	// Using has brakepedal for handbrake as well.

+	if ( ( nButtons & IN_JUMP ) && m_controls.bHasBrakePedal )

+	{

+		m_controls.handbrake = true;	

+

+		if ( cmd->sidemove < -100 )

+		{

+			m_controls.handbrakeLeft = true;

+		}

+		else if ( cmd->sidemove > 100 )

+		{

+			m_controls.handbrakeRight = true;

+		}

+

+		// Prevent playing of the engine revup when we're braking

+		bThrottle = false;

+	}

+

+	if ( IsEngineDisabled() )

+	{

+		m_controls.throttle = 0.0f;

+		m_controls.handbrake = true;

+		bThrottle = false;

+	}

+

+	// throttle sounds

+	// If we dropped a bunch of speed, restart the throttle

+	if ( bThrottle && (m_nLastSpeed > m_nSpeed && (m_nLastSpeed - m_nSpeed > 10)) )

+	{

+		m_bLastThrottle = false;

+	}

+

+	// throttle down now but not before??? (or we're braking)

+	if ( !m_controls.handbrake && !m_controls.brakepedal && bThrottle && !m_bLastThrottle )

+	{

+		m_throttleStartTime = gpGlobals->curtime;		// need to track how long throttle is down

+		m_bLastThrottle = true;

+	}

+	// throttle up now but not before??

+	else if ( !bThrottle && m_bLastThrottle && IsEngineDisabled() == false )

+	{

+		m_throttleActiveTime = gpGlobals->curtime - m_throttleStartTime;

+		m_bLastThrottle = false;

+	}

+

+	float flSpeedPercentage = clamp( m_nSpeed / m_flMaxSpeed, 0.f, 1.f );

+	vbs_sound_update_t params;

+	params.Defaults();

+	params.bReverse = (m_controls.throttle < 0);

+	params.bThrottleDown = bThrottle;

+	params.bTurbo = IsBoosting();

+	params.bVehicleInWater = m_pOuterServerVehicle->IsVehicleBodyInWater();

+	params.flCurrentSpeedFraction = flSpeedPercentage;

+	params.flFrameTime = flFrameTime;

+	params.flWorldSpaceSpeed = carState.speed;

+	m_pOuterServerVehicle->SoundUpdate( params );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+bool CFourWheelVehiclePhysics::IsBoosting( void )

+{

+	const vehicleparams_t *pVehicleParams = &m_pVehicle->GetVehicleParams();

+	const vehicle_operatingparams_t *pVehicleOperating = &m_pVehicle->GetOperatingParams();

+	if ( pVehicleParams && pVehicleOperating )

+	{	

+		if ( ( pVehicleOperating->boostDelay - pVehicleParams->engine.boostDelay ) > 0.0f )

+			return true;

+	}

+

+	return false;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void CFourWheelVehiclePhysics::SetDisableEngine( bool bDisable )

+{

+	// Set the engine state.

+	m_pVehicle->SetEngineDisabled( bDisable );

+}

+

+static int AddPhysToList( IPhysicsObject **pList, int listMax, int count, IPhysicsObject *pPhys )

+{

+	if ( pPhys )

+	{

+		if ( count < listMax )

+		{

+			pList[count] = pPhys;

+			count++;

+		}

+	}

+	return count;

+}

+

+int CFourWheelVehiclePhysics::VPhysicsGetObjectList( IPhysicsObject **pList, int listMax )

+{

+	int count = 0;

+	// add the body

+	count = AddPhysToList( pList, listMax, count, m_pOuter->VPhysicsGetObject() );

+	for ( int i = 0; i < 4; i++ )

+	{

+		count = AddPhysToList( pList, listMax, count, m_pWheels[i] );

+	}

+	return count;

+}