jedi-academy/code/game/g_vehicles.h

#ifndef __G_VEHICLES_H
#define __G_VEHICLES_H

#include "q_shared.h"
#include "g_public.h"			   

typedef enum
{
	VH_NONE = 0,
	VH_WALKER,		//something you ride inside of, it walks like you, like an AT-ST
	VH_FIGHTER,		//something you fly inside of, like an X-Wing or TIE fighter
	VH_SPEEDER,		//something you ride on that hovers, like a speeder or swoop
	VH_ANIMAL,		//animal you ride on top of that walks, like a tauntaun
	VH_FLIER,		//animal you ride on top of that flies, like a giant mynoc?
	VH_NUM_VEHICLES
} vehicleType_t;

enum	EWeaponPose
{
	WPOSE_NONE	= 0,
	WPOSE_BLASTER,
	WPOSE_SABERLEFT,
	WPOSE_SABERRIGHT,
};

extern stringID_table_t VehicleTable[VH_NUM_VEHICLES+1];

#define NO_PILOT_DIE_TIME 10000

//===========================================================================================================
//START VEHICLE WEAPONS
//===========================================================================================================
typedef struct
{
//*** IMPORTANT!!! *** the number of variables in the vehWeaponStats_t struct (including all elements of arrays) must be reflected by NUM_VWEAP_PARMS!!!
//*** IMPORTANT!!! *** vWeapFields table correponds to this structure!
	char	*name;
	qboolean	bIsProjectile;	//traceline or entity?
	qboolean	bHasGravity;	//if a projectile, drops
	qboolean	bIonWeapon;//disables ship shields and sends them out of control
	qboolean	bSaberBlockable;//lightsabers can deflect this projectile
	int		iMuzzleFX;	//index of Muzzle Effect
	int		iModel;		//handle to the model used by this projectile
	int		iShotFX;	//index of Shot Effect
	int		iImpactFX;	//index of Impact Effect
	int		iG2MarkShaderHandle;	//index of shader to use for G2 marks made on other models when hit by this projectile
	float	fG2MarkSize;//size (diameter) of the ghoul2 mark
	int		iLoopSound;	//index of loopSound
	float	fSpeed;		//speed of projectile/range of traceline
	float	fHoming;		//0.0 = not homing, 0.5 = half vel to targ, half cur vel, 1.0 = all vel to targ
	float	fHomingFOV;
	int		iLockOnTime;	//0 = no lock time needed, else # of ms needed to lock on
	int		iDamage;		//damage done when traceline or projectile directly hits target
	int		iSplashDamage;//damage done to ents in splashRadius of end of traceline or projectile origin on impact
	float	fSplashRadius;//radius that ent must be in to take splashDamage (linear fall-off)
	int		iAmmoPerShot;	//how much "ammo" each shot takes
	int		iHealth;		//if non-zero, projectile can be shot, takes this much damage before being destroyed
	float	fWidth;		//width of traceline or bounding box of projecile (non-rotating!)
	float	fHeight;		//height of traceline or bounding box of projecile (non-rotating!)
	int		iLifeTime;	//removes itself after this amount of time
	qboolean	bExplodeOnExpire;	//when iLifeTime is up, explodes rather than simply removing itself
} vehWeaponInfo_t;
//NOTE: this MUST stay up to date with the number of variables in the vehFields table!!!
#define NUM_VWEAP_PARMS	25

#define	VWFOFS(x) ((size_t)&(((vehWeaponInfo_t *)0)->x))

#define MAX_VEH_WEAPONS	16	//sigh... no more than 16 different vehicle weapons
#define VEH_WEAPON_BASE	0
#define VEH_WEAPON_NONE	-1

extern vehWeaponInfo_t g_vehWeaponInfo[MAX_VEH_WEAPONS];
extern int	numVehicleWeapons;

//===========================================================================================================
//END VEHICLE WEAPONS
//===========================================================================================================

// The maximum number of muzzles a vehicle may have.
#define		MAX_VEHICLE_MUZZLES			10

// The maximum number of exhausts a vehicle may have.
#define		MAX_VEHICLE_EXHAUSTS		4

