jediacademypc/code/game/bg_vehicleload.c

//bg_vehicleLoad.c

#ifdef _JK2 //SP does not have this preprocessor for game like MP does
#ifndef _JK2MP
#define _JK2MP
#endif
#endif

#ifdef _JK2MP
	#include "q_shared.h"
	#include "bg_public.h"
	#include "bg_vehicles.h"
	#include "bg_weapons.h"

	//Could use strap stuff but I don't particularly care at the moment anyway.
#include "../namespace_begin.h"
	extern int	trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode );
	extern void	trap_FS_Read( void *buffer, int len, fileHandle_t f );
	extern void	trap_FS_Write( const void *buffer, int len, fileHandle_t f );
	extern void	trap_FS_FCloseFile( fileHandle_t f );
	extern int	trap_FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize );
#include "../namespace_end.h"
#else
	#include "g_local.h"
	#define QAGAME
#endif


#ifdef _JK2MP
#ifndef QAGAME
#ifndef CGAME
#define WE_ARE_IN_THE_UI
#include "../ui/ui_local.h"
#endif
#endif
#endif

#ifndef _JK2MP
#include "..\Ratl\string_vs.h"
#endif

#ifdef QAGAME
extern void G_SetSharedVehicleFunctions( vehicleInfo_t *pVehInfo );
extern int G_ModelIndex( const char *name );
extern int G_SoundIndex( const char *name );
	#ifdef _JK2MP
		extern int G_EffectIndex( const char *name );
	#endif
#elif CGAME
#include "../namespace_begin.h"
extern qhandle_t	trap_R_RegisterModel( const char *name );			// returns rgb axis if not found
extern qhandle_t	trap_R_RegisterSkin( const char *name );			// returns all white if not found
extern qhandle_t	trap_R_RegisterShader( const char *name );
extern qhandle_t	trap_R_RegisterShaderNoMip( const char *name );
extern int			trap_FX_RegisterEffect(const char *file);
extern sfxHandle_t	trap_S_RegisterSound( const char *sample);		// returns buzz if not found
#include "../namespace_end.h"
#else//UI
#include "../namespace_begin.h"
extern qhandle_t	trap_R_RegisterModel( const char *name );			// returns rgb axis if not found
extern qhandle_t	trap_R_RegisterSkin( const char *name );			// returns all white if not found
extern qhandle_t	trap_R_RegisterShader( const char *name );			// returns all white if not found
extern qhandle_t	trap_R_RegisterShaderNoMip( const char *name );			// returns all white if not found
extern sfxHandle_t	trap_S_RegisterSound( const char *sample);		// returns buzz if not found
#include "../namespace_end.h"
#endif

extern stringID_table_t animTable [MAX_ANIMATIONS+1];

// These buffers are filled in with the same contents and then just read from in
// a few places. We only need one copy on Xbox.
#define MAX_VEH_WEAPON_DATA_SIZE 0x4000
#define MAX_VEHICLE_DATA_SIZE 0x10000

#if !defined(_XBOX) || defined(QAGAME)
	char	VehWeaponParms[MAX_VEH_WEAPON_DATA_SIZE];
	char	VehicleParms[MAX_VEHICLE_DATA_SIZE];

void BG_ClearVehicleParseParms(void)
{
	//You can't strcat to these forever without clearing them!
	VehWeaponParms[0] = 0;
	VehicleParms[0] = 0;
}

#else
	extern char VehWeaponParms[MAX_VEH_WEAPON_DATA_SIZE];
	extern char VehicleParms[MAX_VEHICLE_DATA_SIZE];
#endif

#ifdef _JK2MP
#include "../namespace_begin.h"
#endif

#ifndef WE_ARE_IN_THE_UI
//These funcs are actually shared in both projects
extern void G_SetAnimalVehicleFunctions( vehicleInfo_t *pVehInfo );
extern void G_SetSpeederVehicleFunctions( vehicleInfo_t *pVehInfo );
extern void G_SetWalkerVehicleFunctions( vehicleInfo_t *pVehInfo );
extern void G_SetFighterVehicleFunctions( vehicleInfo_t *pVehInfo );
#endif

vehWeaponInfo_t g_vehWeaponInfo[MAX_VEH_WEAPONS];
int		numVehicleWeapons = 1;//first one is null/default

vehicleInfo_t g_vehicleInfo[MAX_VEHICLES];
int		numVehicles = 0;//first one is null/default

// Used by Xbox to reset all the kruft between levels
void BG_ClearVehicles(void)
{
	numVehicleWeapons = 1;
	memset( g_vehWeaponInfo, 0, sizeof(g_vehWeaponInfo) );

	numVehicles = 0;
	memset( g_vehicleInfo, 0, sizeof(g_vehicleInfo) );
}

void BG_VehicleLoadParms( void );

typedef enum {
	VF_IGNORE,
	VF_INT,
	VF_FLOAT,
	VF_LSTRING,	// string on disk, pointer in memory, TAG_LEVEL
	VF_VECTOR,
	VF_BOOL,
	VF_VEHTYPE,
	VF_ANIM,
	VF_WEAPON,	// take string, resolve into index into VehWeaponParms
	VF_MODEL,	// take the string, get the G_ModelIndex
	VF_MODEL_CLIENT,	// (cgame only) take the string, get the G_ModelIndex
	VF_EFFECT,	// take the string, get the G_EffectIndex
	VF_EFFECT_CLIENT,	// (cgame only) take the string, get the index
	VF_SHADER,	// (cgame only) take the string, call trap_R_RegisterShader
	VF_SHADER_NOMIP,// (cgame only) take the string, call trap_R_RegisterShaderNoMip
	VF_SOUND,	// take the string, get the G_SoundIndex
	VF_SOUND_CLIENT	// (cgame only) take the string, get the index
} vehFieldType_t;

typedef struct
{
	char	*name;
	int		ofs;
	vehFieldType_t	type;
} vehField_t;

vehField_t vehWeaponFields[NUM_VWEAP_PARMS] = 
{
	{"name", VWFOFS(name), VF_LSTRING},	//unique name of the vehicle
	{"projectile", VWFOFS(bIsProjectile), VF_BOOL},	//traceline or entity?
	{"hasGravity", VWFOFS(bHasGravity), VF_BOOL},	//if a projectile, drops
	{"ionWeapon", VWFOFS(bIonWeapon), VF_BOOL},	//disables ship shields and sends them out of control
	{"saberBlockable", VWFOFS(bSaberBlockable), VF_BOOL},	//lightsabers can deflect this projectile
	{"muzzleFX", VWFOFS(iMuzzleFX), VF_EFFECT_CLIENT},	//index of Muzzle Effect
	{"model", VWFOFS(iModel), VF_MODEL_CLIENT},	//handle to the model used by this projectile
	{"shotFX", VWFOFS(iShotFX), VF_EFFECT_CLIENT},	//index of Shot Effect
	{"impactFX", VWFOFS(iImpactFX), VF_EFFECT_CLIENT},	//index of Impact Effect
	{"g2MarkShader", VWFOFS(iG2MarkShaderHandle), VF_SHADER},	//index of shader to use for G2 marks made on other models when hit by this projectile
	{"g2MarkSize", VWFOFS(fG2MarkSize), VF_FLOAT},	//size (diameter) of the ghoul2 mark
	{"loopSound", VWFOFS(iLoopSound), VF_SOUND_CLIENT},	//index of loopSound
	{"speed", VWFOFS(fSpeed), VF_FLOAT},		//speed of projectile/range of traceline
	{"homing", VWFOFS(fHoming), VF_FLOAT},		//0.0 = not homing, 0.5 = half vel to targ, half cur vel, 1.0 = all vel to targ
	{"lockOnTime", VWFOFS(iLockOnTime), VF_INT},	//0 = no lock time needed, else # of ms needed to lock on
	{"damage", VWFOFS(iDamage), VF_INT},		//damage done when traceline or projectile directly hits target
	{"splashDamage", VWFOFS(iSplashDamage), VF_INT},//damage done to ents in splashRadius of end of traceline or projectile origin on impact
	{"splashRadius", VWFOFS(fSplashRadius), VF_FLOAT},//radius that ent must be in to take splashDamage (linear fall-off)
	{"ammoPerShot", VWFOFS(iAmmoPerShot), VF_INT},//how much "ammo" each shot takes
	{"health", VWFOFS(iHealth), VF_INT},		//if non-zero, projectile can be shot, takes this much damage before being destroyed
	{"width", VWFOFS(fWidth), VF_FLOAT},		//width of traceline or bounding box of projecile (non-rotating!)
	{"height", VWFOFS(fHeight), VF_FLOAT},		//height of traceline or bounding box of projecile (non-rotating!)
	{"lifetime", VWFOFS(iLifeTime), VF_INT},	//removes itself after this amount of time
	{"explodeOnExpire", VWFOFS(bExplodeOnExpire), VF_BOOL},	//when iLifeTime is up, explodes rather than simply removing itself
};

