Renegade/Code/wwphys/vehiclephys.cpp

/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/***********************************************************************************************
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : WWPhys                                                       *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/wwphys/vehiclephys.cpp                       $*
 *                                                                                             *
 *              Original Author:: Greg Hjelstrom                                               *
 *                                                                                             *
 *                      $Author:: Byon_g                                                      $*
 *                                                                                             *
 *                     $Modtime:: 12/12/01 10:37a                                             $*
 *                                                                                             *
 *                    $Revision:: 26                                                          $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */


#include "vehiclephys.h"
#include "chunkio.h"
#include "persistfactory.h"
#include "wwphysids.h"
#include "wheel.h"
#include "physcontrol.h"
#include "octbox.h"
#include "pscene.h"
#include "wwprofile.h"
#include "vehicledazzle.h"

// Vehicles will sit rolled over for this long before exploding!
const float		EXPIRE_SECONDS								= 4.0f;

// HACK! when the engine is off, decimate the momentum each timestep by this fraction...
const float		PARKING_BRAKE_DAMPING					= 0.5f;

// max number of auxiliary graphical bones to support (e.g. engine flames)
const int		MAX_CAPTURED_BONE_COUNT					= 4;
const char *	ENGINE_FLAME_BONE_NAME					= "ENGINEFLAME";

// Wheel parsing constants...
const char *	WHEELP_BONE_NAME							= "WheelP";		// Position bone (contact patch)
const char *	WHEELC_BONE_NAME							= "WheelC";		// Center bone (rotational center of the wheel)
const char *	WHEELF_BONE_NAME							= "WheelF";		// Fork constraint bone (e.g. back wheel of a motorcycle)
const char *	WHEELT_BONE_NAME							= "WheelT";		// Translation constraint bone (e.g. front wheel of a motorcycle)
const int		WHEEL_INDEX_CHAR0							= 6;
const int		WHEEL_INDEX_CHAR1							= 7;
const int		WHEEL_FLAG_CHAR0							= 8;

// Wheel flags (begin appearing at character WHEEL_FLAG_CHAR0)
const char		WHEEL_FLAG_STEERING						= 'S';			// wheel turns with steering 
const char		WHEEL_FLAG_INV_STEERING					= 'I';			// wheel turns opposite steering
const char		WHEEL_FLAG_TILT_STEERING				= 'T';			// wheel turns when vehicle (bike) tilts
const char		WHEEL_FLAG_ENGINE							= 'E';			// wheel is attached to engine
const char		WHEEL_FLAG_LEFT_TRACK					= 'L';			// wheel is part of the left track
const char		WHEEL_FLAG_RIGHT_TRACK					= 'R';			// wheel is part of the right track
const char		WHEEL_FLAG_FAKE							= 'F';			// wheel is fake!

																
																						
																						
																						
/***********************************************************************************************
**
** VehiclePhysClass Implementation
**
***********************************************************************************************/


bool VehiclePhysClass::_DisableVehicleSimulation = false;
bool VehiclePhysClass::_DisableVehicleRendering = false;


/*
** Chunk Ids used by VehiclePhysClass
*/
enum
{
	VEHICLEPHYS_CHUNK_RIGIDBODY				= 405001445,		// parent class
	VEHICLEPHYS_CHUNK_VARIABLES,

	VEHICLEPHYS_VARIABLE_ISENGINEON			= 0,
};


VehiclePhysClass::VehiclePhysClass(void) :
	IsEngineOn(false),
	RealWheelCount(0),
	DriveWheelCount(0),
	EngineFlameBones(MAX_CAPTURED_BONE_COUNT),
	LastGoodPosition(1),
	ExpireTimer(EXPIRE_SECONDS)
{
	for (int i=0; i<MAX_CAPTURED_BONE_COUNT; i++) {
		EngineFlameBones[i] = -1;
	}
	Enable_Shadow_Generation(true);
}

void VehiclePhysClass::Init(const VehiclePhysDefClass & def)
{
	RigidBodyClass::Init(def);
	for (int i=0; i<MAX_CAPTURED_BONE_COUNT; i++) {
		EngineFlameBones[i] = -1;
	}
	Enable_Shadow_Generation(true);
}