// The maxiumum number of different weapons a vehicle may have
#define		MAX_VEHICLE_WEAPONS			2
#define		MAX_VEHICLE_TURRETS			2
#define		MAX_VEHICLE_TURRET_MUZZLES	2

typedef struct
{
	int			iWeapon;	//what vehWeaponInfo index to use
	int			iDelay;		//delay between turret muzzle shots
	int			iAmmoMax;	//how much ammo it has
	int			iAmmoRechargeMS;	//how many MS between every point of recharged ammo
	char		*yawBone;	//bone on ship that this turret uses to yaw
	char		*pitchBone;	//bone on ship that this turret uses to pitch
	int			yawAxis;	//axis on yawBone to which we should to apply the yaw angles
	int			pitchAxis;	//axis on pitchBone to which we should to apply the pitch angles
	float		yawClampLeft;	//how far the turret is allowed to turn left
	float		yawClampRight;	//how far the turret is allowed to turn right
	float		pitchClampUp;	//how far the turret is allowed to title up
	float		pitchClampDown; //how far the turret is allowed to tilt down
	int			iMuzzle[MAX_VEHICLE_TURRET_MUZZLES];//iMuzzle-1 = index of ship's muzzle to fire this turret's 1st and 2nd shots from
	char		*gunnerViewTag;//Where to put the view origin of the gunner (name)
	float		fTurnSpeed;	//how quickly the turret can turn
	qboolean	bAI;	//whether or not the turret auto-targets enemies when it's not manned
	qboolean	bAILead;//whether
	float		fAIRange;	//how far away the AI will look for enemies
	int			passengerNum;//which passenger, if any, has control of this turret (overrides AI)
} turretStats_t;

typedef struct
{
//*** IMPORTANT!!! *** See note at top of next structure!!! ***
	// Weapon stuff.
	int			ID;//index into the weapon data
	// The delay between shots for each weapon.
	int			delay;
	// Whether or not all the muzzles for each weapon can be linked together (linked delay = weapon delay * number of muzzles linked!)
	int			linkable;
	// Whether or not to auto-aim the projectiles/tracelines at the thing under the crosshair when we fire
	qboolean	aimCorrect;
	//maximum ammo
	int			ammoMax;
	//ammo recharge rate - milliseconds per unit (minimum of 100, which is 10 ammo per second)
	int			ammoRechargeMS;
	//sound to play when out of ammo (plays default "no ammo" sound if none specified)
	int			soundNoAmmo;
} vehWeaponStats_t;

// Compiler pre-define.
struct Vehicle_t;

