941 lines
20 KiB
C++
941 lines
20 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================//
|
|
#include "cbase.h"
|
|
|
|
#include "vcollide_parse_private.h"
|
|
|
|
#include "tier1/strtools.h"
|
|
#include "vphysics/constraints.h"
|
|
#include "vphysics/vehicles.h"
|
|
#include "filesystem_helpers.h"
|
|
#include "bspfile.h"
|
|
#include "utlbuffer.h"
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
static void ReadVector( const char *pString, Vector& out )
|
|
{
|
|
float x, y, z;
|
|
sscanf( pString, "%f %f %f", &x, &y, &z );
|
|
out[0] = x;
|
|
out[1] = y;
|
|
out[2] = z;
|
|
}
|
|
|
|
static void ReadAngles( const char *pString, QAngle& out )
|
|
{
|
|
float x, y, z;
|
|
sscanf( pString, "%f %f %f", &x, &y, &z );
|
|
out[0] = x;
|
|
out[1] = y;
|
|
out[2] = z;
|
|
}
|
|
|
|
static void ReadVector4D( const char *pString, Vector4D& out )
|
|
{
|
|
float x, y, z, w;
|
|
sscanf( pString, "%f %f %f %f", &x, &y, &z, &w );
|
|
out[0] = x;
|
|
out[1] = y;
|
|
out[2] = z;
|
|
out[3] = w;
|
|
}
|
|
|
|
class CVPhysicsParse : public IVPhysicsKeyParser
|
|
{
|
|
public:
|
|
~CVPhysicsParse() {}
|
|
|
|
CVPhysicsParse( const char *pKeyData );
|
|
void NextBlock( void );
|
|
|
|
const char *GetCurrentBlockName( void );
|
|
bool Finished( void );
|
|
void ParseSolid( solid_t *pSolid, IVPhysicsKeyHandler *unknownKeyHandler );
|
|
void ParseFluid( fluid_t *pFluid, IVPhysicsKeyHandler *unknownKeyHandler );
|
|
void ParseRagdollConstraint( constraint_ragdollparams_t *pConstraint, IVPhysicsKeyHandler *unknownKeyHandler );
|
|
void ParseSurfaceTable( int *table, IVPhysicsKeyHandler *unknownKeyHandler );
|
|
void ParseSurfaceTablePacked( CUtlVector<char> &out );
|
|
void ParseVehicle( vehicleparams_t *pVehicle, IVPhysicsKeyHandler *unknownKeyHandler );
|
|
void ParseCustom( void *pCustom, IVPhysicsKeyHandler *unknownKeyHandler );
|
|
void SkipBlock( void ) { ParseCustom(NULL, NULL); }
|
|
|
|
private:
|
|
void ParseVehicleAxle( vehicle_axleparams_t &axle );
|
|
void ParseVehicleWheel( vehicle_wheelparams_t &wheel );
|
|
void ParseVehicleSuspension( vehicle_suspensionparams_t &suspension );
|
|
void ParseVehicleBody( vehicle_bodyparams_t &body );
|
|
void ParseVehicleEngine( vehicle_engineparams_t &engine );
|
|
void ParseVehicleEngineBoost( vehicle_engineparams_t &engine );
|
|
void ParseVehicleSteering( vehicle_steeringparams_t &steering );
|
|
|
|
const char *m_pText;
|
|
char m_blockName[MAX_KEYVALUE];
|
|
};
|
|
|
|
|
|
CVPhysicsParse::CVPhysicsParse( const char *pKeyData )
|
|
{
|
|
m_pText = pKeyData;
|
|
NextBlock();
|
|
}
|
|
|
|
void CVPhysicsParse::NextBlock( void )
|
|
{
|
|
char key[MAX_KEYVALUE], value[MAX_KEYVALUE];
|
|
while ( m_pText )
|
|
{
|
|
m_pText = ParseKeyvalue( m_pText, key, value );
|
|
if ( !Q_strcmp(value, "{") )
|
|
{
|
|
V_strcpy_safe( m_blockName, key );
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Make sure m_blockName is initialized -- should this be done?
|
|
m_blockName[ 0 ] = 0;
|
|
}
|
|
|
|
|
|
const char *CVPhysicsParse::GetCurrentBlockName( void )
|
|
{
|
|
if ( m_pText )
|
|
return m_blockName;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
bool CVPhysicsParse::Finished( void )
|
|
{
|
|
if ( m_pText )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void CVPhysicsParse::ParseSolid( solid_t *pSolid, IVPhysicsKeyHandler *unknownKeyHandler )
|
|
{
|
|
char key[MAX_KEYVALUE], value[MAX_KEYVALUE];
|
|
key[0] = 0;
|
|
|
|
if ( unknownKeyHandler )
|
|
{
|
|
unknownKeyHandler->SetDefaults( pSolid );
|
|
}
|
|
else
|
|
{
|
|
memset( pSolid, 0, sizeof(*pSolid) );
|
|
}
|
|
|
|
// disable these until the ragdoll is created
|
|
pSolid->params.enableCollisions = false;
|
|
|
|
while ( m_pText )
|
|
{
|
|
m_pText = ParseKeyvalue( m_pText, key, value );
|
|
if ( key[0] == '}' )
|
|
{
|
|
NextBlock();
|
|
return;
|
|
}
|
|
|
|
if ( !Q_stricmp( key, "index" ) )
|
|
{
|
|
pSolid->index = atoi(value);
|
|
}
|
|
else if ( !Q_stricmp( key, "name" ) )
|
|
{
|
|
Q_strncpy( pSolid->name, value, sizeof(pSolid->name) );
|
|
}
|
|
else if ( !Q_stricmp( key, "parent" ) )
|
|
{
|
|
Q_strncpy( pSolid->parent, value, sizeof(pSolid->parent) );
|
|
}
|
|
else if ( !Q_stricmp( key, "surfaceprop" ) )
|
|
{
|
|
Q_strncpy( pSolid->surfaceprop, value, sizeof(pSolid->surfaceprop) );
|
|
}
|
|
else if ( !Q_stricmp( key, "mass" ) )
|
|
{
|
|
pSolid->params.mass = atof(value);
|
|
}
|
|
else if ( !Q_stricmp( key, "massCenterOverride" ) )
|
|
{
|
|
ReadVector( value, pSolid->massCenterOverride );
|
|
pSolid->params.massCenterOverride = &pSolid->massCenterOverride;
|
|
}
|
|
else if ( !Q_stricmp( key, "inertia" ) )
|
|
{
|
|
pSolid->params.inertia = atof(value);
|
|
}
|
|
else if ( !Q_stricmp( key, "damping" ) )
|
|
{
|
|
pSolid->params.damping = atof(value);
|
|
}
|
|
else if ( !Q_stricmp( key, "rotdamping" ) )
|
|
{
|
|
pSolid->params.rotdamping = atof(value);
|
|
}
|
|
else if ( !Q_stricmp( key, "volume" ) )
|
|
{
|
|
pSolid->params.volume = atof(value);
|
|
}
|
|
else if ( !Q_stricmp( key, "drag" ) )
|
|
{
|
|
pSolid->params.dragCoefficient = atof(value);
|
|
}
|
|
else if ( !Q_stricmp( key, "rollingdrag" ) )
|
|
{
|
|
//pSolid->params.rollingDrag = atof(value);
|
|
}
|
|
else
|
|
{
|
|
if ( unknownKeyHandler )
|
|
{
|
|
unknownKeyHandler->ParseKeyValue( pSolid, key, value );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CVPhysicsParse::ParseRagdollConstraint( constraint_ragdollparams_t *pConstraint, IVPhysicsKeyHandler *unknownKeyHandler )
|
|
{
|
|
char key[MAX_KEYVALUE], value[MAX_KEYVALUE];
|
|
|
|
key[0] = 0;
|
|
if ( unknownKeyHandler )
|
|
{
|
|
unknownKeyHandler->SetDefaults( pConstraint );
|
|
}
|
|
else
|
|
{
|
|
memset( pConstraint, 0, sizeof(*pConstraint) );
|
|
pConstraint->childIndex = -1;
|
|
pConstraint->parentIndex = -1;
|
|
}
|
|
|
|
// BUGBUG: xmin/xmax, ymin/ymax, zmin/zmax specify clockwise rotations.
|
|
// BUGBUG: HL rotations are counter-clockwise, so reverse these limits at some point!!!
|
|
pConstraint->useClockwiseRotations = true;
|
|
|
|
while ( m_pText )
|
|
{
|
|
m_pText = ParseKeyvalue( m_pText, key, value );
|
|
if ( key[0] == '}' )
|
|
{
|
|
NextBlock();
|
|
return;
|
|
}
|
|
|
|
if ( !Q_stricmp( key, "parent" ) )
|
|
{
|
|
pConstraint->parentIndex = atoi( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "child" ) )
|
|
{
|
|
pConstraint->childIndex = atoi( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "xmin" ) )
|
|
{
|
|
pConstraint->axes[0].minRotation = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "xmax" ) )
|
|
{
|
|
pConstraint->axes[0].maxRotation = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "xfriction" ) )
|
|
{
|
|
pConstraint->axes[0].angularVelocity = 0;
|
|
pConstraint->axes[0].torque = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "ymin" ) )
|
|
{
|
|
pConstraint->axes[1].minRotation = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "ymax" ) )
|
|
{
|
|
pConstraint->axes[1].maxRotation = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "yfriction" ) )
|
|
{
|
|
pConstraint->axes[1].angularVelocity = 0;
|
|
pConstraint->axes[1].torque = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "zmin" ) )
|
|
{
|
|
pConstraint->axes[2].minRotation = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "zmax" ) )
|
|
{
|
|
pConstraint->axes[2].maxRotation = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "zfriction" ) )
|
|
{
|
|
pConstraint->axes[2].angularVelocity = 0;
|
|
pConstraint->axes[2].torque = atof( value );
|
|
}
|
|
else
|
|
{
|
|
if ( unknownKeyHandler )
|
|
{
|
|
unknownKeyHandler->ParseKeyValue( pConstraint, key, value );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CVPhysicsParse::ParseFluid( fluid_t *pFluid, IVPhysicsKeyHandler *unknownKeyHandler )
|
|
{
|
|
char key[MAX_KEYVALUE], value[MAX_KEYVALUE];
|
|
|
|
key[0] = 0;
|
|
pFluid->index = -1;
|
|
if ( unknownKeyHandler )
|
|
{
|
|
unknownKeyHandler->SetDefaults( pFluid );
|
|
}
|
|
else
|
|
{
|
|
memset( pFluid, 0, sizeof(*pFluid) );
|
|
// HACKHACK: This is a reasonable default even though it is hardcoded
|
|
V_strcpy_safe( pFluid->surfaceprop, "water" );
|
|
}
|
|
|
|
while ( m_pText )
|
|
{
|
|
m_pText = ParseKeyvalue( m_pText, key, value );
|
|
if ( key[0] == '}' )
|
|
{
|
|
NextBlock();
|
|
return;
|
|
}
|
|
|
|
if ( !Q_stricmp( key, "index" ) )
|
|
{
|
|
pFluid->index = atoi( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "damping" ) )
|
|
{
|
|
pFluid->params.damping = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "surfaceplane" ) )
|
|
{
|
|
ReadVector4D( value, pFluid->params.surfacePlane );
|
|
}
|
|
else if ( !Q_stricmp( key, "currentvelocity" ) )
|
|
{
|
|
ReadVector( value, pFluid->params.currentVelocity );
|
|
}
|
|
else if ( !Q_stricmp( key, "contents" ) )
|
|
{
|
|
pFluid->params.contents = atoi( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "surfaceprop" ) )
|
|
{
|
|
Q_strncpy( pFluid->surfaceprop, value, sizeof(pFluid->surfaceprop) );
|
|
}
|
|
else
|
|
{
|
|
if ( unknownKeyHandler )
|
|
{
|
|
unknownKeyHandler->ParseKeyValue( pFluid, key, value );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CVPhysicsParse::ParseSurfaceTable( int *table, IVPhysicsKeyHandler *unknownKeyHandler )
|
|
{
|
|
char key[MAX_KEYVALUE], value[MAX_KEYVALUE];
|
|
|
|
key[0] = 0;
|
|
while ( m_pText )
|
|
{
|
|
m_pText = ParseKeyvalue( m_pText, key, value );
|
|
if ( key[0] == '}' )
|
|
{
|
|
NextBlock();
|
|
return;
|
|
}
|
|
|
|
int propIndex = physprops->GetSurfaceIndex( key );
|
|
int tableIndex = atoi(value);
|
|
if ( tableIndex >= 0 && tableIndex < 128 )
|
|
{
|
|
table[tableIndex] = propIndex;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CVPhysicsParse::ParseSurfaceTablePacked( CUtlVector<char> &out )
|
|
{
|
|
char key[MAX_KEYVALUE], value[MAX_KEYVALUE];
|
|
|
|
key[0] = 0;
|
|
int lastIndex = 0;
|
|
while ( m_pText )
|
|
{
|
|
m_pText = ParseKeyvalue( m_pText, key, value );
|
|
if ( key[0] == '}' )
|
|
{
|
|
NextBlock();
|
|
return;
|
|
}
|
|
|
|
int len = Q_strlen( key );
|
|
int outIndex = out.AddMultipleToTail( len + 1 );
|
|
memcpy( &out[outIndex], key, len+1 );
|
|
int tableIndex = atoi(value);
|
|
Assert( tableIndex == lastIndex + 1);
|
|
lastIndex = tableIndex;
|
|
}
|
|
}
|
|
|
|
void CVPhysicsParse::ParseVehicleAxle( vehicle_axleparams_t &axle )
|
|
{
|
|
char key[MAX_KEYVALUE], value[MAX_KEYVALUE];
|
|
|
|
memset( &axle, 0, sizeof(axle) );
|
|
key[0] = 0;
|
|
while ( m_pText )
|
|
{
|
|
m_pText = ParseKeyvalue( m_pText, key, value );
|
|
if ( key[0] == '}' )
|
|
return;
|
|
|
|
// parse subchunks
|
|
if ( value[0] == '{' )
|
|
{
|
|
if ( !Q_stricmp( key, "wheel" ) )
|
|
{
|
|
ParseVehicleWheel( axle.wheels );
|
|
}
|
|
else if ( !Q_stricmp( key, "suspension" ) )
|
|
{
|
|
ParseVehicleSuspension( axle.suspension );
|
|
}
|
|
else
|
|
{
|
|
SkipBlock();
|
|
}
|
|
}
|
|
else if ( !Q_stricmp( key, "offset" ) )
|
|
{
|
|
ReadVector( value, axle.offset );
|
|
}
|
|
else if ( !Q_stricmp( key, "wheeloffset" ) )
|
|
{
|
|
ReadVector( value, axle.wheelOffset );
|
|
}
|
|
else if ( !Q_stricmp( key, "torquefactor" ) )
|
|
{
|
|
axle.torqueFactor = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "brakefactor" ) )
|
|
{
|
|
axle.brakeFactor = atof( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CVPhysicsParse::ParseVehicleWheel( vehicle_wheelparams_t &wheel )
|
|
{
|
|
char key[MAX_KEYVALUE], value[MAX_KEYVALUE];
|
|
|
|
key[0] = 0;
|
|
while ( m_pText )
|
|
{
|
|
m_pText = ParseKeyvalue( m_pText, key, value );
|
|
if ( key[0] == '}' )
|
|
return;
|
|
|
|
if ( !Q_stricmp( key, "radius" ) )
|
|
{
|
|
wheel.radius = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "mass" ) )
|
|
{
|
|
wheel.mass = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "inertia" ) )
|
|
{
|
|
wheel.inertia = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "damping" ) )
|
|
{
|
|
wheel.damping = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "rotdamping" ) )
|
|
{
|
|
wheel.rotdamping = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "frictionscale" ) )
|
|
{
|
|
wheel.frictionScale = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "material" ) )
|
|
{
|
|
wheel.materialIndex = physprops->GetSurfaceIndex( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "skidmaterial" ) )
|
|
{
|
|
wheel.skidMaterialIndex = physprops->GetSurfaceIndex( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "brakematerial" ) )
|
|
{
|
|
wheel.brakeMaterialIndex = physprops->GetSurfaceIndex( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CVPhysicsParse::ParseVehicleSuspension( vehicle_suspensionparams_t &suspension )
|
|
{
|
|
char key[MAX_KEYVALUE], value[MAX_KEYVALUE];
|
|
|
|
key[0] = 0;
|
|
while ( m_pText )
|
|
{
|
|
m_pText = ParseKeyvalue( m_pText, key, value );
|
|
if ( key[0] == '}' )
|
|
return;
|
|
|
|
if ( !Q_stricmp( key, "springconstant" ) )
|
|
{
|
|
suspension.springConstant = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "springdamping" ) )
|
|
{
|
|
suspension.springDamping = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "stabilizerconstant" ) )
|
|
{
|
|
suspension.stabilizerConstant = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "springdampingcompression" ) )
|
|
{
|
|
suspension.springDampingCompression = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "maxbodyforce" ) )
|
|
{
|
|
suspension.maxBodyForce = atof( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CVPhysicsParse::ParseVehicleBody( vehicle_bodyparams_t &body )
|
|
{
|
|
char key[MAX_KEYVALUE], value[MAX_KEYVALUE];
|
|
|
|
key[0] = 0;
|
|
while ( m_pText )
|
|
{
|
|
m_pText = ParseKeyvalue( m_pText, key, value );
|
|
if ( key[0] == '}' )
|
|
return;
|
|
|
|
if ( !Q_stricmp( key, "massCenterOverride" ) )
|
|
{
|
|
ReadVector( value, body.massCenterOverride );
|
|
}
|
|
else if ( !Q_stricmp( key, "addgravity" ) )
|
|
{
|
|
body.addGravity = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "maxAngularVelocity" ) )
|
|
{
|
|
body.maxAngularVelocity = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "massOverride" ) )
|
|
{
|
|
body.massOverride = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "tiltforce" ) )
|
|
{
|
|
body.tiltForce = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "tiltforceheight" ) )
|
|
{
|
|
body.tiltForceHeight = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "countertorquefactor" ) )
|
|
{
|
|
body.counterTorqueFactor = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "keepuprighttorque" ) )
|
|
{
|
|
body.keepUprightTorque = atof( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CVPhysicsParse::ParseVehicleEngineBoost( vehicle_engineparams_t &engine )
|
|
{
|
|
char key[MAX_KEYVALUE], value[MAX_KEYVALUE];
|
|
|
|
key[0] = 0;
|
|
while ( m_pText )
|
|
{
|
|
m_pText = ParseKeyvalue( m_pText, key, value );
|
|
if ( key[0] == '}' )
|
|
return;
|
|
// parse subchunks
|
|
if ( !Q_stricmp( key, "force" ) )
|
|
{
|
|
engine.boostForce = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "duration" ) )
|
|
{
|
|
engine.boostDuration = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "delay" ) )
|
|
{
|
|
engine.boostDelay = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "maxspeed" ) )
|
|
{
|
|
engine.boostMaxSpeed = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "torqueboost" ) )
|
|
{
|
|
engine.torqueBoost = atoi( value ) != 0 ? true : false;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
void CVPhysicsParse::ParseVehicleEngine( vehicle_engineparams_t &engine )
|
|
{
|
|
char key[MAX_KEYVALUE], value[MAX_KEYVALUE];
|
|
|
|
key[0] = 0;
|
|
while ( m_pText )
|
|
{
|
|
m_pText = ParseKeyvalue( m_pText, key, value );
|
|
if ( key[0] == '}' )
|
|
return;
|
|
// parse subchunks
|
|
if ( value[0] == '{' )
|
|
{
|
|
if ( !Q_stricmp( key, "boost" ) )
|
|
{
|
|
ParseVehicleEngineBoost( engine );
|
|
}
|
|
else
|
|
{
|
|
SkipBlock();
|
|
}
|
|
}
|
|
else if ( !Q_stricmp( key, "gear" ) )
|
|
{
|
|
// Protect against exploits/overruns
|
|
if ( engine.gearCount < ARRAYSIZE(engine.gearRatio) )
|
|
{
|
|
engine.gearRatio[engine.gearCount] = atof( value );
|
|
engine.gearCount++;
|
|
}
|
|
else
|
|
{
|
|
Assert( 0 );
|
|
}
|
|
}
|
|
else if ( !Q_stricmp( key, "horsepower" ) )
|
|
{
|
|
engine.horsepower = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "maxSpeed" ) )
|
|
{
|
|
engine.maxSpeed = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "maxReverseSpeed" ) )
|
|
{
|
|
engine.maxRevSpeed = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "axleratio" ) )
|
|
{
|
|
engine.axleRatio = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "maxRPM" ) )
|
|
{
|
|
engine.maxRPM = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "throttleTime" ) )
|
|
{
|
|
engine.throttleTime = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "AutoTransmission" ) )
|
|
{
|
|
engine.isAutoTransmission = atoi( value ) != 0 ? true : false;
|
|
}
|
|
else if ( !Q_stricmp( key, "shiftUpRPM" ) )
|
|
{
|
|
engine.shiftUpRPM = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "shiftDownRPM" ) )
|
|
{
|
|
engine.shiftDownRPM = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "autobrakeSpeedGain" ) )
|
|
{
|
|
engine.autobrakeSpeedGain = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "autobrakeSpeedFactor" ) )
|
|
{
|
|
engine.autobrakeSpeedFactor = atof( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CVPhysicsParse::ParseVehicleSteering( vehicle_steeringparams_t &steering )
|
|
{
|
|
char key[MAX_KEYVALUE], value[MAX_KEYVALUE];
|
|
|
|
key[0] = 0;
|
|
while ( m_pText )
|
|
{
|
|
m_pText = ParseKeyvalue( m_pText, key, value );
|
|
if ( key[0] == '}' )
|
|
return;
|
|
// parse subchunks
|
|
if ( !Q_stricmp( key, "degreesSlow" ) )
|
|
{
|
|
steering.degreesSlow = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "degreesFast" ) )
|
|
{
|
|
steering.degreesFast = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "degreesBoost" ) )
|
|
{
|
|
steering.degreesBoost = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "fastcarspeed" ) )
|
|
{
|
|
steering.speedFast = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "slowcarspeed" ) )
|
|
{
|
|
steering.speedSlow = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "slowsteeringrate" ) )
|
|
{
|
|
steering.steeringRateSlow = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "faststeeringrate" ) )
|
|
{
|
|
steering.steeringRateFast = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "steeringRestRateSlow" ) )
|
|
{
|
|
steering.steeringRestRateSlow = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "steeringRestRateFast" ) )
|
|
{
|
|
steering.steeringRestRateFast = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "throttleSteeringRestRateFactor" ) )
|
|
{
|
|
steering.throttleSteeringRestRateFactor = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "boostSteeringRestRateFactor" ) )
|
|
{
|
|
steering.boostSteeringRestRateFactor = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "boostSteeringRateFactor" ) )
|
|
{
|
|
steering.boostSteeringRateFactor = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "steeringExponent" ) )
|
|
{
|
|
steering.steeringExponent = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "turnThrottleReduceSlow" ) )
|
|
{
|
|
steering.turnThrottleReduceSlow = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "turnThrottleReduceFast" ) )
|
|
{
|
|
steering.turnThrottleReduceFast = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "brakeSteeringRateFactor" ) )
|
|
{
|
|
steering.brakeSteeringRateFactor = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "powerSlideAccel" ) )
|
|
{
|
|
steering.powerSlideAccel = atof( value );
|
|
}
|
|
else if ( !Q_stricmp( key, "skidallowed" ) )
|
|
{
|
|
steering.isSkidAllowed = atoi( value ) != 0 ? true : false;
|
|
}
|
|
else if ( !Q_stricmp( key, "dustcloud" ) )
|
|
{
|
|
steering.dustCloud = atoi( value ) != 0 ? true : false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CVPhysicsParse::ParseVehicle( vehicleparams_t *pVehicle, IVPhysicsKeyHandler *unknownKeyHandler )
|
|
{
|
|
char key[MAX_KEYVALUE], value[MAX_KEYVALUE];
|
|
|
|
key[0] = 0;
|
|
if ( unknownKeyHandler )
|
|
{
|
|
unknownKeyHandler->SetDefaults( pVehicle );
|
|
}
|
|
else
|
|
{
|
|
memset( pVehicle, 0, sizeof(*pVehicle) );
|
|
}
|
|
|
|
while ( m_pText )
|
|
{
|
|
m_pText = ParseKeyvalue( m_pText, key, value );
|
|
if ( key[0] == '}' )
|
|
{
|
|
NextBlock();
|
|
return;
|
|
}
|
|
|
|
// parse subchunks
|
|
if ( value[0] == '{' )
|
|
{
|
|
if ( !Q_stricmp( key, "axle" ) )
|
|
{
|
|
// Protect against exploits/overruns
|
|
if ( pVehicle->axleCount < ARRAYSIZE(pVehicle->axles) )
|
|
{
|
|
ParseVehicleAxle( pVehicle->axles[pVehicle->axleCount] );
|
|
pVehicle->axleCount++;
|
|
}
|
|
else
|
|
{
|
|
Assert( 0 );
|
|
}
|
|
}
|
|
else if ( !Q_stricmp( key, "body" ) )
|
|
{
|
|
ParseVehicleBody( pVehicle->body );
|
|
}
|
|
else if ( !Q_stricmp( key, "engine" ) )
|
|
{
|
|
ParseVehicleEngine( pVehicle->engine );
|
|
}
|
|
else if ( !Q_stricmp( key, "steering" ) )
|
|
{
|
|
ParseVehicleSteering( pVehicle->steering );
|
|
}
|
|
else
|
|
{
|
|
SkipBlock();
|
|
}
|
|
}
|
|
else if ( !Q_stricmp( key, "wheelsperaxle" ) )
|
|
{
|
|
pVehicle->wheelsPerAxle = atoi( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CVPhysicsParse::ParseCustom( void *pCustom, IVPhysicsKeyHandler *unknownKeyHandler )
|
|
{
|
|
char key[MAX_KEYVALUE], value[MAX_KEYVALUE];
|
|
|
|
key[0] = 0;
|
|
int indent = 0;
|
|
if ( unknownKeyHandler )
|
|
{
|
|
unknownKeyHandler->SetDefaults( pCustom );
|
|
}
|
|
|
|
while ( m_pText )
|
|
{
|
|
m_pText = ParseKeyvalue( m_pText, key, value );
|
|
|
|
if ( m_pText )
|
|
{
|
|
if ( key[0] == '{' )
|
|
{
|
|
indent++;
|
|
}
|
|
else if ( value[0] == '{' )
|
|
{
|
|
// They've got a named block here
|
|
// Increase our indent, and let them parse the key
|
|
indent++;
|
|
if ( unknownKeyHandler )
|
|
{
|
|
unknownKeyHandler->ParseKeyValue( pCustom, key, value );
|
|
}
|
|
}
|
|
else if ( key[0] == '}' )
|
|
{
|
|
indent--;
|
|
if ( indent < 0 )
|
|
{
|
|
NextBlock();
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( unknownKeyHandler )
|
|
{
|
|
unknownKeyHandler->ParseKeyValue( pCustom, key, value );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
IVPhysicsKeyParser *CreateVPhysicsKeyParser( const char *pKeyData )
|
|
{
|
|
return new CVPhysicsParse( pKeyData );
|
|
}
|
|
|
|
void DestroyVPhysicsKeyParser( IVPhysicsKeyParser *pParser )
|
|
{
|
|
delete pParser;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Helper functions for parsing script file
|
|
//-----------------------------------------------------------------------------
|
|
|
|
const char *ParseKeyvalue( const char *pBuffer, char (&key)[MAX_KEYVALUE], char (&value)[MAX_KEYVALUE] )
|
|
{
|
|
// Make sure value is always null-terminated.
|
|
value[0] = 0;
|
|
|
|
pBuffer = ParseFile( pBuffer, key, NULL );
|
|
|
|
// no value on a close brace
|
|
if ( key[0] == '}' && key[1] == 0 )
|
|
{
|
|
value[0] = 0;
|
|
return pBuffer;
|
|
}
|
|
|
|
Q_strlower( key );
|
|
|
|
pBuffer = ParseFile( pBuffer, value, NULL );
|
|
|
|
Q_strlower( value );
|
|
|
|
return pBuffer;
|
|
}
|