void VehiclePhysClass::Definition_Changed(void)
{
	RigidBodyClass::Definition_Changed();

	for (int i=0; i<Wheels.Length(); i++) {
		const VehiclePhysDefClass * def = Get_VehiclePhysDef();
		Wheels[i]->Set_Spring_Constant(def->Get_Spring_Constant());
		Wheels[i]->Set_Damping_Coefficient(def->Get_Damping_Constant());
		Wheels[i]->Set_Spring_Length(def->Get_Spring_Length());
	}
}

VehiclePhysClass::~VehiclePhysClass(void)
{
	Release_Wheels();
	Release_Auxiliary_Bones();
	Release_Dazzles();
}


void VehiclePhysClass::Update_Wheels (void)
{
	/*
	** update the wheels graphically
	*/
	Set_Stationary_Collision_Region();
	Inc_Ignore_Counter();

	for (int i=0; i<Wheels.Length(); i++) {
		Wheels[i]->Update_Model();
	}
	
	PhysicsSceneClass::Get_Instance()->Release_Collision_Region();
	Dec_Ignore_Counter();

	return ;
}

void VehiclePhysClass::Non_Physical_Wheel_Update(float suspension_fraction,float rotation)
{
	for (int i=0; i<Wheels.Length(); i++) {
		Wheels[i]->Non_Physical_Update(suspension_fraction,rotation);
	}
}


void VehiclePhysClass::Render(RenderInfoClass & rinfo)
{
	const VehiclePhysDefClass * def = Get_VehiclePhysDef();

	/*
	** update the wheels graphically
	*/
	Update_Wheels();

	/*
	** update the engine flames
	*/
	Matrix3D flame_tm(1);
	flame_tm.Translate_Z(-Get_Normalized_Engine_Flame() * def->EngineFlameLength);
	for (int ibone=0; ibone<MAX_CAPTURED_BONE_COUNT; ibone++) {
		if (EngineFlameBones[ibone] != -1) {
			Model->Control_Bone(EngineFlameBones[ibone],flame_tm);
		}
	}

	/*
	** Update the dazzles
	*/
	for (int idazzle=0; idazzle<Dazzles.Length(); idazzle++) {
		Dazzles[idazzle]->Pre_Render_Update(this);
	}

	/*
	** Pass on up!
	*/
	RigidBodyClass::Render(rinfo);
}

void VehiclePhysClass::Set_Model(RenderObjClass * model)
{
	Release_Wheels();
	Release_Auxiliary_Bones();
	RigidBodyClass::Set_Model(model);
	Update_Cached_Model_Parameters();
}

float VehiclePhysClass::Compute_Approximate_Ride_Height(void)
{
	float val = 0.0f;

	if (ContactBox != NULL) {

		OBBoxClass box;
		ContactBox->Get_Inner_Box(&box,Quaternion(1),Vector3(0,0,0));
		val += (box.Extent.Z - box.Center.Z);
		
		if (Wheels.Length() > 0) {
			val += 0.66f * Wheels[0]->Get_Spring_Length();
		} else { 
			val += 0.6f;
		}

	} else { 
		val = 1.0f;
	}

	return val;
}