typedef struct
{
//*** IMPORTANT!!! *** vehFields table correponds to this structure!
	char		*name;	//unique name of the vehicle

	//general data
	vehicleType_t	type;	//what kind of vehicle
	int			numHands;	//if 2 hands, no weapons, if 1 hand, can use 1-handed weapons, if 0 hands, can use 2-handed weapons
	float		lookPitch;	//How far you can look up and down off the forward of the vehicle
	float		lookYaw;	//How far you can look left and right off the forward of the vehicle
	float		length;		//how long it is - used for body length traces when turning/moving?
	float		width;		//how wide it is - used for body length traces when turning/moving?
	float		height;		//how tall it is - used for body length traces when turning/moving?
	vec3_t		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
	float		speedMax;		//top speed
	float		turboSpeed;		//turbo speed
	float		speedMin;		//if < 0, can go in reverse
	float		speedIdle;		//what speed it drifts to when no accel/decel input is given
	float		accelIdle;		//if speedIdle > 0, how quickly it goes up to that speed
	float		acceleration;	//when pressing on accelerator
	float		decelIdle;		//when giving no input, how quickly it drops to speedIdle
	float		throttleSticks;	//if true, speed stays at whatever you accel/decel to, unless you turbo or brake
	float		strafePerc;		//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
	float		bankingSpeed;	//how quickly it pitches and rolls (not under player control)
	float		rollLimit;		//how far it can roll to either side
	float		pitchLimit;		//how far it can roll forward or backward
	float		braking;		//when pressing on decelerator
	float		mouseYaw;		// The mouse yaw override.
	float		mousePitch;		// The mouse pitch override.
	float		turningSpeed;	//how quickly you can turn
	qboolean	turnWhenStopped;//whether or not you can turn when not moving
	float		traction;		//how much your command input affects velocity
	float		friction;		//how much velocity is cut on its own
	float		maxSlope;		//the max slope that it can go up with control
	qboolean	speedDependantTurning;//vehicle turns faster the faster it's going

	//durability stats
	int			mass;			//for momentum and impact force (player mass is 10)
	int			armor;			//total points of damage it can take
	int			shields;		//energy shield damage points
	int			shieldRechargeMS;//energy shield milliseconds per point recharged
	float		toughness;		//modifies incoming damage, 1.0 is normal, 0.5 is half, etc.  Simulates being made of tougher materials/construction
	int			malfunctionArmorLevel;//when armor drops to or below this point, start malfunctioning
	int			surfDestruction; //can parts of this thing be torn off on impact? -rww

	//individual "area" health -rww
	int			health_front;
	int			health_back;
	int			health_right;
	int			health_left;

	//visuals & sounds
	char		*model;			//what model to use - if make it an NPC's primary model, don't need this?
	char		*skin;			//what skin to use - if make it an NPC's primary model, don't need this?
	int			g2radius;		//render radius for the ghoul2 model
	int			riderAnim;		//what animation the rider uses
	int			radarIconHandle;//what icon to show on radar in MP
	char		*droidNPC;		//NPC to attach to *droidunit tag (if it exists in the model)

	int			soundOn;		//sound to play when get on it
	int			soundOff;		//sound to play when get off
	int			soundLoop;		//sound to loop while riding it
	int			soundTakeOff;	//sound to play when ship takes off
	int			soundEngineStart;//sound to play when ship's thrusters first activate
	int			soundSpin;		//sound to loop while spiraling out of control
	int			soundTurbo;		//sound to play when turbo/afterburner kicks in
	int			soundHyper;		//sound to play when ship lands
	int			soundLand;		//sound to play when ship lands
	int			soundFlyBy;		//sound to play when they buzz you
	int			soundFlyBy2;	//alternate sound to play when they buzz you
	int			soundShift1;	//sound to play when accelerating
	int			soundShift2;	//sound to play when accelerating
	int			soundShift3;	//sound to play when decelerating
	int			soundShift4;	//sound to play when decelerating

	int			iExhaustFX;		//exhaust effect, played from "*exhaust" bolt(s)
	int			iTurboFX;		//turbo exhaust effect, played from "*exhaust" bolt(s) when ship is in "turbo" mode
	int			iTurboStartFX;	//turbo begin effect, played from "*exhaust" bolts when "turbo" mode begins
	int			iTrailFX;		//trail effect, played from "*trail" bolt(s)
	int			iImpactFX;		//impact effect, for when it bumps into something
	int			iExplodeFX;		//explosion effect, for when it blows up (should have the sound built into explosion effect)
	int			iWakeFX;		//effect it makes when going across water
	int			iDmgFX;			//effect to play on damage from a weapon or something
	int			iArmorLowFX;	//played when armor is less than 30% of full
	int			iArmorGoneFX;	//played when on armor is completely gone
	
	//Weapon stats
	vehWeaponStats_t	weapon[MAX_VEHICLE_WEAPONS];

	// Which weapon a muzzle fires (has to match one of the weapons this vehicle has). So 1 would be weapon 1,
	// 2 would be weapon 2 and so on.
	int			weapMuzzle[MAX_VEHICLE_MUZZLES];

	//turrets (if any) on the vehicle
	turretStats_t	turret[MAX_VEHICLE_TURRETS];

	// The max height before this ship (?) starts (auto)landing.
	float landingHeight;

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

	int			maxPassengers;	// The max number of passengers this vehicle may have (Default = 0).
	qboolean	hideRider;		// rider (and passengers?) should not be drawn
	qboolean	killRiderOnDeath;//if rider is on vehicle when it dies, they should die
	qboolean	flammable;		//whether or not the vehicle should catch on fire before it explodes
	int			explosionDelay;	//how long the vehicle should be on fire/dying before it explodes
	//camera stuff
	qboolean	cameraOverride;	//whether or not to use all of the following 3rd person camera override values
	float		cameraRange;	//how far back the camera should be - normal is 80
	float		cameraVertOffset;//how high over the vehicle origin the camera should be - normal is 16
	float		cameraHorzOffset;//how far to left/right (negative/positive) of of the vehicle origin the camera should be - normal is 0
	float		cameraPitchOffset;//a modifier on the camera's pitch (up/down angle) to the vehicle - normal is 0
	float		cameraFOV;		//third person camera FOV, default is 80
	float		cameraAlpha;	//fade out the vehicle to this alpha (0.1-1.0f) if it's in the way of the crosshair
	qboolean	cameraPitchDependantVertOffset;//use the hacky AT-ST pitch dependant vertical offset

	//NOTE: some info on what vehicle weapon to use?  Like ATST or TIE bomber or TIE fighter or X-Wing...?

//===VEH_PARM_MAX========================================================================
//*** IMPORTANT!!! *** vehFields table correponds to this structure!

//THE FOLLOWING FIELDS are not in the vehFields table because they are internal variables, not read in from the .veh file
	int			modelIndex;		//set internally, not until this vehicle is spawned into the level

	// NOTE: Please note that most of this stuff has been converted from C++ classes to generic C.
	// This part of the structure is used to simulate inheritance for vehicles. The basic idea is that all vehicle use
	// this vehicle interface since they declare their own functions and assign the function pointer to the
	// corresponding function. Meanwhile, the base logic can still call the appropriate functions. In C++ talk all
	// of these functions (pointers) are pure virtuals and this is an abstract base class (although it cannot be
	// inherited from, only contained and reimplemented (through an object and a setup function respectively)). -AReis

	// Makes sure that the vehicle is properly animated.
	void (*AnimateVehicle)( Vehicle_t *pVeh );

	// Makes sure that the rider's in this vehicle are properly animated.
	void (*AnimateRiders)( Vehicle_t *pVeh );

	// Determine whether this entity is able to board this vehicle or not.
	bool (*ValidateBoard)( Vehicle_t *pVeh, gentity_t *pEnt );

	// Set the parent entity of this Vehicle NPC.
	void (*SetParent)( Vehicle_t *pVeh, gentity_t *pParentEntity );

	// Add a pilot to the vehicle.
	void (*SetPilot)( Vehicle_t *pVeh, gentity_t *pPilot );

	// Add a passenger to the vehicle (false if we're full).
	bool (*AddPassenger)( Vehicle_t *pVeh );

	// Animate the vehicle and it's riders.
	void (*Animate)( Vehicle_t *pVeh );

	// Board this Vehicle (get on). The first entity to board an empty vehicle becomes the Pilot.
	bool (*Board)( Vehicle_t *pVeh, gentity_t *pEnt );

	// Eject an entity from the vehicle.
	bool (*Eject)( Vehicle_t *pVeh, gentity_t *pEnt, qboolean forceEject );

	// Eject all the inhabitants of this vehicle.
	bool (*EjectAll)( Vehicle_t *pVeh );	

	// Start a delay until the vehicle dies.
	void (*StartDeathDelay)( Vehicle_t *pVeh, int iDelayTime );

	// Update death sequence.
	void (*DeathUpdate)( Vehicle_t *pVeh );
	
	// Register all the assets used by this vehicle.
	void (*RegisterAssets)( Vehicle_t *pVeh );
	
	// Initialize the vehicle (should be called by Spawn?).
	bool (*Initialize)( Vehicle_t *pVeh );

	// Like a think or move command, this updates various vehicle properties.
	bool (*Update)( Vehicle_t *pVeh, const usercmd_t *pUcmd );

	// Update the properties of a Rider (that may reflect what happens to the vehicle).
	//
	//	[return]		bool			True if still in vehicle, false if otherwise.
	bool (*UpdateRider)( Vehicle_t *pVeh, gentity_t *pRider, usercmd_t *pUcmd );

	// ProcessMoveCommands the Vehicle.
	void (*ProcessMoveCommands)( Vehicle_t *pVeh );

	// ProcessOrientCommands the Vehicle.
	void (*ProcessOrientCommands)( Vehicle_t *pVeh );
	
	// Attachs all the riders of this vehicle to their appropriate position/tag (*driver, *pass1, *pass2, whatever...).
	void (*AttachRiders)( Vehicle_t *pVeh );

	// Make someone invisible and un-collidable.
	void (*Ghost)( Vehicle_t *pVeh, gentity_t *pEnt );

	// Make someone visible and collidable.
	void (*UnGhost)( Vehicle_t *pVeh, gentity_t *pEnt );

	// Get the pilot of this vehicle.
	const gentity_t *(*GetPilot)( Vehicle_t *pVeh );

	// Whether this vehicle is currently inhabited (by anyone) or not.
	bool (*Inhabited)( Vehicle_t *pVeh );
} vehicleInfo_t;