static qboolean BG_ParseVehWeaponParm( vehWeaponInfo_t *vehWeapon, char *parmName, char *pValue )
{
	int		i;
	vec3_t	vec;
	byte	*b = (byte *)vehWeapon;
	int		_iFieldsRead = 0;
	vehicleType_t vehType;
	char	value[1024];

	Q_strncpyz( value, pValue, sizeof(value) );

	// Loop through possible parameters
	for ( i = 0; i < NUM_VWEAP_PARMS; i++ )
	{
		if ( vehWeaponFields[i].name && !Q_stricmp( vehWeaponFields[i].name, parmName ) )
		{
			// found it
			switch( vehWeaponFields[i].type ) 
			{
			case VF_INT:
				*(int *)(b+vehWeaponFields[i].ofs) = atoi(value);
				break;
			case VF_FLOAT:
				*(float *)(b+vehWeaponFields[i].ofs) = atof(value);
				break;
			case VF_LSTRING:	// string on disk, pointer in memory, TAG_LEVEL
				if (!*(char **)(b+vehWeaponFields[i].ofs))
				{ //just use 1024 bytes in case we want to write over the string
#ifdef _JK2MP
					*(char **)(b+vehWeaponFields[i].ofs) = (char *)BG_Alloc(1024);//(char *)BG_Alloc(strlen(value));
					strcpy(*(char **)(b+vehWeaponFields[i].ofs), value);
#else
					(*(char **)(b+vehWeaponFields[i].ofs)) = G_NewString( value );
#endif
				}
				
				break;
			case VF_VECTOR:
				_iFieldsRead = sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]);
				assert(_iFieldsRead==3 );
				if (_iFieldsRead!=3)
				{
					Com_Printf (S_COLOR_YELLOW"BG_ParseVehWeaponParm: VEC3 sscanf() failed to read 3 floats ('angle' key bug?)\n");
				}
				((float *)(b+vehWeaponFields[i].ofs))[0] = vec[0];
				((float *)(b+vehWeaponFields[i].ofs))[1] = vec[1];
				((float *)(b+vehWeaponFields[i].ofs))[2] = vec[2];
				break;
			case VF_BOOL:
				*(qboolean *)(b+vehWeaponFields[i].ofs) = (qboolean)(atof(value)!=0);
				break;
			case VF_VEHTYPE:
				vehType = (vehicleType_t)GetIDForString( VehicleTable, value );
				*(vehicleType_t *)(b+vehWeaponFields[i].ofs) = vehType;
				break;
			case VF_ANIM:
				{
					int anim = GetIDForString( animTable, value );
					*(int *)(b+vehWeaponFields[i].ofs) = anim;
				}
				break;
			case VF_WEAPON:	// take string, resolve into index into VehWeaponParms
				//*(int *)(b+vehWeaponFields[i].ofs) = VEH_VehWeaponIndexForName( value );
				break;
			case VF_MODEL:// take the string, get the G_ModelIndex
#ifdef QAGAME
				*(int *)(b+vehWeaponFields[i].ofs) = G_ModelIndex( value );
#else
				*(int *)(b+vehWeaponFields[i].ofs) = trap_R_RegisterModel( value );
#endif
				break;
			case VF_MODEL_CLIENT:	// (MP cgame only) take the string, get the G_ModelIndex
#ifndef _JK2MP
				*(int *)(b+vehWeaponFields[i].ofs) = G_ModelIndex( value );
#elif QAGAME
				//*(int *)(b+vehWeaponFields[i].ofs) = G_ModelIndex( value );
#else
				*(int *)(b+vehWeaponFields[i].ofs) = trap_R_RegisterModel( value );
#endif
				break;
			case VF_EFFECT:	// take the string, get the G_EffectIndex
#ifdef QAGAME
				*(int *)(b+vehWeaponFields[i].ofs) = G_EffectIndex( value );
#elif CGAME
				*(int *)(b+vehWeaponFields[i].ofs) = trap_FX_RegisterEffect( value );
#endif
				break;
			case VF_EFFECT_CLIENT:	// (MP cgame only) take the string, get the index
#ifndef _JK2MP
				*(int *)(b+vehWeaponFields[i].ofs) = G_EffectIndex( value );
#elif QAGAME
				//*(int *)(b+vehWeaponFields[i].ofs) = G_EffectIndex( value );
#elif CGAME
				*(int *)(b+vehWeaponFields[i].ofs) = trap_FX_RegisterEffect( value );
#endif
				break;
			case VF_SHADER:	// (cgame only) take the string, call trap_R_RegisterShader
#ifdef WE_ARE_IN_THE_UI
				*(int *)(b+vehWeaponFields[i].ofs) = trap_R_RegisterShaderNoMip( value );
#elif CGAME
				*(int *)(b+vehWeaponFields[i].ofs) = trap_R_RegisterShader( value );
#endif
				break;
			case VF_SHADER_NOMIP:// (cgame only) take the string, call trap_R_RegisterShaderNoMip
#ifndef QAGAME
				*(int *)(b+vehWeaponFields[i].ofs) = trap_R_RegisterShaderNoMip( value );
#endif
				break;
			case VF_SOUND:	// take the string, get the G_SoundIndex
#ifdef QAGAME
				*(int *)(b+vehWeaponFields[i].ofs) = G_SoundIndex( value );
#else
				*(int *)(b+vehWeaponFields[i].ofs) = trap_S_RegisterSound( value );
#endif
				break;
			case VF_SOUND_CLIENT:	// (MP cgame only) take the string, get the index
#ifndef _JK2MP
				*(int *)(b+vehWeaponFields[i].ofs) = G_SoundIndex( value );
#elif QAGAME
				//*(int *)(b+vehWeaponFields[i].ofs) = G_SoundIndex( value );
#else
				*(int *)(b+vehWeaponFields[i].ofs) = trap_S_RegisterSound( value );
#endif
				break;
			default:
				//Unknown type?
				return qfalse;
				break;
			}
			break;
		}
	}
	if ( i == NUM_VWEAP_PARMS )
	{
        return qfalse;
	}
	else
	{
		return qtrue;
	}
}

int VEH_LoadVehWeapon( const char *vehWeaponName )
{//load up specified vehWeapon and save in array: g_vehWeaponInfo
	const char	*token;
	char		parmName[128];//we'll assume that no parm name is longer than 128
	char		*value;
	const char	*p;
	vehWeaponInfo_t	*vehWeapon = NULL;

	//BG_VehWeaponSetDefaults( &g_vehWeaponInfo[0] );//set the first vehicle to default data

	//try to parse data out
	p = VehWeaponParms;

#ifdef _JK2MP
	COM_BeginParseSession("vehWeapons");
#else
	COM_BeginParseSession();
#endif

	vehWeapon = &g_vehWeaponInfo[numVehicleWeapons];
	// look for the right vehicle weapon
	while ( p ) 
	{
		token = COM_ParseExt( &p, qtrue );
		if ( token[0] == 0 )
		{
			return qfalse;
		}

		if ( !Q_stricmp( token, vehWeaponName ) ) 
		{
			break;
		}

		SkipBracedSection( &p );
	}
	if ( !p ) 
	{
		return qfalse;
	}

	token = COM_ParseExt( &p, qtrue );
	if ( token[0] == 0 )
	{//barf
		return VEH_WEAPON_NONE;
	}

	if ( Q_stricmp( token, "{" ) != 0 ) 
	{
		return VEH_WEAPON_NONE;
	}
	
	// parse the vehWeapon info block
	while ( 1 ) 
	{
		SkipRestOfLine( &p );
		token = COM_ParseExt( &p, qtrue );
		if ( !token[0] ) 
		{
			Com_Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing Vehicle Weapon '%s'\n", vehWeaponName );
			return VEH_WEAPON_NONE;
		}

		if ( !Q_stricmp( token, "}" ) ) 
		{
			break;
		}
		Q_strncpyz( parmName, token, sizeof(parmName) );
		value = COM_ParseExt( &p, qtrue );
		if ( !value || !value[0] )
		{
			Com_Printf( S_COLOR_RED"ERROR: Vehicle Weapon token '%s' has no value!\n", parmName );
		}
		else
		{
			if ( !BG_ParseVehWeaponParm( vehWeapon, parmName, value ) )
			{
				Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle Weapon key/value pair '%s','%s'!\n", parmName, value );
			}
		}
	}
	if ( vehWeapon->fHoming )
	{//all lock-on weapons use these 2 sounds
#ifdef QAGAME
		//Hmm, no need fo have server register this, is there?
		//G_SoundIndex( "sound/weapons/torpedo/tick.wav" );
		//G_SoundIndex( "sound/weapons/torpedo/lock.wav" );
#elif CGAME
		trap_S_RegisterSound( "sound/vehicles/weapons/common/tick.wav" );
		trap_S_RegisterSound( "sound/vehicles/weapons/common/lock.wav" );
		trap_S_RegisterSound( "sound/vehicles/common/lockalarm1.wav" );
		trap_S_RegisterSound( "sound/vehicles/common/lockalarm2.wav" );
		trap_S_RegisterSound( "sound/vehicles/common/lockalarm3.wav" );
#else
		trap_S_RegisterSound( "sound/vehicles/weapons/common/tick.wav" );
		trap_S_RegisterSound( "sound/vehicles/weapons/common/lock.wav" );
		trap_S_RegisterSound( "sound/vehicles/common/lockalarm1.wav" );
		trap_S_RegisterSound( "sound/vehicles/common/lockalarm2.wav" );
		trap_S_RegisterSound( "sound/vehicles/common/lockalarm3.wav" );
#endif
	}
	return (numVehicleWeapons++);
}

int VEH_VehWeaponIndexForName( const char *vehWeaponName )
{
	int vw;
	if ( !vehWeaponName || !vehWeaponName[0] )
	{
		Com_Printf( S_COLOR_RED"ERROR: Trying to read Vehicle Weapon with no name!\n" );
		return VEH_WEAPON_NONE;
	}
	for ( vw = VEH_WEAPON_BASE; vw < numVehicleWeapons; vw++ )
	{
		if ( g_vehWeaponInfo[vw].name
			&& Q_stricmp( g_vehWeaponInfo[vw].name, vehWeaponName ) == 0 )
		{//already loaded this one
			return vw;
		}
	}
	//haven't loaded it yet
	if ( vw >= MAX_VEH_WEAPONS )
	{//no more room!
		Com_Printf( S_COLOR_RED"ERROR: Too many Vehicle Weapons (max 16), aborting load on %s!\n", vehWeaponName );
		return VEH_WEAPON_NONE;
	}
	//we have room for another one, load it up and return the index
	//HMM... should we not even load the .vwp file until we want to?
	vw = VEH_LoadVehWeapon( vehWeaponName );
	if ( vw == VEH_WEAPON_NONE )
	{
		Com_Printf( S_COLOR_RED"ERROR: Could not find Vehicle Weapon %s!\n", vehWeaponName );
	}
	return vw;
}