void VehiclePhysClass::Timestep(float dt)
{
	WWPROFILE("VehiclePhysClass::Timestep");
	int i;

	/*
	** Take a copy of our state for later "roll testing"
	*/
	RigidBodyStateStruct initial_state = State;

	/*
	** If the vehicle is not in use and it is on the ground, dampen the hell out of it
	*/
#if 0
	int contact_count=0;
	for (i=0; i<Wheels.Length(); i++) {
		if ((Wheels[i] != NULL) && (Wheels[i]->Get_Flag(SuspensionElementClass::INCONTACT) == true)) {
			contact_count++;
		}
	}
	if ((contact_count >= 3) && (Is_Engine_Enabled() == false)) {
		State.LMomentum *= PARKING_BRAKE_DAMPING;
		State.AMomentum *= PARKING_BRAKE_DAMPING;
	}
#endif

	/*
	** If there are wheels contacting the ground, turn off friction for the body of the vehicle
	*/
	bool wheels_touching_ground = false;
	for (i=0; i<Wheels.Length(); i++) {
		if ((Wheels[i] != NULL) && (Wheels[i]->Get_Flag(SuspensionElementClass::INCONTACT) == true)) {
			wheels_touching_ground = true;
		}
	}
	Set_Flag(FRICTION_DISABLED,wheels_touching_ground);

	/*
	** Call to parent class
	*/
	if (Get_VehiclePhysDef()->IsFake == false) {
		RigidBodyClass::Timestep(dt);
	}

	/*
	** See if we should be destroyed due to coming to rest upside down
	*/
	float up_cos = Get_Transform().Get_Z_Vector().Z;
	const float MIN_Z_COSINE = 0.25f;
	if (up_cos < MIN_Z_COSINE) {
		ExpireTimer -= dt;
		if (ExpireTimer < 0.0f) {
			ExpireTimer = EXPIRE_SECONDS; // if expiration is denied, try again later.
			Expire();
		}
	} else {
		ExpireTimer = EXPIRE_SECONDS;
	}
}

SuspensionElementClass * VehiclePhysClass::Peek_Wheel(int wheel_index)
{
	return Wheels[wheel_index];
}


void VehiclePhysClass::Compute_Force_And_Torque(Vector3 * force,Vector3 * torque)
{
	{
		WWPROFILE("VehiclePhysClass::Compute_Force_And_Torque");
		
		/*
		** Compute forces and torques for each wheel.
		*/
		int goodwheels = 0;
		for (int iwheel = 0; iwheel<Wheels.Length(); iwheel++) {
			Wheels[iwheel]->Compute_Force_And_Torque(force,torque);
			if (Wheels[iwheel]->Get_Flag(WheelClass::INCONTACT)) {
				goodwheels++;
			}
		}
		
		/*
		** If all of our wheels are contacting and we are mostly upright,
		** remember this transform as a "good" position.
		*/
		if ((goodwheels == Wheels.Length()) && (Rotation.Get_Z_Vector().Z > 0.7f)) {
			LastGoodPosition.Set(Rotation,State.Position);
		}
	}

	/*
	** Let base class add in its forces
	*/
	RigidBodyClass::Compute_Force_And_Torque(force,torque);
}

bool VehiclePhysClass::Can_Go_To_Sleep(float dt)
{
	/*
	** Vehicles go to sleep if at least three wheels are in contact and their 
	** velocities are below some thresh-hold and their controller isn't doing anything.
	*/
	if ((Controller != NULL) && (Controller->Is_Inactive() != true)) {
		GoToSleepTimer = RBODY_SLEEP_DELAY;
		return false;
	}
	
	/*
	** Check our velocities
	*/
	const float VEL_THRESHHOLD = 0.10f;
	const float AVEL_THRESHHOLD = 0.10f;

	float max_lmomentum2 = Mass * Mass * VEL_THRESHHOLD * VEL_THRESHHOLD;
	float max_amomentum2 = IBody[1][1] * IBody[1][1] * AVEL_THRESHHOLD * AVEL_THRESHHOLD;
	bool tried_to_sleep = false;

	if ((State.LMomentum.Length2() < max_lmomentum2) && 
		(State.AMomentum.Length2() < max_amomentum2) ) 
	{

		/*
		** Count the contacts
		*/
		int contact_count = 0;

		for (int iwheel = 0; iwheel<Wheels.Length(); iwheel++) {
			if (Wheels[iwheel]->Get_Flag(SuspensionElementClass::INCONTACT)) {
				contact_count++;
			}
		}	

		if ((Wheels.Length() <= 2) || (contact_count >= 3) || (ContactBox->ContactCount >= 3)) {
			tried_to_sleep = true;
			if (GoToSleepTimer < 0.0f) {
				return true;
			}
		}
	}

	if (tried_to_sleep) {
		GoToSleepTimer -= dt;
	} else {
		GoToSleepTimer = RBODY_SLEEP_DELAY;
	}

	return false;
}