#define	VFOFS(x) ((size_t)&(((vehicleInfo_t *)0)->x))

#define MAX_VEHICLES	16	//sigh... no more than 64 individual vehicles
extern vehicleInfo_t g_vehicleInfo[MAX_VEHICLES];
extern int	numVehicles;

// Load the function pointers for a vehicle into this shared vehicle info structure.
extern void G_SetSpeederVehicleFunctions( vehicleInfo_t *pVehInfo );
extern void G_SetAnimalVehicleFunctions( vehicleInfo_t *pVehInfo );
extern void G_SetFighterVehicleFunctions( vehicleInfo_t *pVehInfo );
extern void G_SetWalkerVehicleFunctions( vehicleInfo_t *pVehInfo );

// Setup the shared functions (one's that all vehicles would generally use).
extern void G_SetSharedVehicleFunctions( vehicleInfo_t *pVehInfo );

// Create/Allocate a new Animal Vehicle (initializing it as well).
extern void G_CreateSpeederNPC( Vehicle_t **pVeh, const char *strType );
extern void G_CreateAnimalNPC( Vehicle_t **pVeh, const char *strType );
extern void G_CreateFighterNPC( Vehicle_t **pVeh, const char *strType );
extern void G_CreateWalkerNPC( Vehicle_t **pVeh, const char *strType );