vehField_t vehicleFields[] = 
{
	{"name", VFOFS(name), VF_LSTRING},	//unique name of the vehicle

	//general data
	{"type", VFOFS(type), VF_VEHTYPE},	//what kind of vehicle
	{"numHands", VFOFS(numHands), VF_INT},	//if 2 hands, no weapons, if 1 hand, can use 1-handed weapons, if 0 hands, can use 2-handed weapons
	{"lookPitch", VFOFS(lookPitch), VF_FLOAT},	//How far you can look up and down off the forward of the vehicle
	{"lookYaw", VFOFS(lookYaw), VF_FLOAT},	//How far you can look left and right off the forward of the vehicle
	{"length", VFOFS(length), VF_FLOAT},		//how long it is - used for body length traces when turning/moving?
	{"width", VFOFS(width), VF_FLOAT},		//how wide it is - used for body length traces when turning/moving?
	{"height", VFOFS(height), VF_FLOAT},		//how tall it is - used for body length traces when turning/moving?
	{"centerOfGravity", VFOFS(centerOfGravity), VF_VECTOR},//offset from origin: {forward, right, up} as a modifier on that dimension (-1.0f is all the way back, 1.0f is all the way forward)

	//speed stats
	{"speedMax", VFOFS(speedMax), VF_FLOAT},		//top speed
	{"turboSpeed", VFOFS(turboSpeed), VF_FLOAT},	//turbo speed
	{"speedMin", VFOFS(speedMin), VF_FLOAT},		//if < 0, can go in reverse
	{"speedIdle", VFOFS(speedIdle), VF_FLOAT},		//what speed it drifts to when no accel/decel input is given
	{"accelIdle", VFOFS(accelIdle), VF_FLOAT},		//if speedIdle > 0, how quickly it goes up to that speed
	{"acceleration", VFOFS(acceleration), VF_FLOAT},	//when pressing on accelerator
	{"decelIdle", VFOFS(decelIdle), VF_FLOAT},		//when giving no input, how quickly it drops to speedIdle
	{"throttleSticks", VFOFS(throttleSticks), VF_BOOL},//if true, speed stays at whatever you accel/decel to, unless you turbo or brake
	{"strafePerc", VFOFS(strafePerc), VF_FLOAT},		//multiplier on current speed for strafing.  If 1.0f, you can strafe at the same speed as you're going forward, 0.5 is half, 0 is no strafing

	//handling stats
	{"bankingSpeed", VFOFS(bankingSpeed), VF_FLOAT},	//how quickly it pitches and rolls (not under player control)
	{"pitchLimit", VFOFS(pitchLimit), VF_FLOAT},		//how far it can roll forward or backward
	{"rollLimit", VFOFS(rollLimit), VF_FLOAT},		//how far it can roll to either side
	{"braking", VFOFS(braking), VF_FLOAT},		//when pressing on decelerator
	{"mouseYaw", VFOFS(mouseYaw), VF_FLOAT},			// The mouse yaw override.
	{"mousePitch", VFOFS(mousePitch), VF_FLOAT},			// The mouse yaw override.
	{"turningSpeed", VFOFS(turningSpeed), VF_FLOAT},	//how quickly you can turn
	{"turnWhenStopped", VFOFS(turnWhenStopped), VF_BOOL},//whether or not you can turn when not moving
	{"traction", VFOFS(traction), VF_FLOAT},		//how much your command input affects velocity
	{"friction", VFOFS(friction), VF_FLOAT},		//how much velocity is cut on its own
	{"maxSlope", VFOFS(maxSlope), VF_FLOAT},		//the max slope that it can go up with control
	{"speedDependantTurning", VFOFS(speedDependantTurning), VF_BOOL},//vehicle turns faster the faster it's going
	
	//durability stats
	{"mass", VFOFS(mass), VF_INT},			//for momentum and impact force (player mass is 10)
	{"armor", VFOFS(armor), VF_INT},			//total points of damage it can take
	{"shields", VFOFS(shields), VF_INT},			//energy shield damage points
	{"shieldRechargeMS", VFOFS(shieldRechargeMS), VF_INT},//energy shield milliseconds per point recharged
	{"toughness", VFOFS(toughness), VF_FLOAT},		//modifies incoming damage, 1.0 is normal, 0.5 is half, etc.  Simulates being made of tougher materials/construction
	{"malfunctionArmorLevel", VFOFS(malfunctionArmorLevel), VF_INT},//when armor drops to or below this point, start malfunctioning
	{"surfDestruction", VFOFS(surfDestruction), VF_INT},

	//visuals & sounds
	{"model", VFOFS(model), VF_LSTRING},			//what model to use - if make it an NPC's primary model, don't need this?
	{"skin", VFOFS(skin), VF_LSTRING},				//what skin to use - if make it an NPC's primary model, don't need this?
	{"g2radius", VFOFS(g2radius), VF_INT},			//render radius (really diameter, but...) for the ghoul2 model
	{"riderAnim", VFOFS(riderAnim), VF_ANIM},		//what animation the rider uses
	{"droidNPC", VFOFS(droidNPC), VF_LSTRING},		//NPC to attach to *droidunit tag (if it exists in the model)

#ifdef _JK2MP
	{"radarIcon", VFOFS(radarIconHandle), VF_SHADER_NOMIP},		//what icon to show on radar in MP
	{"dmgIndicFrame", VFOFS(dmgIndicFrameHandle), VF_SHADER_NOMIP},	//what image to use for the frame of the damage indicator
	{"dmgIndicShield", VFOFS(dmgIndicShieldHandle), VF_SHADER_NOMIP},//what image to use for the shield of the damage indicator
	{"dmgIndicBackground", VFOFS(dmgIndicBackgroundHandle), VF_SHADER_NOMIP},//what image to use for the background of the damage indicator
	{"icon_front", VFOFS(iconFrontHandle), VF_SHADER_NOMIP},	//what image to use for the front of the ship on the damage indicator
	{"icon_back", VFOFS(iconBackHandle), VF_SHADER_NOMIP},		//what image to use for the back of the ship on the damage indicator
	{"icon_right", VFOFS(iconRightHandle), VF_SHADER_NOMIP},	//what image to use for the right of the ship on the damage indicator
	{"icon_left", VFOFS(iconLeftHandle), VF_SHADER_NOMIP},		//what image to use for the left of the ship on the damage indicator
	{"crosshairShader", VFOFS(crosshairShaderHandle), VF_SHADER_NOMIP},	//what image to use as the crosshair
	{"shieldShader", VFOFS(shieldShaderHandle), VF_SHADER},		//What shader to use when drawing the shield shell

	//individual "area" health -rww
	{"health_front", VFOFS(health_front), VF_INT},
	{"health_back", VFOFS(health_back), VF_INT},
	{"health_right", VFOFS(health_right), VF_INT},
	{"health_left", VFOFS(health_left), VF_INT},
#else
	{"radarIcon", 0, VF_IGNORE},		//what icon to show on radar in MP
#endif

	{"soundOn",			VFOFS(soundOn),			VF_SOUND},//sound to play when get on it
	{"soundOff",		VFOFS(soundOff),		VF_SOUND},//sound to play when get off
	{"soundLoop",		VFOFS(soundLoop),		VF_SOUND},//sound to loop while riding it
	{"soundTakeOff",	VFOFS(soundTakeOff),	VF_SOUND},//sound to play when ship takes off
	{"soundEngineStart",VFOFS(soundEngineStart),VF_SOUND_CLIENT},//sound to play when ship's thrusters first activate
	{"soundSpin",		VFOFS(soundSpin),		VF_SOUND},//sound to loop while spiraling out of control
	{"soundTurbo",		VFOFS(soundTurbo),		VF_SOUND},//sound to play when turbo/afterburner kicks in
	{"soundHyper",		VFOFS(soundHyper),		VF_SOUND_CLIENT},//sound to play when hits hyperspace
	{"soundLand",		VFOFS(soundLand),		VF_SOUND},//sound to play when ship lands
	{"soundFlyBy",		VFOFS(soundFlyBy),		VF_SOUND_CLIENT},//sound to play when they buzz you
	{"soundFlyBy2",		VFOFS(soundFlyBy2),		VF_SOUND_CLIENT},//alternate sound to play when they buzz you
	{"soundShift1",		VFOFS(soundShift1),		VF_SOUND},//sound to play when changing speeds
	{"soundShift2",		VFOFS(soundShift2),		VF_SOUND},//sound to play when changing speeds
	{"soundShift3",		VFOFS(soundShift3),		VF_SOUND},//sound to play when changing speeds
	{"soundShift4",		VFOFS(soundShift4),		VF_SOUND},//sound to play when changing speeds

	{"exhaustFX", VFOFS(iExhaustFX), VF_EFFECT_CLIENT},		//exhaust effect, played from "*exhaust" bolt(s)
	{"turboFX", VFOFS(iTurboFX), VF_EFFECT_CLIENT},		//turbo exhaust effect, played from "*exhaust" bolt(s) when ship is in "turbo" mode
	{"turboStartFX", VFOFS(iTurboStartFX), VF_EFFECT},		//turbo start effect, played from "*exhaust" bolt(s) when ship is in "turbo" mode
	{"trailFX", VFOFS(iTrailFX), VF_EFFECT_CLIENT},		//trail effect, played from "*trail" bolt(s)
	{"impactFX", VFOFS(iImpactFX), VF_EFFECT_CLIENT},		//impact effect, for when it bumps into something
	{"explodeFX", VFOFS(iExplodeFX), VF_EFFECT},		//explosion effect, for when it blows up (should have the sound built into explosion effect)
	{"wakeFX", VFOFS(iWakeFX), VF_EFFECT_CLIENT},		//effect it makes when going across water
	{"dmgFX", VFOFS(iDmgFX), VF_EFFECT_CLIENT},		//effect to play on damage from a weapon or something
#ifdef _JK2MP
	{"injureFX", VFOFS(iInjureFX), VF_EFFECT_CLIENT}, //effect to play on partially damaged ship surface
	{"noseFX", VFOFS(iNoseFX), VF_EFFECT_CLIENT},		//effect for nose piece flying away when blown off
	{"lwingFX", VFOFS(iLWingFX), VF_EFFECT_CLIENT},		//effect for left wing piece flying away when blown off
	{"rwingFX", VFOFS(iRWingFX), VF_EFFECT_CLIENT},		//effect for right wing piece flying away when blown off
#else
	{"armorLowFX", VFOFS(iArmorLowFX), VF_EFFECT_CLIENT},		//effect to play on damage from a weapon or something
	{"armorGoneFX", VFOFS(iArmorGoneFX), VF_EFFECT_CLIENT},		//effect to play on damage from a weapon or something
#endif

	// Weapon stuff:
	{"weap1", VFOFS(weapon[0].ID), VF_WEAPON},	//weapon used when press fire
	{"weap2", VFOFS(weapon[1].ID), VF_WEAPON},//weapon used when press alt-fire
	// The delay between shots for this weapon.
	{"weap1Delay", VFOFS(weapon[0].delay), VF_INT},
	{"weap2Delay", VFOFS(weapon[1].delay), VF_INT},
	// Whether or not all the muzzles for each weapon can be linked together (linked delay = weapon delay * number of muzzles linked!)
	{"weap1Link", VFOFS(weapon[0].linkable), VF_INT},
	{"weap2Link", VFOFS(weapon[1].linkable), VF_INT},
	// Whether or not to auto-aim the projectiles at the thing under the crosshair when we fire
	{"weap1Aim", VFOFS(weapon[0].aimCorrect), VF_BOOL},
	{"weap2Aim", VFOFS(weapon[1].aimCorrect), VF_BOOL},
	//maximum ammo
	{"weap1AmmoMax", VFOFS(weapon[0].ammoMax), VF_INT},
	{"weap2AmmoMax", VFOFS(weapon[1].ammoMax), VF_INT},
	//ammo recharge rate - milliseconds per unit (minimum of 100, which is 10 ammo per second)
	{"weap1AmmoRechargeMS", VFOFS(weapon[0].ammoRechargeMS), VF_INT},
	{"weap2AmmoRechargeMS", VFOFS(weapon[1].ammoRechargeMS), VF_INT},
	//sound to play when out of ammo (plays default "no ammo" sound if none specified)
	{"weap1SoundNoAmmo", VFOFS(weapon[0].soundNoAmmo), VF_SOUND_CLIENT},//sound to play when try to fire weapon 1 with no ammo
	{"weap2SoundNoAmmo", VFOFS(weapon[1].soundNoAmmo), VF_SOUND_CLIENT},//sound to play when try to fire weapon 2 with no ammo
	
	// Which weapon a muzzle fires (has to match one of the weapons this vehicle has).
	{"weapMuzzle1", VFOFS(weapMuzzle[0]), VF_WEAPON},
	{"weapMuzzle2", VFOFS(weapMuzzle[1]), VF_WEAPON},
	{"weapMuzzle3", VFOFS(weapMuzzle[2]), VF_WEAPON},
	{"weapMuzzle4", VFOFS(weapMuzzle[3]), VF_WEAPON},
	{"weapMuzzle5", VFOFS(weapMuzzle[4]), VF_WEAPON},
	{"weapMuzzle6", VFOFS(weapMuzzle[5]), VF_WEAPON},
	{"weapMuzzle7", VFOFS(weapMuzzle[6]), VF_WEAPON},
	{"weapMuzzle8", VFOFS(weapMuzzle[7]), VF_WEAPON},
	{"weapMuzzle9", VFOFS(weapMuzzle[8]), VF_WEAPON},
	{"weapMuzzle10", VFOFS(weapMuzzle[9]), VF_WEAPON},

	// The max height before this ship (?) starts (auto)landing.
	{"landingHeight", VFOFS(landingHeight), VF_FLOAT},

	//other misc stats
	{"gravity", VFOFS(gravity), VF_INT},			//normal is 800
	{"hoverHeight", VFOFS(hoverHeight), VF_FLOAT},	//if 0, it's a ground vehicle
	{"hoverStrength", VFOFS(hoverStrength), VF_FLOAT},	//how hard it pushes off ground when less than hover height... causes "bounce", like shocks
	{"waterProof", VFOFS(waterProof), VF_BOOL},		//can drive underwater if it has to
	{"bouyancy", VFOFS(bouyancy), VF_FLOAT},		//when in water, how high it floats (1 is neutral bouyancy)
	{"fuelMax", VFOFS(fuelMax), VF_INT},		//how much fuel it can hold (capacity)
	{"fuelRate", VFOFS(fuelRate), VF_INT},		//how quickly is uses up fuel
	{"turboDuration", VFOFS(turboDuration), VF_INT},		//how long turbo lasts
	{"turboRecharge", VFOFS(turboRecharge), VF_INT},		//how long turbo takes to recharge
	{"visibility", VFOFS(visibility), VF_INT},		//for sight alerts
	{"loudness", VFOFS(loudness), VF_INT},		//for sound alerts
	{"explosionRadius", VFOFS(explosionRadius), VF_FLOAT},//range of explosion
	{"explosionDamage", VFOFS(explosionDamage), VF_INT},//damage of explosion

	//new stuff
	{"maxPassengers", VFOFS(maxPassengers), VF_INT},	// The max number of passengers this vehicle may have (Default = 0).
	{"hideRider", VFOFS(hideRider), VF_BOOL},			// rider (and passengers?) should not be drawn
	{"killRiderOnDeath", VFOFS(killRiderOnDeath), VF_BOOL},//if rider is on vehicle when it dies, they should die
	{"flammable", VFOFS(flammable), VF_BOOL},			//whether or not the vehicle should catch on fire before it explodes
	{"explosionDelay", VFOFS(explosionDelay), VF_INT},	//how long the vehicle should be on fire/dying before it explodes
	//camera stuff
	{"cameraOverride", VFOFS(cameraOverride), VF_BOOL},//override the third person camera with the below values - normal is 0 (off)
	{"cameraRange", VFOFS(cameraRange), VF_FLOAT},		//how far back the camera should be - normal is 80
	{"cameraVertOffset", VFOFS(cameraVertOffset), VF_FLOAT},//how high over the vehicle origin the camera should be - normal is 16
	{"cameraHorzOffset", VFOFS(cameraHorzOffset), VF_FLOAT},//how far to left/right (negative/positive) of of the vehicle origin the camera should be - normal is 0
	{"cameraPitchOffset", VFOFS(cameraPitchOffset), VF_FLOAT},//a modifier on the camera's pitch (up/down angle) to the vehicle - normal is 0
	{"cameraFOV", VFOFS(cameraFOV), VF_FLOAT},			//third person camera FOV, default is 80
	{"cameraAlpha", VFOFS(cameraAlpha), VF_FLOAT},		//fade out the vehicle to this alpha (0.1-1.0f) if it's in the way of the crosshair
	{"cameraPitchDependantVertOffset", VFOFS(cameraPitchDependantVertOffset), VF_BOOL},		//use the hacky AT-ST pitch dependant vertical offset
//===TURRETS===========================================================================
	//Turret 1
	{"turret1Weap", VFOFS(turret[0].iWeapon), VF_WEAPON},
	{"turret1Delay", VFOFS(turret[0].iDelay), VF_INT},
	{"turret1AmmoMax", VFOFS(turret[0].iAmmoMax), VF_INT},
	{"turret1AmmoRechargeMS", VFOFS(turret[0].iAmmoRechargeMS), VF_INT},
	{"turret1YawBone", VFOFS(turret[0].yawBone), VF_LSTRING},
	{"turret1PitchBone", VFOFS(turret[0].pitchBone), VF_LSTRING},
	{"turret1YawAxis", VFOFS(turret[0].yawAxis), VF_INT},
	{"turret1PitchAxis", VFOFS(turret[0].pitchAxis), VF_INT},
	{"turret1ClampYawL", VFOFS(turret[0].yawClampLeft), VF_FLOAT},	//how far the turret is allowed to turn left
	{"turret1ClampYawR", VFOFS(turret[0].yawClampRight), VF_FLOAT},	//how far the turret is allowed to turn right
	{"turret1ClampPitchU", VFOFS(turret[0].pitchClampUp), VF_FLOAT},	//how far the turret is allowed to title up
	{"turret1ClampPitchD", VFOFS(turret[0].pitchClampDown), VF_FLOAT}, //how far the turret is allowed to tilt down
	{"turret1Muzzle1", VFOFS(turret[0].iMuzzle[0]), VF_INT},
	{"turret1Muzzle2", VFOFS(turret[0].iMuzzle[1]), VF_INT},
	{"turret1TurnSpeed", VFOFS(turret[0].fTurnSpeed), VF_FLOAT},
	{"turret1AI", VFOFS(turret[0].bAI), VF_BOOL},
	{"turret1AILead", VFOFS(turret[0].bAILead), VF_BOOL},
	{"turret1AIRange", VFOFS(turret[0].fAIRange), VF_FLOAT},
	{"turret1PassengerNum", VFOFS(turret[0].passengerNum), VF_INT},//which number passenger can control this turret
	{"turret1GunnerViewTag", VFOFS(turret[0].gunnerViewTag), VF_LSTRING},
	
	//Turret 2
	{"turret2Weap", VFOFS(turret[1].iWeapon), VF_WEAPON},
	{"turret2Delay", VFOFS(turret[1].iDelay), VF_INT},
	{"turret2AmmoMax", VFOFS(turret[1].iAmmoMax), VF_INT},
	{"turret2AmmoRechargeMS", VFOFS(turret[1].iAmmoRechargeMS), VF_INT},
	{"turret2YawBone", VFOFS(turret[1].yawBone), VF_LSTRING},
	{"turret2PitchBone", VFOFS(turret[1].pitchBone), VF_LSTRING},
	{"turret2YawAxis", VFOFS(turret[1].yawAxis), VF_INT},
	{"turret2PitchAxis", VFOFS(turret[1].pitchAxis), VF_INT},
	{"turret2ClampYawL", VFOFS(turret[1].yawClampLeft), VF_FLOAT},	//how far the turret is allowed to turn left
	{"turret2ClampYawR", VFOFS(turret[1].yawClampRight), VF_FLOAT},	//how far the turret is allowed to turn right
	{"turret2ClampPitchU", VFOFS(turret[1].pitchClampUp), VF_FLOAT},	//how far the turret is allowed to title up
	{"turret2ClampPitchD", VFOFS(turret[1].pitchClampDown), VF_FLOAT}, //how far the turret is allowed to tilt down
	{"turret2Muzzle1", VFOFS(turret[1].iMuzzle[0]), VF_INT},
	{"turret2Muzzle2", VFOFS(turret[1].iMuzzle[1]), VF_INT},
	{"turret2TurnSpeed", VFOFS(turret[1].fTurnSpeed), VF_FLOAT},
	{"turret2AI", VFOFS(turret[1].bAI), VF_BOOL},
	{"turret2AILead", VFOFS(turret[1].bAILead), VF_BOOL},
	{"turret2AIRange", VFOFS(turret[1].fAIRange), VF_FLOAT},
	{"turret2PassengerNum", VFOFS(turret[1].passengerNum), VF_INT},//which number passenger can control this turret
	{"turret2GunnerViewTag", VFOFS(turret[1].gunnerViewTag), VF_LSTRING},
//===END TURRETS===========================================================================
	//terminating entry
	{0, -1, VF_INT}
};