void VehiclePhysClass::Update_Cached_Model_Parameters(void)
{
	if (Model == NULL) return;

	// capture the wheels
	Release_Wheels();
	Create_Wheels();

	// capture auxiliary bones
	Release_Auxiliary_Bones();
	Capture_Auxiliary_Bones();

	// count the drive wheels and real wheels
	DriveWheelCount = 0;
	RealWheelCount = 0;
	for (int i=0; i<Wheels.Length(); i++) {
		if (	Wheels[i]->Get_Flag(SuspensionElementClass::ENGINE) ||
				Wheels[i]->Get_Flag(SuspensionElementClass::LEFT_TRACK) ||
				Wheels[i]->Get_Flag(SuspensionElementClass::RIGHT_TRACK) ) 
		{
			DriveWheelCount++;
		}
		
		// "Real" wheels are all of them except the fake ones.
		if (Wheels[i]->Get_Flag(SuspensionElementClass::FAKE) == false) {
			RealWheelCount++;
		}
	}

	// cache pointers to the dazzles
	Release_Dazzles();
	Capture_Dazzles();

	// Force the shadow manager to use a scaled version of our "blob box"
	ShadowManager.Enable_Force_Use_Blob_Box(true);
	ShadowManager.Set_Blob_Box_Projection_Scale(Vector3(1.5f,1.5f,1.5f));
}

void VehiclePhysClass::Release_Wheels(void)
{
	// release the bones we "captured" and destroy the wheels
	for (int i=0; i<Wheels.Length(); i++) {
		delete Wheels[i];
		Wheels[i] = NULL;
	}
	Wheels.Resize(0);
	DriveWheelCount = 0;
	RealWheelCount = 0;
}

void VehiclePhysClass::Create_Wheels(void)
{
	RenderObjClass * model = Peek_Model();
	if (model == NULL) return;

	const VehiclePhysDefClass * def = Get_VehiclePhysDef();
	WWASSERT(def != NULL);
	
	int ibone;
	int wheelcount = 0;

	// Count the wheels.
	for (ibone=0; ibone < model->Get_Num_Bones(); ibone++) {

		// search for bones named WheelP
		const char * bonename = model->Get_Bone_Name(ibone);
		if (_strnicmp(bonename,WHEELP_BONE_NAME,strlen(WHEELP_BONE_NAME)) == 0) {
			wheelcount++;
		}
	}

	if (wheelcount == 0) {
		return;
	}

	// Allocate the array of pointers for the wheels
	Wheels.Resize(wheelcount);
	for (int i=0; i<Wheels.Length(); i++) {
		Wheels[i] = NULL;
	}

	int curwheel = 0;
	for (ibone=0; (ibone < model->Get_Num_Bones()) && (curwheel < Wheels.Length()); ibone++) {

		// for each bone named WheelP
		const char * wpname = model->Get_Bone_Name(ibone);
		if (_strnicmp(wpname,WHEELP_BONE_NAME,strlen(WHEELP_BONE_NAME)) == 0) {

			int position_bone = ibone;
			int rotation_bone = Find_Rotation_Bone(model,wpname);
			int fork_bone = Find_Fork_Bone(model,wpname);
			int trans_bone = Find_Translation_Bone(model,wpname);
		
			if (position_bone != -1) {

				// initialize a wheel structure:
				SuspensionElementClass * new_wheel = Alloc_Suspension_Element();
				new_wheel->Init(this,position_bone,rotation_bone,fork_bone,trans_bone);
				new_wheel->Set_Spring_Constant(def->SpringConstant);
				new_wheel->Set_Damping_Coefficient(def->DampingConstant);
				new_wheel->Set_Spring_Length(def->SpringLength);

				// parse any flag characters
				unsigned int index = WHEEL_FLAG_CHAR0;
				while (index < strlen(wpname)) {
					switch (wpname[index]) {
					case WHEEL_FLAG_STEERING:
						new_wheel->Set_Flag(SuspensionElementClass::STEERING,true);
						break;

					case WHEEL_FLAG_INV_STEERING:
						new_wheel->Set_Flag(SuspensionElementClass::INV_STEERING,true);
						break;

					case WHEEL_FLAG_TILT_STEERING:
						new_wheel->Set_Flag(SuspensionElementClass::TILT_STEERING,true);
						break;

					case WHEEL_FLAG_ENGINE:
						new_wheel->Set_Flag(SuspensionElementClass::ENGINE,true);
						break;

					case WHEEL_FLAG_LEFT_TRACK:
						new_wheel->Set_Flag(SuspensionElementClass::LEFT_TRACK,true);
						break;

					case WHEEL_FLAG_RIGHT_TRACK:
						new_wheel->Set_Flag(SuspensionElementClass::RIGHT_TRACK,true);
						break;

					case WHEEL_FLAG_FAKE:
						new_wheel->Set_Flag(SuspensionElementClass::FAKE,true);
						break;

					}
					index++;
				}
				
				// install the wheel
				Wheels[curwheel++] = new_wheel;
			}
		}
	}
}

