d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
230 Commits
25 Branches
6 Tags
221 MiB
Tree: 0aa1fe0b8d
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '0aa1fe0b8d'
${ noResults }
source-engine/game/server/fourwheelvehiclephysics.cpp

1450 lines
48 KiB
Raw Normal View History Unescape

1
5 years ago
//========= 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;
}