stringID_table_t VehicleTable[VH_NUM_VEHICLES+1] =
{
	ENUM2STRING(VH_NONE),
	ENUM2STRING(VH_WALKER),		//something you ride inside of, it walks like you, like an AT-ST
	ENUM2STRING(VH_FIGHTER),	//something you fly inside of, like an X-Wing or TIE fighter
	ENUM2STRING(VH_SPEEDER),	//something you ride on that hovers, like a speeder or swoop
	ENUM2STRING(VH_ANIMAL),		//animal you ride on top of that walks, like a tauntaun
	ENUM2STRING(VH_FLIER),		//animal you ride on top of that flies, like a giant mynoc?
	0,	-1
};

// Setup the shared functions (one's that all vehicles would generally use).
void BG_SetSharedVehicleFunctions( vehicleInfo_t *pVehInfo )
{
#ifdef QAGAME
	//only do the whole thing if we're on game
	G_SetSharedVehicleFunctions(pVehInfo);
#endif

#ifndef WE_ARE_IN_THE_UI
	switch( pVehInfo->type )
	{
		case VH_SPEEDER:
			G_SetSpeederVehicleFunctions( pVehInfo );
			break;
		case VH_ANIMAL:
			G_SetAnimalVehicleFunctions( pVehInfo );
			break;
		case VH_FIGHTER:
			G_SetFighterVehicleFunctions( pVehInfo );
			break;
		case VH_WALKER:
			G_SetWalkerVehicleFunctions( pVehInfo );
			break;
	}
#endif
}