int VehiclePhysClass::Find_Fork_Bone(RenderObjClass * model,const char * wpname)
{
	for (int ibone=0; ibone < model->Get_Num_Bones(); ibone++) {
				
		const char * wfname = model->Get_Bone_Name(ibone);
		if (	(_strnicmp(wfname,WHEELF_BONE_NAME,strlen(WHEELF_BONE_NAME)) == 0) &&
				(wfname[WHEEL_INDEX_CHAR0] == wpname[WHEEL_INDEX_CHAR0]) &&
				(wfname[WHEEL_INDEX_CHAR1] == wpname[WHEEL_INDEX_CHAR1]))
		{
			return ibone;
		}
	}
	return -1;
}

int VehiclePhysClass::Find_Rotation_Bone(RenderObjClass * model,const char * wpname)
{
	for (int ibone=0; ibone < model->Get_Num_Bones(); ibone++) {
				
		const char * wcname = model->Get_Bone_Name(ibone);
		if (	(_strnicmp(wcname,WHEELC_BONE_NAME,strlen(WHEELC_BONE_NAME)) == 0) &&
				(wcname[WHEEL_INDEX_CHAR0] == wpname[WHEEL_INDEX_CHAR0]) &&
				(wcname[WHEEL_INDEX_CHAR1] == wpname[WHEEL_INDEX_CHAR1]))
		{
			return ibone;
		}
	}
	return -1;
}

int VehiclePhysClass::Find_Translation_Bone(RenderObjClass * model,const char * wpname)
{
	for (int ibone=0; ibone < model->Get_Num_Bones(); ibone++) {
				
		const char * wtname = model->Get_Bone_Name(ibone);
		if (	(_strnicmp(wtname,WHEELT_BONE_NAME,strlen(WHEELT_BONE_NAME)) == 0) &&
				(wtname[WHEEL_INDEX_CHAR0] == wpname[WHEEL_INDEX_CHAR0]) &&
				(wtname[WHEEL_INDEX_CHAR1] == wpname[WHEEL_INDEX_CHAR1]))
		{
			return ibone;
		}
	}
	return -1;
}
 
void VehiclePhysClass::Release_Auxiliary_Bones(void)
{
	// release any bones that we currently have captured
	if (Model != NULL) {
		for (int i=0;i<MAX_CAPTURED_BONE_COUNT; i++) {
			if (EngineFlameBones[i] != -1) {
				Model->Release_Bone(EngineFlameBones[i]);
				EngineFlameBones[i] = -1;
			}
		}
	}
}

void VehiclePhysClass::Capture_Auxiliary_Bones(void)
{
	// search through the model for bones beginning with ENGINEFLAME
	int ibone = 0;
	int engine_bone_count = 0;

	for (ibone=0; (ibone < Model->Get_Num_Bones()) && (engine_bone_count < MAX_CAPTURED_BONE_COUNT); ibone++) {
		const char * bone_name = Model->Get_Bone_Name(ibone);
		if (_strnicmp(bone_name,ENGINE_FLAME_BONE_NAME,strlen(ENGINE_FLAME_BONE_NAME)) == 0) {
			
			EngineFlameBones[engine_bone_count] = ibone;
			Model->Capture_Bone(ibone);
			engine_bone_count++;
		}
	}
}