#define VEH_DEFAULT_SPEED_MAX		800.0f
#define VEH_DEFAULT_ACCEL			10.0f
#define VEH_DEFAULT_DECEL			10.0f
#define VEH_DEFAULT_STRAFE_PERC		0.5f
#define VEH_DEFAULT_BANKING_SPEED	0.5f
#define VEH_DEFAULT_ROLL_LIMIT		60.0f
#define VEH_DEFAULT_PITCH_LIMIT		90.0f
#define VEH_DEFAULT_BRAKING			10.0f
#define VEH_DEFAULT_TURNING_SPEED	1.0f
#define VEH_DEFAULT_TRACTION		8.0f
#define VEH_DEFAULT_FRICTION		1.0f
#define VEH_DEFAULT_MAX_SLOPE		0.85f
#define VEH_DEFAULT_MASS			200
#define VEH_DEFAULT_MAX_ARMOR		200
#define VEH_DEFAULT_TOUGHNESS		2.5f
#define VEH_DEFAULT_GRAVITY			800
#define VEH_DEFAULT_HOVER_HEIGHT	64.0f
#define VEH_DEFAULT_HOVER_STRENGTH	10.0f
#define VEH_DEFAULT_VISIBILITY		0
#define VEH_DEFAULT_LOUDNESS		0
#define VEH_DEFAULT_EXP_RAD			400.0f
#define VEH_DEFAULT_EXP_DMG			1000
#define VEH_MAX_PASSENGERS			10

#define VEH_MOUNT_THROW_LEFT		-5
#define	VEH_MOUNT_THROW_RIGHT		-6

#define MAX_STRAFE_TIME				2000.0f//FIXME: extern?
#define	MIN_LANDING_SPEED			200//equal to or less than this and close to ground = auto-slow-down to land
#define	MIN_LANDING_SLOPE			0.8f//must be pretty flat to land on the surf

#define VEHICLE_BASE				0
#define VEHICLE_NONE				-1

enum
{
	VEH_EJECT_LEFT, 
	VEH_EJECT_RIGHT, 
	VEH_EJECT_FRONT, 
	VEH_EJECT_REAR, 
	VEH_EJECT_TOP, 
	VEH_EJECT_BOTTOM
};