void BG_VehicleSetDefaults( vehicleInfo_t *vehicle )
{
	memset(vehicle, 0, sizeof(vehicleInfo_t));
/*
#if _JK2MP
	if (!vehicle->name)
	{
		vehicle->name = (char *)BG_Alloc(1024);
	}
	strcpy(vehicle->name, "default");
#else
	vehicle->name = G_NewString( "default" );
#endif

	//general data
	vehicle->type = VH_SPEEDER;				//what kind of vehicle
	//FIXME: no saber or weapons if numHands = 2, should switch to speeder weapon, no attack anim on player
	vehicle->numHands = 0;					//if 2 hands, no weapons, if 1 hand, can use 1-handed weapons, if 0 hands, can use 2-handed weapons
	vehicle->lookPitch = 0;				//How far you can look up and down off the forward of the vehicle
	vehicle->lookYaw = 5;					//How far you can look left and right off the forward of the vehicle
	vehicle->length = 0;					//how long it is - used for body length traces when turning/moving?
	vehicle->width = 0;						//how wide it is - used for body length traces when turning/moving?
	vehicle->height = 0;					//how tall it is - used for body length traces when turning/moving?
	VectorClear( vehicle->centerOfGravity );//offset from origin: {forward, right, up} as a modifier on that dimension (-1.0f is all the way back, 1.0f is all the way forward)

	//speed stats - note: these are DESIRED speed, not actual current speed/velocity
	vehicle->speedMax = VEH_DEFAULT_SPEED_MAX;	//top speed
	vehicle->turboSpeed = 0;					//turboBoost
	vehicle->speedMin = 0;						//if < 0, can go in reverse
	vehicle->speedIdle = 0;						//what speed it drifts to when no accel/decel input is given
	vehicle->accelIdle = 0;						//if speedIdle > 0, how quickly it goes up to that speed
	vehicle->acceleration = VEH_DEFAULT_ACCEL;	//when pressing on accelerator (1/2 this when going in reverse)
	vehicle->decelIdle = VEH_DEFAULT_DECEL;		//when giving no input, how quickly it desired speed drops to speedIdle
	vehicle->strafePerc = VEH_DEFAULT_STRAFE_PERC;//multiplier on current speed for strafing.  If 1.0f, you can strafe at the same speed as you're going forward, 0.5 is half, 0 is no strafing

	//handling stats
	vehicle->bankingSpeed = VEH_DEFAULT_BANKING_SPEED;	//how quickly it pitches and rolls (not under player control)
	vehicle->rollLimit = VEH_DEFAULT_ROLL_LIMIT;		//how far it can roll to either side
	vehicle->pitchLimit = VEH_DEFAULT_PITCH_LIMIT;		//how far it can pitch forward or backward
	vehicle->braking = VEH_DEFAULT_BRAKING;				//when pressing on decelerator (backwards)
	vehicle->turningSpeed = VEH_DEFAULT_TURNING_SPEED;	//how quickly you can turn
	vehicle->turnWhenStopped = qfalse;					//whether or not you can turn when not moving	
	vehicle->traction = VEH_DEFAULT_TRACTION;			//how much your command input affects velocity
	vehicle->friction = VEH_DEFAULT_FRICTION;			//how much velocity is cut on its own
	vehicle->maxSlope = VEH_DEFAULT_MAX_SLOPE;			//the max slope that it can go up with control

	//durability stats
	vehicle->mass = VEH_DEFAULT_MASS;			//for momentum and impact force (player mass is 10)
	vehicle->armor = VEH_DEFAULT_MAX_ARMOR;		//total points of damage it can take
	vehicle->toughness = VEH_DEFAULT_TOUGHNESS;	//modifies incoming damage, 1.0 is normal, 0.5 is half, etc.  Simulates being made of tougher materials/construction
	vehicle->malfunctionArmorLevel = 0;			//when armor drops to or below this point, start malfunctioning

	//visuals & sounds
	//vehicle->model = "models/map_objects/ships/swoop.md3";	//what model to use - if make it an NPC's primary model, don't need this?
	if (!vehicle->model)
	{
		vehicle->model = (char *)BG_Alloc(1024);
	}
	strcpy(vehicle->model, "models/map_objects/ships/swoop.md3");

	vehicle->modelIndex = 0;							//set internally, not until this vehicle is spawned into the level
	vehicle->skin = NULL;								//what skin to use - if make it an NPC's primary model, don't need this?
	vehicle->riderAnim = BOTH_GUNSIT1;					//what animation the rider uses

	vehicle->soundOn = NULL;							//sound to play when get on it
	vehicle->soundLoop = NULL;							//sound to loop while riding it
	vehicle->soundOff = NULL;							//sound to play when get off
	vehicle->exhaustFX = NULL;							//exhaust effect, played from "*exhaust" bolt(s)
	vehicle->trailFX = NULL;							//trail effect, played from "*trail" bolt(s)
	vehicle->impactFX = NULL;							//explosion effect, for when it blows up (should have the sound built into explosion effect)
	vehicle->explodeFX = NULL;							//explosion effect, for when it blows up (should have the sound built into explosion effect)
	vehicle->wakeFX = NULL;								//effect itmakes when going across water

	//other misc stats
	vehicle->gravity = VEH_DEFAULT_GRAVITY;				//normal is 800
	vehicle->hoverHeight = 0;//VEH_DEFAULT_HOVER_HEIGHT;	//if 0, it's a ground vehicle
	vehicle->hoverStrength = 0;//VEH_DEFAULT_HOVER_STRENGTH;//how hard it pushes off ground when less than hover height... causes "bounce", like shocks
	vehicle->waterProof = qtrue;						//can drive underwater if it has to
	vehicle->bouyancy = 1.0f;							//when in water, how high it floats (1 is neutral bouyancy)
	vehicle->fuelMax = 1000;							//how much fuel it can hold (capacity)
	vehicle->fuelRate = 1;								//how quickly is uses up fuel
	vehicle->visibility = VEH_DEFAULT_VISIBILITY;		//radius for sight alerts
	vehicle->loudness = VEH_DEFAULT_LOUDNESS;			//radius for sound alerts
	vehicle->explosionRadius = VEH_DEFAULT_EXP_RAD;
	vehicle->explosionDamage = VEH_DEFAULT_EXP_DMG;
	vehicle->maxPassengers = 0;

	//new stuff
	vehicle->hideRider = qfalse;						// rider (and passengers?) should not be drawn
	vehicle->killRiderOnDeath = qfalse;					//if rider is on vehicle when it dies, they should die
	vehicle->flammable = qfalse;						//whether or not the vehicle should catch on fire before it explodes
	vehicle->explosionDelay = 0;						//how long the vehicle should be on fire/dying before it explodes
	//camera stuff
	vehicle->cameraOverride = qfalse;					//whether or not to use all of the following 3rd person camera override values
	vehicle->cameraRange = 0.0f;						//how far back the camera should be - normal is 80
	vehicle->cameraVertOffset = 0.0f;					//how high over the vehicle origin the camera should be - normal is 16
	vehicle->cameraHorzOffset = 0.0f;					//how far to left/right (negative/positive) of of the vehicle origin the camera should be - normal is 0
	vehicle->cameraPitchOffset = 0.0f;					//a modifier on the camera's pitch (up/down angle) to the vehicle - normal is 0
	vehicle->cameraFOV = 0.0f;							//third person camera FOV, default is 80
	vehicle->cameraAlpha = qfalse;						//fade out the vehicle if it's in the way of the crosshair
*/
}