void VehiclePhysClass::Release_Dazzles(void)
{
	// delete the dazzle controllers
	for (int i=0; i<Dazzles.Length(); i++) {
		delete Dazzles[i];
		Dazzles[i] = NULL;
	}
	Dazzles.Resize(0);
}

void VehiclePhysClass::Capture_Dazzles(void)
{
	RenderObjClass * model = Peek_Model();
	if (model == NULL) return;

	const VehiclePhysDefClass * def = Get_VehiclePhysDef();
	WWASSERT(def != NULL);
	
	int imodel;
	int dazzlecount = 0;

	// Count the dazzles.
	for (imodel=0; imodel < model->Get_Num_Sub_Objects(); imodel++) {

		// Search for dazzle render objects whose name starts with _HLight, _TLight, or _BLight
		RenderObjClass * subobj = model->Get_Sub_Object(imodel);
		if ((subobj != NULL) && (subobj->Class_ID() == RenderObjClass::CLASSID_DAZZLE)) {
			if (VehicleDazzleClass::Is_Vehicle_Dazzle(subobj)) {
				dazzlecount++;
			}
		}
		REF_PTR_RELEASE(subobj);
	}

	// Return if we didn't find any dazzles that want to be controlled by the vehicle logic
	if (dazzlecount == 0) {
		return;
	}

	// Allocate the array of pointers for the wheels
	Dazzles.Resize(dazzlecount);
	for (int i=0; i<Dazzles.Length(); i++) {
		Dazzles[i] = NULL;
	}

	// Create dazzle controllers
	int curdazzle = 0;
	for (imodel=0; (imodel < model->Get_Num_Sub_Objects()) && (curdazzle < Dazzles.Length()); imodel++) {

		RenderObjClass * subobj = model->Get_Sub_Object(imodel);
		if (VehicleDazzleClass::Is_Vehicle_Dazzle(subobj)) {
			Dazzles[curdazzle] = Create_Dazzle_Controller(subobj);
			curdazzle++;
		}
		REF_PTR_RELEASE(subobj);
	}
}


VehicleDazzleClass * VehiclePhysClass::Create_Dazzle_Controller(RenderObjClass * obj)
{
	WWASSERT(VehicleDazzleClass::Is_Vehicle_Dazzle(obj));
	VehicleDazzleClass * controller = new VehicleDazzleClass();
	controller->Set_Model((DazzleRenderObjClass *)obj);
	return controller;
}

void VehiclePhysClass::Teleport_To_Last_Good_Position(void)
{
	Set_Transform(LastGoodPosition);
}


bool	VehiclePhysClass::Is_In_Contact(void)
{
	bool retval = false;

	//
	//	Check to see if any of the wheels are on the ground
	//
	for (int index = 0; index < Wheels.Length(); index++) {
		
		//
		//	Is this wheel on the ground?
		//
		if (Wheels[index]->Get_Flag(WheelClass::INCONTACT)) {
			retval = true;
			break;
		}
	}

	return retval;
}


bool VehiclePhysClass::Save(ChunkSaveClass &csave)
{
	csave.Begin_Chunk(VEHICLEPHYS_CHUNK_RIGIDBODY);
	RigidBodyClass::Save(csave);
	csave.End_Chunk();

	csave.Begin_Chunk(VEHICLEPHYS_CHUNK_VARIABLES);
	WRITE_MICRO_CHUNK(csave,VEHICLEPHYS_VARIABLE_ISENGINEON,IsEngineOn);
	csave.End_Chunk();

	return true;
}