// Vehicle flags.
enum
{
	VEH_NONE = 0, VEH_FLYING = 0x00000001, VEH_CRASHING = 0x00000002,
	VEH_LANDING = 0x00000004, VEH_BUCKING = 0x00000010, VEH_WINGSOPEN = 0x00000020,
	VEH_GEARSOPEN = 0x00000040, VEH_SLIDEBREAKING = 0x00000080, VEH_SPINNING = 0x00000100,
	VEH_OUTOFCONTROL = 0x00000200,
	VEH_SABERINLEFTHAND = 0x00000400,
	VEH_STRAFERAM = 0x00000800,
	VEH_ACCELERATORON = 0x00001000,
	VEH_ARMORLOW = 0x00002000,
	VEH_ARMORGONE = 0x00004000
};
//externed functions
//extern void G_DriveVehicle( gentity_t *ent, gentity_t *vehEnt, char *vehicleName );
/*extern void G_VehicleStartExplosionDelay( gentity_t *self );
extern void VehicleExplosionDelay( gentity_t *self );
extern void G_VehicleRegisterAssets( int vehicleIndex );
extern void G_DriveATST( gentity_t *ent, gentity_t *atst );
extern void G_VehicleInitialize( gentity_t *vehEnt );*/
extern void G_VehicleSpawn( gentity_t *self );

// A vehicle weapon muzzle.
struct Muzzle
{
	// These are updated every frame and represent the current position and direction for the specific muzzle.
	vec3_t m_vMuzzlePos;
	vec3_t m_vMuzzleDir;

	// This is how long to wait before being able to fire a specific muzzle again. This is based on the firing rate
	// so that a firing rate of 10 rounds/sec would make this value initially 100 miliseconds. 
	int m_iMuzzleWait;

	// whether this Muzzle was just fired or not (reset at muzzle flash code).
	bool m_bFired;

};

//defines for impact damage surface stuff
#define	SHIPSURF_FRONT		1
#define	SHIPSURF_BACK		2
#define	SHIPSURF_RIGHT		3
#define	SHIPSURF_LEFT		4

#define	SHIPSURF_DAMAGE_FRONT_LIGHT		1
#define	SHIPSURF_DAMAGE_BACK_LIGHT		2
#define	SHIPSURF_DAMAGE_RIGHT_LIGHT		3
#define	SHIPSURF_DAMAGE_LEFT_LIGHT		4
#define	SHIPSURF_DAMAGE_FRONT_HEAVY		5
#define	SHIPSURF_DAMAGE_BACK_HEAVY		6
#define	SHIPSURF_DAMAGE_RIGHT_HEAVY		7
#define	SHIPSURF_DAMAGE_LEFT_HEAVY		8

//generic part bits
#define SHIPSURF_BROKEN_A	(1<<0) //gear 1
#define SHIPSURF_BROKEN_B	(1<<1) //gear 1
#define SHIPSURF_BROKEN_C	(1<<2) //wing 1
#define SHIPSURF_BROKEN_D	(1<<3) //wing 2
#define SHIPSURF_BROKEN_E	(1<<4) //wing 3
#define SHIPSURF_BROKEN_F	(1<<5) //wing 4

typedef struct
{
	//linked firing mode
	qboolean	linked;//weapon 1's muzzles are in linked firing mode
	//current weapon ammo
	int			ammo;
	//debouncer for ammo recharge
	int			lastAmmoInc;
	//which muzzle will fire next
	int			nextMuzzle;
} vehWeaponStatus_t;

typedef struct
{
	//current weapon ammo
	int			ammo;
	//debouncer for ammo recharge
	int			lastAmmoInc;
	//which muzzle will fire next
	int			nextMuzzle;
	//which entity they're after
	int			enemyEntNum;
	//how long to hold on to our current enemy
	int			enemyHoldTime;
} vehTurretStatus_t;

// This is the implementation of the vehicle interface and any of the other variables needed. This
// is what actually represents a vehicle. -AReis.
// !!!!!!!!!!!!!!!!!! loadsave affecting structure !!!!!!!!!!!!!!!!!!!!!!!
struct Vehicle_t
{
	// The entity who pilots/drives this vehicle.
	// NOTE: This is redundant (since m_pParentEntity->owner _should_ be the pilot). This makes things clearer though.
	gentity_t *m_pPilot;