void BG_VehicleClampData( vehicleInfo_t *vehicle )
{//sanity check and clamp the vehicle's data
	int		i;

	for ( i = 0; i < 3; i++ )
	{
		if ( vehicle->centerOfGravity[i] > 1.0f )
		{
			vehicle->centerOfGravity[i] = 1.0f;
		}
		else if ( vehicle->centerOfGravity[i] < -1.0f )
		{
			vehicle->centerOfGravity[i] = -1.0f;
		}
	}

	// Validate passenger max.
	if ( vehicle->maxPassengers > VEH_MAX_PASSENGERS )
	{
		vehicle->maxPassengers = VEH_MAX_PASSENGERS;
	}
	else if ( vehicle->maxPassengers < 0 )
	{
		vehicle->maxPassengers = 0;
	}
}

static qboolean BG_ParseVehicleParm( vehicleInfo_t *vehicle, char *parmName, char *pValue )
{
	int		i;
	vec3_t	vec;
	byte	*b = (byte *)vehicle;
	int		_iFieldsRead = 0;
	vehicleType_t vehType;
	char value[1024];

	Q_strncpyz( value, pValue, sizeof(value) );

	// Loop through possible parameters
	for ( i = 0; vehicleFields[i].ofs != -1; i++ )
	{
		if ( !Q_stricmp( vehicleFields[i].name, parmName ) )
		{
			// found it
			switch( vehicleFields[i].type ) 
			{
			case VF_IGNORE:
				break;
			case VF_INT:
				*(int *)(b+vehicleFields[i].ofs) = atoi(value);
				break;
			case VF_FLOAT:
				*(float *)(b+vehicleFields[i].ofs) = atof(value);
				break;
			case VF_LSTRING:	// string on disk, pointer in memory, TAG_LEVEL
				if (!*(char **)(b+vehicleFields[i].ofs))
				{ //just use 128 bytes in case we want to write over the string
#ifdef _JK2MP
					*(char **)(b+vehicleFields[i].ofs) = (char *)BG_Alloc(128);//(char *)BG_Alloc(strlen(value));
					strcpy(*(char **)(b+vehicleFields[i].ofs), value);
#else
					(*(char **)(b+vehicleFields[i].ofs)) = G_NewString( value );
#endif
				}
				
				break;
			case VF_VECTOR:
				_iFieldsRead = sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]);
				assert(_iFieldsRead==3 );
				if (_iFieldsRead!=3)
				{
					Com_Printf (S_COLOR_YELLOW"BG_ParseVehicleParm: VEC3 sscanf() failed to read 3 floats ('angle' key bug?)\n");
				}
				((float *)(b+vehWeaponFields[i].ofs))[0] = vec[0];
				((float *)(b+vehWeaponFields[i].ofs))[1] = vec[1];
				((float *)(b+vehWeaponFields[i].ofs))[2] = vec[2];
				break;
			case VF_BOOL:
				*(qboolean *)(b+vehicleFields[i].ofs) = (qboolean)(atof(value)!=0);
				break;
			case VF_VEHTYPE:
				vehType = (vehicleType_t)GetIDForString( VehicleTable, value );
				*(vehicleType_t *)(b+vehicleFields[i].ofs) = vehType;
				break;
			case VF_ANIM:
				{
					int anim = GetIDForString( animTable, value );
					*(int *)(b+vehicleFields[i].ofs) = anim;
				}
				break;
			case VF_WEAPON:	// take string, resolve into index into VehWeaponParms
				*(int *)(b+vehicleFields[i].ofs) = VEH_VehWeaponIndexForName( value );
				break;
			case VF_MODEL:	// take the string, get the G_ModelIndex
#ifdef QAGAME
				*(int *)(b+vehicleFields[i].ofs) = G_ModelIndex( value );
#else
				*(int *)(b+vehicleFields[i].ofs) = trap_R_RegisterModel( value );
#endif
				break;
			case VF_MODEL_CLIENT:	// (MP cgame only) take the string, get the G_ModelIndex
#ifndef _JK2MP
				*(int *)(b+vehicleFields[i].ofs) = G_ModelIndex( value );
#elif QAGAME
				//*(int *)(b+vehicleFields[i].ofs) = G_ModelIndex( value );
#else
				*(int *)(b+vehicleFields[i].ofs) = trap_R_RegisterModel( value );
#endif
				break;
			case VF_EFFECT:	// take the string, get the G_EffectIndex
#ifdef QAGAME
				*(int *)(b+vehicleFields[i].ofs) = G_EffectIndex( value );
#elif CGAME
				*(int *)(b+vehicleFields[i].ofs) = trap_FX_RegisterEffect( value );
#endif
				break;
			case VF_EFFECT_CLIENT:	// (MP cgame only) take the string, get the G_EffectIndex
#ifndef _JK2MP
				*(int *)(b+vehicleFields[i].ofs) = G_EffectIndex( value );
#elif QAGAME
				//*(int *)(b+vehicleFields[i].ofs) = G_EffectIndex( value );
#elif CGAME
				*(int *)(b+vehicleFields[i].ofs) = trap_FX_RegisterEffect( value );
#endif
				break;
			case VF_SHADER:	// (cgame only) take the string, call trap_R_RegisterShader
#ifdef WE_ARE_IN_THE_UI
				*(int *)(b+vehicleFields[i].ofs) = trap_R_RegisterShaderNoMip( value );
#elif CGAME
				*(int *)(b+vehicleFields[i].ofs) = trap_R_RegisterShader( value );
#endif
				break;
			case VF_SHADER_NOMIP:// (cgame only) take the string, call trap_R_RegisterShaderNoMip
#ifndef QAGAME
				*(int *)(b+vehicleFields[i].ofs) = trap_R_RegisterShaderNoMip( value );
#endif
				break;
			case VF_SOUND:	// take the string, get the G_SoundIndex
#ifdef QAGAME
				*(int *)(b+vehicleFields[i].ofs) = G_SoundIndex( value );
#else
				*(int *)(b+vehicleFields[i].ofs) = trap_S_RegisterSound( value );
#endif
				break;
			case VF_SOUND_CLIENT:	// (MP cgame only) take the string, get the G_SoundIndex
#ifndef _JK2MP
				*(int *)(b+vehicleFields[i].ofs) = G_SoundIndex( value );
#elif QAGAME
				//*(int *)(b+vehicleFields[i].ofs) = G_SoundIndex( value );
#else
				*(int *)(b+vehicleFields[i].ofs) = trap_S_RegisterSound( value );
#endif
				break;
			default:
				//Unknown type?
				return qfalse;
				break;
			}
			break;
		}
	}
	if ( vehicleFields[i].ofs == -1 )
	{
        return qfalse;
	}
	else
	{
		return qtrue;
	}
}