bool VehiclePhysClass::Load(ChunkLoadClass &cload)
{
	while (cload.Open_Chunk()) {
		
		switch(cload.Cur_Chunk_ID()) 
		{
			case VEHICLEPHYS_CHUNK_RIGIDBODY:
				RigidBodyClass::Load(cload);
				break;
				
			case VEHICLEPHYS_CHUNK_VARIABLES:
				while (cload.Open_Micro_Chunk()) {
					switch(cload.Cur_Micro_Chunk_ID()) {
						READ_MICRO_CHUNK(cload,VEHICLEPHYS_VARIABLE_ISENGINEON,IsEngineOn);
					}
					cload.Close_Micro_Chunk();	
				}
				break;

			default:
				WWDEBUG_SAY(("Unhandled Chunk: 0x%X File: %s Line: %d\r\n",cload.Cur_Chunk_ID(),__FILE__,__LINE__));
				break;
		}
		
		cload.Close_Chunk();
	}

	return true;	
}
 
 
/***********************************************************************************************
**
** VehiclePhysDefClass Implementation
**
***********************************************************************************************/

/*
** Declare a PersistFactory for VehiclePhysDefClass
** Dont declare a Definition Factory because we don't want users to directly create this type.
*/
SimplePersistFactoryClass<VehiclePhysDefClass,PHYSICS_CHUNKID_VEHICLEPHYSDEF>	_VehiclePhysDefFactory;

/*
** Chunk ID's used by VehiclePhysDefClass
*/
enum 
{
	VEHICLEPHYSDEF_CHUNK_RIGIDBODYDEF					= 405001519,			// (parent class)
	VEHICLEPHYSDEF_CHUNK_VARIABLES,

	VEHICLEPHYSDEF_VARIABLE_SPRINGCONSTANT				= 0x00,	
	VEHICLEPHYSDEF_VARIABLE_DAMPINGCONSTANT,
	VEHICLEPHYSDEF_VARIABLE_SPRINGLENGTH,
	VEHICLEPHYSDEF_VARIABLE_TRACTIONMULTIPLIER,
	VEHICLEPHYSDEF_VARIABLE_LATERALMOMENTARM,
	VEHICLEPHYSDEF_VARIABLE_TRACTIVEMOMENTARM,
	VEHICLEPHYSDEF_VARIABLE_ENGINEFLAMELENGTH,
	VEHICLEPHYSDEF_VARIABLE_ISFAKE,
};

VehiclePhysDefClass::VehiclePhysDefClass(void) :
	SpringConstant(DEFAULT_SPRING_CONSTANT),
	DampingConstant(DEFAULT_DAMPING_COEFFICIENT),
	SpringLength(DEFAULT_SPRING_LENGTH),
	TractionMultiplier(2.0f),
	LateralMomentArm(0.0f),
	TractiveMomentArm(0.0f),
	EngineFlameLength(1.0f),
	IsFake(false)
{
	// make our parameters editable!
	EDITABLE_PARAM(VehiclePhysDefClass, ParameterClass::TYPE_BOOL, IsFake);	
	FLOAT_UNITS_PARAM(VehiclePhysDefClass, SpringConstant, 0.0f, 100000.0f,"N/m");
	FLOAT_UNITS_PARAM(VehiclePhysDefClass, DampingConstant, 0.0f, 100000.0f,"N/(m/s)");
	FLOAT_UNITS_PARAM(VehiclePhysDefClass, SpringLength, 0.0f, 100.0f,"m");
	FLOAT_EDITABLE_PARAM(VehiclePhysDefClass, TractionMultiplier, 0.5f, 5.0f);
	FLOAT_UNITS_PARAM(VehiclePhysDefClass, LateralMomentArm, 0.0f, 10.0f,"m");
	FLOAT_UNITS_PARAM(VehiclePhysDefClass, TractiveMomentArm, 0.0f, 10.0f,"m");
	FLOAT_UNITS_PARAM(VehiclePhysDefClass, EngineFlameLength, 0.0f, 100.0f,"m");
}

VehiclePhysDefClass::~VehiclePhysDefClass(void)
{
}

uint32 VehiclePhysDefClass::Get_Class_ID (void) const	
{ 
	return CLASSID_VEHICLEPHYSDEF; 
}

const PersistFactoryClass & VehiclePhysDefClass::Get_Factory (void) const
{
	return _VehiclePhysDefFactory;
}