	int m_iPilotTime; //if spawnflag to die without pilot and this < level.time then die.
	qboolean m_bHasHadPilot; //qtrue once the vehicle gets its first pilot

	//the droid unit NPC for this vehicle, if any
	gentity_t *m_pDroidUnit;

	// The entity from which this NPC comes from.
	gentity_t *m_pParentEntity;

	// If not zero, how long to wait before we can do anything with the vehicle (we're getting on still).
	// -1 = board from left, -2 = board from right, -3 = jump/quick board.  -4 & -5 = throw off existing pilot
	int		m_iBoarding;

	// Used to check if we've just started the boarding process
	bool	m_bWasBoarding;

	// The speed the vehicle maintains while boarding occurs (often zero)
	vec3_t	m_vBoardingVelocity;

	// Time modifier (must only be used in ProcessMoveCommands() and ProcessOrientCommands() and is updated in Update()).
	float m_fTimeModifier;

	// Ghoul2 Animation info.
	// NOTE: Since each vehicle has their own model instance, these bolts must be local to each vehicle as well.
	int m_iLeftWingBone;
	int m_iRightWingBone;
	//int m_iDriverTag;
	int m_iExhaustTag[MAX_VEHICLE_EXHAUSTS];
	int m_iMuzzleTag[MAX_VEHICLE_MUZZLES];
	int m_iDroidUnitTag;
	int	m_iGunnerViewTag[MAX_VEHICLE_TURRETS];//Where to put the view origin of the gunner (index)

	// This vehicles weapon muzzles.
	Muzzle m_Muzzles[MAX_VEHICLE_MUZZLES];

	// The user commands structure.
	usercmd_t m_ucmd;

	// The direction an entity will eject from the vehicle towards.
	int m_EjectDir;

	// Flags that describe the vehicles behavior.
	unsigned long m_ulFlags;

	// NOTE: Vehicle Type ID, Orientation, and Armor MUST be transmitted over the net.

	// Current angles of this vehicle.
	vec3_t		m_vOrientation;

	// How long you have strafed left or right (increments every frame that you strafe to right, decrements every frame you strafe left)
	int			m_fStrafeTime;	

	// Previous angles of this vehicle.
	vec3_t		m_vPrevOrientation;

	// When control is lost on a speeder, current angular velocity is stored here and applied until landing
	float		m_vAngularVelocity;

	vec3_t		m_vFullAngleVelocity;

	// Current armor and shields of your vehicle (explodes if armor to 0).
	int			m_iArmor;	//hull strength - STAT_HEALTH on NPC
	int			m_iShields;	//energy shielding - STAT_ARMOR on NPC

	// Timer for all cgame-FX...? ex: exhaust?
	int			m_iLastFXTime; 

	// When to die.
	int			m_iDieTime;

	// This pointer is to a valid VehicleInfo (which could be an animal, speeder, fighter, whatever). This
	// contains the functions actually used to do things to this specific kind of vehicle as well as shared
	// information (max speed, type, etc...).
	vehicleInfo_t *m_pVehicleInfo;

	// This trace tells us if we're within landing height.
	trace_t m_LandTrace;

	//bitflag of surfaces that have broken off
	int			m_iRemovedSurfaces;

	// the last time this vehicle fired a turbo burst
	int			m_iTurboTime;

	//how long it should drop like a rock for after freed from SUSPEND
	int			m_iDropTime;

	int			m_iSoundDebounceTimer;

	//last time we incremented the shields
	int			lastShieldInc;

	//so we don't hold it down and toggle it back and forth
	qboolean	linkWeaponToggleHeld;

	//info about our weapons (linked, ammo, etc.)
	vehWeaponStatus_t	weaponStatus[MAX_VEHICLE_WEAPONS];
	vehTurretStatus_t	turretStatus[MAX_VEHICLE_TURRETS];

	//the guy who was previously the pilot
	gentity_t*	m_pOldPilot;

	// don't need these in mp
	int			m_safeJumpMountTime;
	float		m_safeJumpMountRightDot;
};

extern int BG_VehicleGetIndex( const char *vehicleName );

#endif	// __G_VEHICLES_H