int VEH_LoadVehicle( const char *vehicleName )
{//load up specified vehicle and save in array: g_vehicleInfo
	const char	*token;
	//we'll assume that no parm name is longer than 128
	char		parmName[128] = { 0 };
	char		weap1[128] = { 0 }, weap2[128] = { 0 };
	char		weapMuzzle1[128] = { 0 };
	char		weapMuzzle2[128] = { 0 };
	char		weapMuzzle3[128] = { 0 };
	char		weapMuzzle4[128] = { 0 };
	char		weapMuzzle5[128] = { 0 };
	char		weapMuzzle6[128] = { 0 };
	char		weapMuzzle7[128] = { 0 };
	char		weapMuzzle8[128] = { 0 };
	char		weapMuzzle9[128] = { 0 };
	char		weapMuzzle10[128] = { 0 };
	char		*value = NULL;
	const char	*p = NULL;
	vehicleInfo_t	*vehicle = NULL;

	// Load the vehicle parms if no vehicles have been loaded yet.
	if ( numVehicles == 0 ) 
	{
		BG_VehicleLoadParms();
	}

	//try to parse data out
	p = VehicleParms;

#ifdef _JK2MP
	COM_BeginParseSession("vehicles");
#else
	COM_BeginParseSession();
#endif

	vehicle = &g_vehicleInfo[numVehicles];
	// look for the right vehicle
	while ( p ) 
	{
		token = COM_ParseExt( &p, qtrue );
		if ( token[0] == 0 )
		{
			return VEHICLE_NONE;
		}

		if ( !Q_stricmp( token, vehicleName ) ) 
		{
			break;
		}

		SkipBracedSection( &p );
	}

	if ( !p )
	{
		return VEHICLE_NONE;
	}

	token = COM_ParseExt( &p, qtrue );
	if ( token[0] == 0 )
	{//barf
		return VEHICLE_NONE;
	}

	if ( Q_stricmp( token, "{" ) != 0 ) 
	{
		return VEHICLE_NONE;
	}
	
	BG_VehicleSetDefaults( vehicle );
	// parse the vehicle info block
	while ( 1 ) 
	{
		SkipRestOfLine( &p );
		token = COM_ParseExt( &p, qtrue );
		if ( !token[0] ) 
		{
			Com_Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing Vehicle '%s'\n", vehicleName );
			return VEHICLE_NONE;
		}

		if ( !Q_stricmp( token, "}" ) ) 
		{
			break;
		}
		Q_strncpyz( parmName, token, sizeof(parmName) );
		value = COM_ParseExt( &p, qtrue );
		if ( !value || !value[0] )
		{
			Com_Printf( S_COLOR_RED"ERROR: Vehicle token '%s' has no value!\n", parmName );
		}
		else if ( Q_stricmp( "weap1", parmName ) == 0 )
		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
			Q_strncpyz( weap1, value, sizeof(weap1) );
		}
		else if ( Q_stricmp( "weap2", parmName ) == 0 )
		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
			Q_strncpyz( weap2, value, sizeof(weap2) );
		}
		else if ( Q_stricmp( "weapMuzzle1", parmName ) == 0 )
		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
			Q_strncpyz( weapMuzzle1, value, sizeof(weapMuzzle1) );
		}
		else if ( Q_stricmp( "weapMuzzle2", parmName ) == 0 )
		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
			Q_strncpyz( weapMuzzle2, value, sizeof(weapMuzzle2) );
		}
		else if ( Q_stricmp( "weapMuzzle3", parmName ) == 0 )
		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
			Q_strncpyz( weapMuzzle3, value, sizeof(weapMuzzle3) );
		}
		else if ( Q_stricmp( "weapMuzzle4", parmName ) == 0 )
		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
			Q_strncpyz( weapMuzzle4, value, sizeof(weapMuzzle4) );
		}
		else if ( Q_stricmp( "weapMuzzle5", parmName ) == 0 )
		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
			Q_strncpyz( weapMuzzle5, value, sizeof(weapMuzzle5) );
		}
		else if ( Q_stricmp( "weapMuzzle6", parmName ) == 0 )
		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
			Q_strncpyz( weapMuzzle6, value, sizeof(weapMuzzle6) );
		}
		else if ( Q_stricmp( "weapMuzzle7", parmName ) == 0 )
		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
			Q_strncpyz( weapMuzzle7, value, sizeof(weapMuzzle7) );
		}
		else if ( Q_stricmp( "weapMuzzle8", parmName ) == 0 )
		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
			Q_strncpyz( weapMuzzle8, value, sizeof(weapMuzzle8) );
		}
		else if ( Q_stricmp( "weapMuzzle9", parmName ) == 0 )
		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
			Q_strncpyz( weapMuzzle9, value, sizeof(weapMuzzle9) );
		}
		else if ( Q_stricmp( "weapMuzzle10", parmName ) == 0 )
		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
			Q_strncpyz( weapMuzzle10, value, sizeof(weapMuzzle10) );
		}
		else
		{
			if ( !BG_ParseVehicleParm( vehicle, parmName, value ) )
			{
#ifndef FINAL_BUILD
				Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair '%s', '%s'!\n", parmName, value );
#endif
			}
		}
	}
	//NOW: if we have any weapons, go ahead and load them
	if ( weap1[0] )
	{
		if ( !BG_ParseVehicleParm( vehicle, "weap1", weap1 ) )
		{
#ifndef FINAL_BUILD
			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weap1', '%s'!\n", weap1 );
#endif
		}
	}
	if ( weap2[0] )
	{
		if ( !BG_ParseVehicleParm( vehicle, "weap2", weap2 ) )
		{
#ifndef FINAL_BUILD
			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weap2', '%s'!\n", weap2 );
#endif
		}
	}
	if ( weapMuzzle1[0] )
	{
		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle1", weapMuzzle1 ) )
		{
#ifndef FINAL_BUILD
			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle1', '%s'!\n", weapMuzzle1 );
#endif
		}
	}
	if ( weapMuzzle2[0] )
	{
		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle2", weapMuzzle2 ) )
		{
#ifndef FINAL_BUILD
			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle2', '%s'!\n", weapMuzzle2 );
#endif
		}
	}
	if ( weapMuzzle3[0] )
	{
		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle3", weapMuzzle3 ) )
		{
#ifndef FINAL_BUILD
			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle3', '%s'!\n", weapMuzzle3 );
#endif
		}
	}
	if ( weapMuzzle4[0] )
	{
		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle4", weapMuzzle4 ) )
		{
#ifndef FINAL_BUILD
			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle4', '%s'!\n", weapMuzzle4 );
#endif
		}
	}
	if ( weapMuzzle5[0] )
	{
		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle5", weapMuzzle5 ) )
		{
#ifndef FINAL_BUILD
			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle5', '%s'!\n", weapMuzzle5 );
#endif
		}
	}
	if ( weapMuzzle6[0] )
	{
		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle6", weapMuzzle6 ) )
		{
#ifndef FINAL_BUILD
			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle6', '%s'!\n", weapMuzzle6 );
#endif
		}
	}
	if ( weapMuzzle7[0] )
	{
		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle7", weapMuzzle7 ) )
		{
#ifndef FINAL_BUILD
			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle7', '%s'!\n", weapMuzzle7 );
#endif
		}
	}
	if ( weapMuzzle8[0] )
	{
		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle8", weapMuzzle8 ) )
		{
#ifndef FINAL_BUILD
			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle8', '%s'!\n", weapMuzzle8 );
#endif
		}
	}
	if ( weapMuzzle9[0] )
	{
		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle9", weapMuzzle9 ) )
		{
#ifndef FINAL_BUILD
			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle9', '%s'!\n", weapMuzzle9 );
#endif
		}
	}
	if ( weapMuzzle10[0] )
	{
		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle10", weapMuzzle10 ) )
		{
#ifndef FINAL_BUILD
			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle10', '%s'!\n", weapMuzzle10 );
#endif
		}
	}

#ifdef _JK2MP
	//let's give these guys some defaults
	if (!vehicle->health_front)
	{
		vehicle->health_front = vehicle->armor/4;
	}
	if (!vehicle->health_back)
	{
		vehicle->health_back = vehicle->armor/4;
	}
	if (!vehicle->health_right)
	{
		vehicle->health_right = vehicle->armor/4;
	}
	if (!vehicle->health_left)
	{
		vehicle->health_left = vehicle->armor/4;
	}
#endif

	if ( vehicle->model )
	{
#ifdef QAGAME
		vehicle->modelIndex = G_ModelIndex( va( "models/players/%s/model.glm", vehicle->model ) );
#else
		vehicle->modelIndex = trap_R_RegisterModel( va( "models/players/%s/model.glm", vehicle->model ) );
#endif
	}

#ifndef _JK2MP
	//SP
	if ( vehicle->skin
		&& vehicle->skin[0] )
	{
		ratl::string_vs<256>			skins(vehicle->skin);
		for (ratl::string_vs<256>::tokenizer i = skins.begin("|"); i!=skins.end(); i++)
		{
			//this will just turn off surfs if there is a *off shader on a surf, the skin will actually get thrown away when cgame starts
			gi.RE_RegisterSkin( va( "models/players/%s/model_%s.skin", vehicle->model, *i) );
			//this is for the server-side call, it will propgate down to cgame with configstrings and register it at the same time as all the other skins for ghoul2 models
			G_SkinIndex( va( "models/players/%s/model_%s.skin", vehicle->model, *i) );
		}
	}
	else
	{
		//this will just turn off surfs if there is a *off shader on a surf, the skin will actually get thrown away when cgame starts
		gi.RE_RegisterSkin( va( "models/players/%s/model_default.skin", vehicle->model) );
		//this is for the server-side call, it will propgate down to cgame with configstrings and register it at the same time as all the other skins for ghoul2 models
		G_SkinIndex( va( "models/players/%s/model_default.skin", vehicle->model) );
	}
#else
#ifndef QAGAME
	if ( vehicle->skin
		&& vehicle->skin[0] )
	{
		trap_R_RegisterSkin( va( "models/players/%s/model_%s.skin", vehicle->model, vehicle->skin) );
	}
#endif
#endif
	//sanity check and clamp the vehicle's data
	BG_VehicleClampData( vehicle );
	// Setup the shared function pointers.
	BG_SetSharedVehicleFunctions( vehicle );
	//misc effects... FIXME: not even used in MP, are they?
	if ( vehicle->explosionDamage )
	{
#ifdef QAGAME
		G_EffectIndex( "ships/ship_explosion_mark" );
#elif CGAME
		trap_FX_RegisterEffect( "ships/ship_explosion_mark" );
#endif
	}
	if ( vehicle->flammable )
	{
#ifdef QAGAME
		G_SoundIndex( "sound/vehicles/common/fire_lp.wav" );
#elif CGAME
		trap_S_RegisterSound( "sound/vehicles/common/fire_lp.wav" );
#else
		trap_S_RegisterSound( "sound/vehicles/common/fire_lp.wav" );
#endif
	}

	if ( vehicle->hoverHeight > 0 )
	{
#ifndef _JK2MP
		G_EffectIndex( "ships/swoop_dust" );
#elif QAGAME
		G_EffectIndex( "ships/swoop_dust" );
#elif CGAME
		trap_FX_RegisterEffect( "ships/swoop_dust" );
#endif
	}

#ifdef QAGAME
	G_EffectIndex( "volumetric/black_smoke" );
	G_EffectIndex( "ships/fire" );
	G_SoundIndex( "sound/vehicles/common/release.wav" );
#elif CGAME
	trap_R_RegisterShader( "gfx/menus/radar/bracket" );
	trap_R_RegisterShaderNoMip( "gfx/menus/radar/asteroid" );
	trap_S_RegisterSound( "sound/vehicles/common/impactalarm.wav" );
	trap_S_RegisterSound( "sound/vehicles/common/linkweaps.wav" );
	trap_S_RegisterSound( "sound/vehicles/common/release.wav" );
	trap_FX_RegisterEffect("effects/ships/dest_burning.efx");
	trap_FX_RegisterEffect("effects/ships/dest_destroyed.efx");
	trap_FX_RegisterEffect( "volumetric/black_smoke" );
	trap_FX_RegisterEffect( "ships/fire" );
	trap_FX_RegisterEffect("ships/hyperspace_stars");

	if ( vehicle->hideRider )
	{
		trap_R_RegisterShaderNoMip( "gfx/menus/radar/circle_base" );
		trap_R_RegisterShaderNoMip( "gfx/menus/radar/circle_base_frame" );
		trap_R_RegisterShaderNoMip( "gfx/menus/radar/circle_base_shield" );
	}
#endif

	return (numVehicles++);
}

int VEH_VehicleIndexForName( const char *vehicleName )
{
	int v;
	if ( !vehicleName || !vehicleName[0] )
	{
		Com_Printf( S_COLOR_RED"ERROR: Trying to read Vehicle with no name!\n" );
		return VEHICLE_NONE;
	}
	for (  v = VEHICLE_BASE; v < numVehicles; v++ )
	{
		if ( g_vehicleInfo[v].name
			&& Q_stricmp( g_vehicleInfo[v].name, vehicleName ) == 0 )
		{//already loaded this one
			return v;
		}
	}
	//haven't loaded it yet
	if ( v >= MAX_VEHICLES )
	{//no more room!
		Com_Printf( S_COLOR_RED"ERROR: Too many Vehicles (max 64), aborting load on %s!\n", vehicleName );
		return VEHICLE_NONE;
	}
	//we have room for another one, load it up and return the index
	//HMM... should we not even load the .veh file until we want to?
	v = VEH_LoadVehicle( vehicleName ); 
 	if ( v == VEHICLE_NONE )
	{
		Com_Printf( S_COLOR_RED"ERROR: Could not find Vehicle %s!\n", vehicleName );
	}
	return v;
}