bool VehiclePhysDefClass::Save(ChunkSaveClass &csave)
{
	csave.Begin_Chunk(VEHICLEPHYSDEF_CHUNK_RIGIDBODYDEF);
	RigidBodyDefClass::Save(csave);
	csave.End_Chunk();

	csave.Begin_Chunk(VEHICLEPHYSDEF_CHUNK_VARIABLES);
	WRITE_MICRO_CHUNK(csave,VEHICLEPHYSDEF_VARIABLE_SPRINGCONSTANT,SpringConstant);
	WRITE_MICRO_CHUNK(csave,VEHICLEPHYSDEF_VARIABLE_DAMPINGCONSTANT,DampingConstant);
	WRITE_MICRO_CHUNK(csave,VEHICLEPHYSDEF_VARIABLE_SPRINGLENGTH,SpringLength);
	WRITE_MICRO_CHUNK(csave,VEHICLEPHYSDEF_VARIABLE_TRACTIONMULTIPLIER,TractionMultiplier);
	WRITE_MICRO_CHUNK(csave,VEHICLEPHYSDEF_VARIABLE_LATERALMOMENTARM,LateralMomentArm);
	WRITE_MICRO_CHUNK(csave,VEHICLEPHYSDEF_VARIABLE_TRACTIVEMOMENTARM,TractiveMomentArm);
	WRITE_MICRO_CHUNK(csave,VEHICLEPHYSDEF_VARIABLE_ENGINEFLAMELENGTH,EngineFlameLength);
	WRITE_MICRO_CHUNK(csave,VEHICLEPHYSDEF_VARIABLE_ISFAKE,IsFake);
	csave.End_Chunk();
	return true;
}

bool VehiclePhysDefClass::Load(ChunkLoadClass &cload)
{
	while (cload.Open_Chunk()) {

		switch(cload.Cur_Chunk_ID()) {

			case VEHICLEPHYSDEF_CHUNK_RIGIDBODYDEF:
				RigidBodyDefClass::Load(cload);
				break;

			case VEHICLEPHYSDEF_CHUNK_VARIABLES:
				while (cload.Open_Micro_Chunk()) {
					switch(cload.Cur_Micro_Chunk_ID()) {
						READ_MICRO_CHUNK(cload,VEHICLEPHYSDEF_VARIABLE_SPRINGCONSTANT,SpringConstant);
						READ_MICRO_CHUNK(cload,VEHICLEPHYSDEF_VARIABLE_DAMPINGCONSTANT,DampingConstant);
						READ_MICRO_CHUNK(cload,VEHICLEPHYSDEF_VARIABLE_SPRINGLENGTH,SpringLength);
						READ_MICRO_CHUNK(cload,VEHICLEPHYSDEF_VARIABLE_TRACTIONMULTIPLIER,TractionMultiplier);
						READ_MICRO_CHUNK(cload,VEHICLEPHYSDEF_VARIABLE_LATERALMOMENTARM,LateralMomentArm);
						READ_MICRO_CHUNK(cload,VEHICLEPHYSDEF_VARIABLE_TRACTIVEMOMENTARM,TractiveMomentArm);
						READ_MICRO_CHUNK(cload,VEHICLEPHYSDEF_VARIABLE_ENGINEFLAMELENGTH,EngineFlameLength);
						READ_MICRO_CHUNK(cload,VEHICLEPHYSDEF_VARIABLE_ISFAKE,IsFake);
					}
					cload.Close_Micro_Chunk();
				}
				break;

			default:
				WWDEBUG_SAY(("Unhandled Chunk: 0x%X File: %s Line: %d\r\n",cload.Cur_Chunk_ID(),__FILE__,__LINE__));
				break;
		}

		cload.Close_Chunk();
	}

	return true;
}

bool VehiclePhysDefClass::Is_Type(const char * type_name)
{
	if (stricmp(type_name,VehiclePhysDefClass::Get_Type_Name()) == 0) {
		return true;
	} else {
		return RigidBodyDefClass::Is_Type(type_name);
	}
}