void BG_VehWeaponLoadParms( void ) 
{
	int			len, totallen, vehExtFNLen, mainBlockLen, fileCnt, i;
	char		*holdChar, *marker;
	char		vehWeaponExtensionListBuf[2048];			//	The list of file names read in
	fileHandle_t	f;
	char		*tempReadBuffer;

	len = 0;

	//remember where to store the next one
	totallen = mainBlockLen = len;
	marker = VehWeaponParms+totallen;
	*marker = 0;

	//now load in the extra .veh extensions
#ifdef _JK2MP
	fileCnt = trap_FS_GetFileList("ext_data/vehicles/weapons", ".vwp", vehWeaponExtensionListBuf, sizeof(vehWeaponExtensionListBuf) );
#else
	fileCnt = gi.FS_GetFileList("ext_data/vehicles/weapons", ".vwp", vehWeaponExtensionListBuf, sizeof(vehWeaponExtensionListBuf) );
#endif

	holdChar = vehWeaponExtensionListBuf;

#ifdef _JK2MP
	tempReadBuffer = (char *)BG_TempAlloc(MAX_VEH_WEAPON_DATA_SIZE);
#else
	tempReadBuffer = (char *)gi.Malloc( MAX_VEH_WEAPON_DATA_SIZE, TAG_G_ALLOC, qtrue );
#endif
	
	// NOTE: Not use TempAlloc anymore...
	//Make ABSOLUTELY CERTAIN that BG_Alloc/etc. is not used before
	//the subsequent BG_TempFree or the pool will be screwed. 

	for ( i = 0; i < fileCnt; i++, holdChar += vehExtFNLen + 1 ) 
	{
		vehExtFNLen = strlen( holdChar );

//		Com_Printf( "Parsing %s\n", holdChar );

#ifdef _JK2MP
		len = trap_FS_FOpenFile(va( "ext_data/vehicles/weapons/%s", holdChar), &f, FS_READ);
#else
//		len = gi.FS_ReadFile( va( "ext_data/vehicles/weapons/%s", holdChar), (void **) &buffer );
		len = gi.FS_FOpenFile(va( "ext_data/vehicles/weapons/%s", holdChar), &f, FS_READ);
#endif

		if ( len == -1 ) 
		{
			Com_Printf( "error reading file\n" );
		}
		else
		{
#ifdef _JK2MP
			trap_FS_Read(tempReadBuffer, len, f);
			tempReadBuffer[len] = 0;
#else
			gi.FS_Read(tempReadBuffer, len, f);
			tempReadBuffer[len] = 0;
#endif

			// Don't let it end on a } because that should be a stand-alone token.
			if ( totallen && *(marker-1) == '}' )
			{
				strcat( marker, " " );
				totallen++;
				marker++; 
			}

			if ( totallen + len >= MAX_VEH_WEAPON_DATA_SIZE ) {
				Com_Error(ERR_DROP, "Vehicle Weapon extensions (*.vwp) are too large" );
			}
			strcat( marker, tempReadBuffer );
#ifdef _JK2MP
			trap_FS_FCloseFile( f );
#else
			gi.FS_FCloseFile( f );
#endif

			totallen += len;
			marker = VehWeaponParms+totallen;
		}
	}

#ifdef _JK2MP
	BG_TempFree(MAX_VEH_WEAPON_DATA_SIZE);
#else
	gi.Free(tempReadBuffer);	tempReadBuffer = NULL;
#endif
}

void BG_VehicleLoadParms( void ) 
{//HMM... only do this if there's a vehicle on the level?
	int			len, totallen, vehExtFNLen, mainBlockLen, fileCnt, i;
//	const char	*filename = "ext_data/vehicles.dat";
	char		*holdChar, *marker;
	char		vehExtensionListBuf[2048];			//	The list of file names read in
	fileHandle_t	f;
	char		*tempReadBuffer;

	len = 0;

	//remember where to store the next one
	totallen = mainBlockLen = len;
	marker = VehicleParms+totallen;
	*marker = 0;

	//now load in the extra .veh extensions
#ifdef _JK2MP
	fileCnt = trap_FS_GetFileList("ext_data/vehicles", ".veh", vehExtensionListBuf, sizeof(vehExtensionListBuf) );
#else
	fileCnt = gi.FS_GetFileList("ext_data/vehicles", ".veh", vehExtensionListBuf, sizeof(vehExtensionListBuf) );
#endif

	holdChar = vehExtensionListBuf;

#ifdef _JK2MP
	tempReadBuffer = (char *)BG_TempAlloc(MAX_VEHICLE_DATA_SIZE);
#else
	tempReadBuffer = (char *)gi.Malloc( MAX_VEHICLE_DATA_SIZE, TAG_G_ALLOC, qtrue );
#endif
	
	// NOTE: Not use TempAlloc anymore...
	//Make ABSOLUTELY CERTAIN that BG_Alloc/etc. is not used before
	//the subsequent BG_TempFree or the pool will be screwed. 

	for ( i = 0; i < fileCnt; i++, holdChar += vehExtFNLen + 1 ) 
	{
		vehExtFNLen = strlen( holdChar );

//		Com_Printf( "Parsing %s\n", holdChar );

#ifdef _JK2MP
		len = trap_FS_FOpenFile(va( "ext_data/vehicles/%s", holdChar), &f, FS_READ);
#else
//		len = gi.FS_ReadFile( va( "ext_data/vehicles/%s", holdChar), (void **) &buffer );
		len = gi.FS_FOpenFile(va( "ext_data/vehicles/%s", holdChar), &f, FS_READ);
#endif

		if ( len == -1 ) 
		{
			Com_Printf( "error reading file\n" );
		}
		else
		{
#ifdef _JK2MP
			trap_FS_Read(tempReadBuffer, len, f);
			tempReadBuffer[len] = 0;
#else
			gi.FS_Read(tempReadBuffer, len, f);
			tempReadBuffer[len] = 0;
#endif

			// Don't let it end on a } because that should be a stand-alone token.
			if ( totallen && *(marker-1) == '}' )
			{
				strcat( marker, " " );
				totallen++;
				marker++; 
			}

			if ( totallen + len >= MAX_VEHICLE_DATA_SIZE ) {
				Com_Error(ERR_DROP, "Vehicle extensions (*.veh) are too large" );
			}
			strcat( marker, tempReadBuffer );
#ifdef _JK2MP
			trap_FS_FCloseFile( f );
#else
			gi.FS_FCloseFile( f );
#endif

			totallen += len;
			marker = VehicleParms+totallen;
		}
	}

#ifdef _JK2MP
	BG_TempFree(MAX_VEHICLE_DATA_SIZE);
#else
	gi.Free(tempReadBuffer);	tempReadBuffer = NULL;
#endif
	
	numVehicles = 1;//first one is null/default
	//set the first vehicle to default data
	BG_VehicleSetDefaults( &g_vehicleInfo[VEHICLE_BASE] );
	//sanity check and clamp the vehicle's data
	BG_VehicleClampData( &g_vehicleInfo[VEHICLE_BASE] );
	// Setup the shared function pointers.
	BG_SetSharedVehicleFunctions( &g_vehicleInfo[VEHICLE_BASE] );

	//Load the Vehicle Weapons data, too
	BG_VehWeaponLoadParms();
}

int BG_VehicleGetIndex( const char *vehicleName )
{
	return (VEH_VehicleIndexForName( vehicleName ));
}

//We get the vehicle name passed in as modelname
//with a $ in front of it.
//we are expected to then get the model for the
//vehicle and stomp over modelname with it.
void BG_GetVehicleModelName(char *modelname)
{
	char *vehName = &modelname[1];
	int vIndex = BG_VehicleGetIndex(vehName);
	assert(modelname[0] == '$');
	
	if (vIndex == VEHICLE_NONE)
	{
		Com_Error(ERR_DROP, "BG_GetVehicleModelName:  couldn't find vehicle %s", vehName);
	}

    strcpy(modelname, g_vehicleInfo[vIndex].model);	
}

void BG_GetVehicleSkinName(char *skinname)
{
	char *vehName = &skinname[1];
	int vIndex = BG_VehicleGetIndex(vehName);
	assert(skinname[0] == '$');
	
	if (vIndex == VEHICLE_NONE)
	{
		Com_Error(ERR_DROP, "BG_GetVehicleSkinName:  couldn't find vehicle %s", vehName);
	}

    if ( !g_vehicleInfo[vIndex].skin 
		|| !g_vehicleInfo[vIndex].skin[0] )
	{
		skinname[0] = 0;
	}
	else
	{
		strcpy(skinname, g_vehicleInfo[vIndex].skin);	
	}
}

#ifdef _JK2MP
#ifndef WE_ARE_IN_THE_UI
//so cgame can assign the function pointer for the vehicle attachment without having to
//bother with all the other funcs that don't really exist cgame-side.
extern int BG_GetTime(void);
extern int trap_G2API_AddBolt(void *ghoul2, int modelIndex, const char *boneName);
extern qboolean trap_G2API_GetBoltMatrix(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
void AttachRidersGeneric( Vehicle_t *pVeh )
{
	// If we have a pilot, attach him to the driver tag.
	if ( pVeh->m_pPilot )
	{
		mdxaBone_t boltMatrix;
		vec3_t	yawOnlyAngles;
		bgEntity_t *parent = pVeh->m_pParentEntity;
		bgEntity_t *pilot = pVeh->m_pPilot;
		int crotchBolt = trap_G2API_AddBolt(parent->ghoul2, 0, "*driver");

		assert(parent->playerState);

		VectorSet(yawOnlyAngles, 0, parent->playerState->viewangles[YAW], 0);

		// Get the driver tag.
		trap_G2API_GetBoltMatrix( parent->ghoul2, 0, crotchBolt, &boltMatrix,
								yawOnlyAngles, parent->playerState->origin,
								BG_GetTime(), NULL, parent->modelScale );
		BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, pilot->playerState->origin );
	}
}
#endif

#include "../namespace_end.h"

#endif // _JK2MP