codemp/game/g_vehicles.c

Go to the documentation of this file.

// leave this line at the top for all g_xxxx.cpp files...
#include "g_headers.h"

#include "q_shared.h"
#include "g_local.h"

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

#ifndef _JK2MP
#include "g_functions.h"
#include "g_vehicles.h"
#include "../CGame/cg_Local.h"
#else
#include "bg_vehicles.h"
#endif

#ifdef _JK2MP
//this is really horrible, but it works! just be sure not to use any locals or anything
//with these names (exluding bool, false, true). -rww
#define currentAngles r.currentAngles
#define currentOrigin r.currentOrigin
#define mins r.mins
#define maxs r.maxs
#define legsAnimTimer legsTimer
#define torsoAnimTimer torsoTimer
#define bool qboolean
#define false qfalse
#define true qtrue

#define sqrtf sqrt

#define MOD_EXPLOSIVE MOD_SUICIDE
#endif

#ifndef _JK2MP
#define GAME_INLINE inline
#define bgEntity_t gentity_t
#endif

#ifdef _JK2MP
extern gentity_t *NPC_Spawn_Do( gentity_t *ent );
extern void NPC_SetAnim(gentity_t       *ent,int setAnimParts,int anim,int setAnimFlags);
#else
extern gentity_t *NPC_Spawn_Do( gentity_t *pEnt, qboolean fullSpawnNow );
extern qboolean G_ClearLineOfSight(const vec3_t point1, const vec3_t point2, int ignore, int clipmask);

extern qboolean G_SetG2PlayerModelInfo( gentity_t *pEnt, const char *modelName, const char *customSkin, const char *surfOff, const char *surfOn );
extern void G_RemovePlayerModel( gentity_t *pEnt );
extern void G_ChangePlayerModel( gentity_t *pEnt, const char *newModel );
extern void G_RemoveWeaponModels( gentity_t *pEnt );
extern void CG_ChangeWeapon( int num );
extern float DotToSpot( vec3_t spot, vec3_t from, vec3_t fromAngles );
extern qboolean Q3_TaskIDPending( gentity_t *ent, taskID_t taskType );
extern void SetClientViewAngle( gentity_t *ent, vec3_t angle );

extern vmCvar_t cg_thirdPersonAlpha;
extern vec3_t playerMins;
extern vec3_t playerMaxs;
extern cvar_t   *g_speederControlScheme;
extern cvar_t *in_joystick;
extern void PM_SetAnim(pmove_t  *pm,int setAnimParts,int anim,int setAnimFlags, int blendTime);
extern int PM_AnimLength( int index, animNumber_t anim );
extern void NPC_SetAnim(gentity_t       *ent,int setAnimParts,int anim,int setAnimFlags, int iBlend);
extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
#endif

#ifdef _JK2MP
#include "../namespace_begin.h"
extern void BG_SetAnim(playerState_t *ps, animation_t *animations, int setAnimParts,int anim,int setAnimFlags, int blendTime);
extern void BG_SetLegsAnimTimer(playerState_t *ps, int time );
extern void BG_SetTorsoAnimTimer(playerState_t *ps, int time );
#include "../namespace_end.h"
void G_VehUpdateShields( gentity_t *targ );
#ifdef QAGAME
extern void VEH_TurretThink( Vehicle_t *pVeh, gentity_t *parent, int turretNum );
#endif
#else
extern void PM_SetTorsoAnimTimer( gentity_t *ent, int *torsoAnimTimer, int time );
extern void PM_SetLegsAnimTimer( gentity_t *ent, int *legsAnimTimer, int time );
#endif

extern qboolean BG_UnrestrainedPitchRoll( playerState_t *ps, Vehicle_t *pVeh );

void Vehicle_SetAnim(gentity_t *ent,int setAnimParts,int anim,int setAnimFlags, int iBlend)
{
#ifdef _JK2MP
        assert(ent->client);
        BG_SetAnim(&ent->client->ps, bgAllAnims[ent->localAnimIndex].anims, setAnimParts, anim, setAnimFlags, iBlend);
        ent->s.legsAnim = ent->client->ps.legsAnim;
#else
        NPC_SetAnim(ent, setAnimParts, anim, setAnimFlags, iBlend);
#endif
}

void G_VehicleTrace( trace_t *results, const vec3_t start, const vec3_t tMins, const vec3_t tMaxs, const vec3_t end, int passEntityNum, int contentmask )
{
#ifdef _JK2MP
        trap_Trace(results, start, tMins, tMaxs, end, passEntityNum, contentmask);
#else
        gi.trace( results, start, tMins, tMaxs, end, passEntityNum, contentmask );
#endif
}

Vehicle_t *G_IsRidingVehicle( gentity_t *pEnt )
{
        gentity_t *ent = (gentity_t *)pEnt;

        if ( ent && ent->client && ent->client->NPC_class != CLASS_VEHICLE && ent->s.m_iVehicleNum != 0 ) //ent->client && ( ent->client->ps.eFlags & EF_IN_VEHICLE ) && ent->owner )
        {
                return g_entities[ent->s.m_iVehicleNum].m_pVehicle;
        }
        return NULL;
}



float   G_CanJumpToEnemyVeh(Vehicle_t *pVeh, const usercmd_t *pUcmd )
{
#ifndef _JK2MP
        gentity_t*      rider = pVeh->m_pPilot;

        // If There Is An Enemy And We Are At The Same Z Height
        //------------------------------------------------------
        if (rider && 
                rider->enemy && 
                pUcmd->rightmove && 
                fabsf(rider->enemy->currentOrigin[2] - rider->currentOrigin[2])<50.0f)
        {
                if (level.time<pVeh->m_safeJumpMountTime)
                {
                        return pVeh->m_safeJumpMountRightDot;
                }


                // If The Enemy Is Riding Another Vehicle
                //----------------------------------------
                Vehicle_t*      enemyVeh = G_IsRidingVehicle(rider->enemy);
                if (enemyVeh)
                {
                        vec3_t  enemyFwd;
                        vec3_t  toEnemy;
                        float   toEnemyDistance;
                        vec3_t  riderFwd;
                        vec3_t  riderRight;
                        float   riderRightDot;

                        // If He Is Close Enough And Going The Same Speed
                        //------------------------------------------------
                        VectorSubtract(rider->enemy->currentOrigin, rider->currentOrigin, toEnemy);
                        toEnemyDistance = VectorNormalize(toEnemy);
                        if (toEnemyDistance<70.0f && 
                                pVeh->m_pParentEntity->resultspeed>100.0f &&
                                fabsf(pVeh->m_pParentEntity->resultspeed - enemyVeh->m_pParentEntity->resultspeed)<100.0f)
                        {
                                // If He Is Either To The Left Or Right Of Me
                                //--------------------------------------------
                                AngleVectors(rider->currentAngles, riderFwd, riderRight, 0);
                                riderRightDot = DotProduct(riderRight, toEnemy);
                                if ((pUcmd->rightmove>0 && riderRightDot>0.2) || (pUcmd->rightmove<0 &&riderRightDot<-0.2))
                                {
                                        // If We Are Both Going About The Same Direction
                                        //-----------------------------------------------
                                        AngleVectors(rider->enemy->currentAngles, enemyFwd, 0, 0);
                                        if (DotProduct(enemyFwd, riderFwd)>0.2f)
                                        {
                                                pVeh->m_safeJumpMountTime = level.time + Q_irand(3000, 4000);   // Ok, now you get a 3 sec window
                                                pVeh->m_safeJumpMountRightDot = riderRightDot;
                                                return riderRightDot;
                                        }// Same Direction?
                                }// To Left Or Right?
                        }// Close Enough & Same Speed?
                }// Enemy Riding A Vehicle?
        }// Has Enemy And On Same Z-Height
#endif
        return 0.0f;
}

// Spawn this vehicle into the world.
void G_VehicleSpawn( gentity_t *self )
{
        float yaw;
        gentity_t *vehEnt;

        VectorCopy( self->currentOrigin, self->s.origin );

#ifdef _JK2MP
        trap_LinkEntity( self );
#else
        gi.linkentity( self );
#endif

        if ( !self->count )
        {
                self->count = 1;
        }

        //save this because self gets removed in next func
        yaw = self->s.angles[YAW];
        
#ifdef _JK2MP
        vehEnt = NPC_Spawn_Do( self );
#else
        vehEnt = NPC_Spawn_Do( self, qtrue );
#endif
        
        if ( !vehEnt )
        {
                return;//return NULL;
        }
        
        vehEnt->s.angles[YAW] = yaw;
        if ( vehEnt->m_pVehicle->m_pVehicleInfo->type != VH_ANIMAL )
        {
                vehEnt->NPC->behaviorState = BS_CINEMATIC;
        }

#ifdef _JK2MP //special check in case someone disconnects/dies while boarding
        if (vehEnt->spawnflags & 1)
        { //die without pilot
                if (!vehEnt->damage)
                { //default 10 sec
                        vehEnt->damage = 10000;
                }
                if (!vehEnt->speed)
                { //default 512 units
                        vehEnt->speed = 512.0f;
                }
                vehEnt->m_pVehicle->m_iPilotTime = level.time + vehEnt->damage;
        }
#else
        if (vehEnt->spawnflags & 1)
        { //die without pilot
                vehEnt->m_pVehicle->m_iPilotTime = level.time + vehEnt->endFrame;
        }
#endif
        //return vehEnt;
}

// Attachs an entity to the vehicle it's riding (it's owner).
void G_AttachToVehicle( gentity_t *pEnt, usercmd_t **ucmd )
{
        gentity_t               *vehEnt;
        mdxaBone_t              boltMatrix;
        gentity_t               *ent;
#ifdef _JK2MP
        int                             crotchBolt;
#endif

        if ( !pEnt || !ucmd )
                return;

        ent = (gentity_t *)pEnt;

#ifdef _JK2MP
        vehEnt = &g_entities[ent->r.ownerNum];
#else
        vehEnt = ent->owner;
#endif
        ent->waypoint = vehEnt->waypoint; // take the veh's waypoint as your own

        if ( !vehEnt->m_pVehicle )
                return;

#ifdef _JK2MP
        crotchBolt = trap_G2API_AddBolt(vehEnt->ghoul2, 0, "*driver");

        // Get the driver tag.
        trap_G2API_GetBoltMatrix( vehEnt->ghoul2, 0, crotchBolt, &boltMatrix,
                                                        vehEnt->m_pVehicle->m_vOrientation, vehEnt->currentOrigin,
                                                        level.time, NULL, vehEnt->modelScale );
        BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, ent->client->ps.origin );
        G_SetOrigin(ent, ent->client->ps.origin);
        trap_LinkEntity( ent );
#else
        // Get the driver tag.
        gi.G2API_GetBoltMatrix( vehEnt->ghoul2, vehEnt->playerModel, vehEnt->crotchBolt, &boltMatrix,
                                                        vehEnt->m_pVehicle->m_vOrientation, vehEnt->currentOrigin,
                                                        (cg.time?cg.time:level.time), NULL, vehEnt->s.modelScale );
        gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, ent->client->ps.origin );
        gi.linkentity( ent );
#endif
}

#ifndef _JK2MP
void G_KnockOffVehicle( gentity_t *pRider, gentity_t *self, qboolean bPull )
{
        Vehicle_t *pVeh = NULL;
        vec3_t riderAngles, fDir, rDir, dir2Me;
        float   fDot, rDot;

        if ( !pRider || !pRider->client )
        {
                return;
        }
        
        pVeh = G_IsRidingVehicle( pRider );

        if ( !pVeh || !pVeh->m_pVehicleInfo )
        {
                return;
        }

        VectorCopy( pRider->currentAngles, riderAngles );
        riderAngles[0] = 0;
        AngleVectors( riderAngles, fDir, rDir, NULL );
        VectorSubtract( self->currentOrigin, pRider->currentOrigin, dir2Me );
        dir2Me[2] = 0;
        VectorNormalize( dir2Me );
        fDot = DotProduct( fDir, dir2Me );
        if ( fDot >= 0.5f )
        {//I'm in front of them
                if ( bPull )
                {//pull them foward
                        pVeh->m_EjectDir = VEH_EJECT_FRONT;
                }
                else
                {//push them back
                        pVeh->m_EjectDir = VEH_EJECT_REAR;
                }
        }
        else if ( fDot <= -0.5f )
        {//I'm behind them
                if ( bPull )
                {//pull them back
                        pVeh->m_EjectDir = VEH_EJECT_REAR;
                }
                else
                {//push them forward
                        pVeh->m_EjectDir = VEH_EJECT_FRONT;
                }
        }
        else
        {//to the side of them
                rDot = DotProduct( fDir, dir2Me );
                if ( rDot >= 0.0f )
                {//to the right
                        if ( bPull )
                        {//pull them right
                                pVeh->m_EjectDir = VEH_EJECT_RIGHT;
                        }
                        else
                        {//push them left
                                pVeh->m_EjectDir = VEH_EJECT_LEFT;
                        }
                }
                else
                {//to the left
                        if ( bPull )
                        {//pull them left
                                pVeh->m_EjectDir = VEH_EJECT_LEFT;
                        }
                        else
                        {//push them right
                                pVeh->m_EjectDir = VEH_EJECT_RIGHT;
                        }
                }
        }
        //now forcibly eject them
        pVeh->m_pVehicleInfo->Eject( pVeh, pRider, qtrue );
}
#endif

#ifndef _JK2MP //don't want this in mp at least for now
void G_DrivableATSTDie( gentity_t *self )
{
}

void G_DriveATST( gentity_t *pEnt, gentity_t *atst )
{
        if ( pEnt->NPC_type && pEnt->client && (pEnt->client->NPC_class == CLASS_ATST) )
        {//already an atst, switch back
                //open hatch
                G_RemovePlayerModel( pEnt );
                pEnt->NPC_type = "player";
                pEnt->client->NPC_class = CLASS_PLAYER;
                pEnt->flags &= ~FL_SHIELDED;
                pEnt->client->ps.eFlags &= ~EF_IN_ATST;
                //size
                VectorCopy( playerMins, pEnt->mins );
                VectorCopy( playerMaxs, pEnt->maxs );
                pEnt->client->crouchheight = CROUCH_MAXS_2;
                pEnt->client->standheight = DEFAULT_MAXS_2;
                G_ChangePlayerModel( pEnt, pEnt->NPC_type );
                //G_SetG2PlayerModel( pEnt, pEnt->NPC_type, NULL, NULL, NULL );

                //FIXME: reset/4 their weapon
                pEnt->client->ps.stats[STAT_WEAPONS] &= ~(( 1 << WP_ATST_MAIN )|( 1 << WP_ATST_SIDE ));
                pEnt->client->ps.ammo[weaponData[WP_ATST_MAIN].ammoIndex] = 0;
                pEnt->client->ps.ammo[weaponData[WP_ATST_SIDE].ammoIndex] = 0;
                CG_ChangeWeapon( WP_BLASTER );
                //camera
                //if ( pEnt->client->ps.weapon != WP_SABER )
                {
                        gi.cvar_set( "cg_thirdperson", "0" );
                }
                cg.overrides.active &= ~(CG_OVERRIDE_3RD_PERSON_RNG|CG_OVERRIDE_3RD_PERSON_VOF|CG_OVERRIDE_3RD_PERSON_POF|CG_OVERRIDE_3RD_PERSON_APH);
                cg.overrides.thirdPersonRange = cg.overrides.thirdPersonVertOffset = cg.overrides.thirdPersonPitchOffset = 0;
                cg.overrides.thirdPersonAlpha = cg_thirdPersonAlpha.value;
                pEnt->client->ps.viewheight = pEnt->maxs[2] + STANDARD_VIEWHEIGHT_OFFSET;
                //pEnt->mass = 10;
        }
        else
        {//become an atst
                pEnt->NPC_type = "atst";
                pEnt->client->NPC_class = CLASS_ATST;
                pEnt->client->ps.eFlags |= EF_IN_ATST;
                pEnt->flags |= FL_SHIELDED;
                //size
                VectorSet( pEnt->mins, ATST_MINS0, ATST_MINS1, ATST_MINS2 );
                VectorSet( pEnt->maxs, ATST_MAXS0, ATST_MAXS1, ATST_MAXS2 );
                pEnt->client->crouchheight = ATST_MAXS2;
                pEnt->client->standheight = ATST_MAXS2;
                if ( !atst )
                {//no pEnt to copy from
                        G_ChangePlayerModel( pEnt, "atst" );
                        //G_SetG2PlayerModel( pEnt, "atst", NULL, NULL, NULL );
                        NPC_SetAnim( pEnt, SETANIM_BOTH, BOTH_STAND1, SETANIM_FLAG_OVERRIDE, 200 );
                }
                else
                {
                        G_RemovePlayerModel( pEnt );
                        G_RemoveWeaponModels( pEnt );
                        gi.G2API_CopyGhoul2Instance( atst->ghoul2, pEnt->ghoul2 );
                        pEnt->playerModel = 0;
                        G_SetG2PlayerModelInfo( pEnt, "atst", NULL, NULL, NULL );
                        //turn off hatch underside
                        gi.G2API_SetSurfaceOnOff( &pEnt->ghoul2[pEnt->playerModel], "head_hatchcover", 0x00000002/*G2SURFACEFLAG_OFF*/ );
                        G_Sound( pEnt, G_SoundIndex( "sound/chars/atst/atst_hatch_close" ));
                }
                pEnt->s.radius = 320;
                //weapon
                gitem_t *item = FindItemForWeapon( WP_ATST_MAIN );      //precache the weapon
                CG_RegisterItemSounds( (item-bg_itemlist) );
                CG_RegisterItemVisuals( (item-bg_itemlist) );
                item = FindItemForWeapon( WP_ATST_SIDE );       //precache the weapon
                CG_RegisterItemSounds( (item-bg_itemlist) );
                CG_RegisterItemVisuals( (item-bg_itemlist) );
                pEnt->client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_ATST_MAIN )|( 1 << WP_ATST_SIDE );
                pEnt->client->ps.ammo[weaponData[WP_ATST_MAIN].ammoIndex] = ammoData[weaponData[WP_ATST_MAIN].ammoIndex].max;
                pEnt->client->ps.ammo[weaponData[WP_ATST_SIDE].ammoIndex] = ammoData[weaponData[WP_ATST_SIDE].ammoIndex].max;
                CG_ChangeWeapon( WP_ATST_MAIN );
                //HACKHACKHACKTEMP
                item = FindItemForWeapon( WP_EMPLACED_GUN );
                CG_RegisterItemSounds( (item-bg_itemlist) );
                CG_RegisterItemVisuals( (item-bg_itemlist) );
                item = FindItemForWeapon( WP_ROCKET_LAUNCHER );
                CG_RegisterItemSounds( (item-bg_itemlist) );
                CG_RegisterItemVisuals( (item-bg_itemlist) );
                item = FindItemForWeapon( WP_BOWCASTER );
                CG_RegisterItemSounds( (item-bg_itemlist) );
                CG_RegisterItemVisuals( (item-bg_itemlist) );
                //HACKHACKHACKTEMP
                //FIXME: these get lost in load/save!  Must use variables that are set every frame or saved/loaded
                //camera
                gi.cvar_set( "cg_thirdperson", "1" );
                cg.overrides.active |= CG_OVERRIDE_3RD_PERSON_RNG;
                cg.overrides.thirdPersonRange = 240;
                //cg.overrides.thirdPersonVertOffset = 100;
                //cg.overrides.thirdPersonPitchOffset = -30;
                //FIXME: this gets stomped in pmove?
                pEnt->client->ps.viewheight = 120;
                //FIXME: setting these broke things very badly...?
                //pEnt->client->standheight = 200;
                //pEnt->client->crouchheight = 200;
                //pEnt->mass = 300;
                //movement
                //pEnt->client->ps.speed = 0;//FIXME: override speed?
                //FIXME: slow turn turning/can't turn if not moving?
        }
}
#endif //_JK2MP

// Animate the vehicle and it's riders.
void Animate( Vehicle_t *pVeh )
{
        // Validate a pilot rider.
        if ( pVeh->m_pPilot )
        {
                if (pVeh->m_pVehicleInfo->AnimateRiders)
                {
                        pVeh->m_pVehicleInfo->AnimateRiders( pVeh );
                }
        }

        pVeh->m_pVehicleInfo->AnimateVehicle( pVeh );
}

// Determine whether this entity is able to board this vehicle or not.
bool ValidateBoard( Vehicle_t *pVeh, bgEntity_t *pEnt )
{
        // Determine where the entity is entering the vehicle from (left, right, or back).
        vec3_t vVehToEnt;
        vec3_t vVehDir;
        const gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
        const gentity_t *ent = (gentity_t *)pEnt;
        vec3_t vVehAngles;
        float fDot;

        if ( pVeh->m_iDieTime>0)
        {
                return false;
        }

        if ( pVeh->m_pPilot != NULL )
        {//already have a driver!
                if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
                {//I know, I know, this should by in the fighters's validateboard()
                        //can never steal a fighter from it's pilot
                        if ( pVeh->m_iNumPassengers < pVeh->m_pVehicleInfo->maxPassengers )
                        {
                                return true;
                        }
                        else
                        {
                                return false;
                        }
                }
                else if ( pVeh->m_pVehicleInfo->type == VH_WALKER )
                {//I know, I know, this should by in the walker's validateboard()
                        if ( !ent->client || ent->client->ps.groundEntityNum != parent->s.number )
                        {//can only steal an occupied AT-ST if you're on top (by the hatch)
                                return false;
                        }
                }
                else if (pVeh->m_pVehicleInfo->type == VH_SPEEDER)
                {//you can only steal the bike from the driver if you landed on the driver or bike
                        return (pVeh->m_iBoarding==VEH_MOUNT_THROW_LEFT || pVeh->m_iBoarding==VEH_MOUNT_THROW_RIGHT);
                }
        }
        // Yes, you shouldn't have put this here (you 'should' have made an 'overriden' ValidateBoard func), but in this
        // instance it's more than adequate (which is why I do it too :-). Making a whole other function for this is silly.
        else if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
        {
                // If you're a fighter, you allow everyone to enter you from all directions.
                return true;
        }

        // Clear out all orientation axis except for the yaw.
        VectorSet(vVehAngles, 0, parent->currentAngles[YAW], 0);

        // Vector from Entity to Vehicle.
        VectorSubtract( ent->currentOrigin, parent->currentOrigin, vVehToEnt );
        vVehToEnt[2] = 0;
        VectorNormalize( vVehToEnt );

        // Get the right vector.
        AngleVectors( vVehAngles, NULL, vVehDir, NULL ); 
        VectorNormalize( vVehDir );

        // Find the angle between the vehicle right vector and the vehicle to entity vector.
        fDot = DotProduct( vVehToEnt, vVehDir );

        // If the entity is within a certain angle to the left of the vehicle...
        if ( fDot >= 0.5f )
        {
                // Right board.
                pVeh->m_iBoarding = -2;
        }
        else if ( fDot <= -0.5f )
        {
                // Left board.
                pVeh->m_iBoarding = -1;
        }
        // Maybe they're trying to board from the back...
        else
        {
                // The forward vector of the vehicle.
        //      AngleVectors( vVehAngles, vVehDir, NULL, NULL ); 
        //      VectorNormalize( vVehDir );

                // Find the angle between the vehicle forward and the vehicle to entity vector.
        //      fDot = DotProduct( vVehToEnt, vVehDir );

                // If the entity is within a certain angle behind the vehicle...
                //if ( fDot <= -0.85f )
                {
                        // Jump board.
                        pVeh->m_iBoarding = -3;
                }
        }

        // If for some reason we couldn't board, leave...
        if ( pVeh->m_iBoarding > -1 )
                return false;

        return true;
}

#ifdef VEH_CONTROL_SCHEME_4
void FighterStorePilotViewAngles( Vehicle_t *pVeh, bgEntity_t *parent )
{
        playerState_t *riderPS;
#ifdef _JK2MP
        bgEntity_t *rider = NULL;
        if (parent->s.owner != ENTITYNUM_NONE)
        {
                rider = PM_BGEntForNum(parent->s.owner); //&g_entities[parent->r.ownerNum];
        }
#else
        gentity_t *rider = parent->owner;
#endif

#ifdef _JK2MP
        if ( !rider )
#else
        if ( !rider || !rider->client )
#endif
        {
                rider = parent;
        }

#ifdef _JK2MP
        riderPS = rider->playerState;
#else
        riderPS = &rider->client->ps;
#endif
        VectorClear( pVeh->m_vPrevRiderViewAngles );
        pVeh->m_vPrevRiderViewAngles[YAW] = AngleNormalize180(riderPS->viewangles[YAW]);
}
#endif// VEH_CONTROL_SCHEME_4

// Board this Vehicle (get on). The first entity to board an empty vehicle becomes the Pilot.
bool Board( Vehicle_t *pVeh, bgEntity_t *pEnt )
{
        vec3_t vPlayerDir;
        gentity_t *ent = (gentity_t *)pEnt;
        gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;

        // If it's not a valid entity, OR if the vehicle is blowing up (it's dead), OR it's not
        // empty, OR we're already being boarded, OR the person trying to get on us is already
        // in a vehicle (that was a fun bug :-), leave!
        if ( !ent || parent->health <= 0 /*|| !( parent->client->ps.eFlags & EF_EMPTY_VEHICLE )*/ || (pVeh->m_iBoarding > 0) ||
#ifdef _JK2MP
                 ( ent->client->ps.m_iVehicleNum ) )
#else
                 ( ent->s.m_iVehicleNum != 0 ) )
#endif
                return false;

        // Bucking so we can't do anything (NOTE: Should probably be a better name since fighters don't buck...).
        if ( pVeh->m_ulFlags & VEH_BUCKING )
                return false;

        // Validate the entity's ability to board this vehicle.
        if ( !pVeh->m_pVehicleInfo->ValidateBoard( pVeh, pEnt ) )
                return false;

        // FIXME FIXME!!! Ask Mike monday where ent->client->ps.eFlags might be getting changed!!! It is always 0 (when it should
        // be 1024) so a person riding a vehicle is able to ride another vehicle!!!!!!!!

        // Tell everybody their status.
        // ALWAYS let the player be the pilot.
        if ( ent->s.number < MAX_CLIENTS )
        {
                pVeh->m_pOldPilot = pVeh->m_pPilot;


#ifdef _JK2MP
                if ( !pVeh->m_pPilot )
                { //become the pilot, if there isn't one now
                        pVeh->m_pVehicleInfo->SetPilot( pVeh, (bgEntity_t *)ent );
                }
                // If we're not yet full...
                else if ( pVeh->m_iNumPassengers < pVeh->m_pVehicleInfo->maxPassengers )
                {
                        int i;
                        // Find an empty slot and put that passenger here.
                        for ( i = 0; i < pVeh->m_pVehicleInfo->maxPassengers; i++ )
                        {
                                if ( pVeh->m_ppPassengers[i] == NULL )
                                {
                                        pVeh->m_ppPassengers[i] = (bgEntity_t *)ent;
#ifdef QAGAME
                                        //Server just needs to tell client which passengernum he is
                                        if ( ent->client )
                                        {
                                                ent->client->ps.generic1 = i+1;
                                        }
#endif
                                        break;
                                }
                        }
                        pVeh->m_iNumPassengers++;
                }
                // We're full, sorry...
                else
                {
                        return false;
                }
                ent->s.m_iVehicleNum = parent->s.number;
                if (ent->client)
                {
                        ent->client->ps.m_iVehicleNum = ent->s.m_iVehicleNum;
                }
                if ( pVeh->m_pPilot == (bgEntity_t *)ent )
                {
                        parent->r.ownerNum = ent->s.number;
                        parent->s.owner = parent->r.ownerNum; //for prediction
                }
#else
                pVeh->m_pVehicleInfo->SetPilot( pVeh, ent );
                ent->s.m_iVehicleNum = parent->s.number;
                parent->owner = ent;
#endif

#ifdef QAGAME           
                {
                        gentity_t *gParent = (gentity_t *)parent;
                        if ( (gParent->spawnflags&2) )
                        {//was being suspended
                                gParent->spawnflags &= ~2;//SUSPENDED - clear this spawnflag, no longer docked, okay to free-fall if not in space
                                //gParent->client->ps.eFlags &= ~EF_RADAROBJECT;
                                G_Sound( gParent, CHAN_AUTO, G_SoundIndex( "sound/vehicles/common/release.wav" ) );
                                if ( gParent->fly_sound_debounce_time )
                                {//we should drop like a rock for a few seconds
                                        pVeh->m_iDropTime = level.time + gParent->fly_sound_debounce_time;
                                }
                        }
                }
#endif

#ifndef _JK2MP
                gi.cvar_set( "cg_thirdperson", "1" );                                                           //go to third person
                CG_CenterPrint( "@SP_INGAME_EXIT_VIEW", SCREEN_HEIGHT * 0.95 );         //tell them how to get out!
#endif

                //FIXME: rider needs to look in vehicle's direction when he gets in
                // Clear these since they're used to turn the vehicle now.
                /*SetClientViewAngle( ent, pVeh->m_vOrientation );
                memset( &parent->client->usercmd, 0, sizeof( usercmd_t ) );
                memset( &pVeh->m_ucmd, 0, sizeof( usercmd_t ) );
                VectorClear( parent->client->ps.viewangles );
                VectorClear( parent->client->ps.delta_angles );*/

                // Set the looping sound only when there is a pilot (when the vehicle is "on").
                if ( pVeh->m_pVehicleInfo->soundLoop )
                {
#ifdef _JK2MP
                        parent->client->ps.loopSound = parent->s.loopSound = pVeh->m_pVehicleInfo->soundLoop;
#else
                        parent->s.loopSound = pVeh->m_pVehicleInfo->soundLoop;
#endif
                }
        }
        else
        {
                // If there's no pilot, try to drive this vehicle.
                if ( pVeh->m_pPilot == NULL )
                {
#ifdef _JK2MP
                        pVeh->m_pVehicleInfo->SetPilot( pVeh, (bgEntity_t *)ent );
                        // TODO: Set pilot should do all this stuff....
                        parent->r.ownerNum = ent->s.number;
                        parent->s.owner = parent->r.ownerNum; //for prediction
#else
                        pVeh->m_pVehicleInfo->SetPilot( pVeh, ent );
                        // TODO: Set pilot should do all this stuff....
                        parent->owner = ent;
#endif
                        // Set the looping sound only when there is a pilot (when the vehicle is "on").
                        if ( pVeh->m_pVehicleInfo->soundLoop )
                        {
#ifdef _JK2MP
                                parent->client->ps.loopSound = parent->s.loopSound = pVeh->m_pVehicleInfo->soundLoop;
#else
                                parent->s.loopSound = pVeh->m_pVehicleInfo->soundLoop;
#endif
                        }

                        parent->client->ps.speed = 0;
                        memset( &pVeh->m_ucmd, 0, sizeof( usercmd_t ) );
                }
                // If we're not yet full...
                else if ( pVeh->m_iNumPassengers < pVeh->m_pVehicleInfo->maxPassengers )
                {
                        int i;
                        // Find an empty slot and put that passenger here.
                        for ( i = 0; i < pVeh->m_pVehicleInfo->maxPassengers; i++ )
                        {
                                if ( pVeh->m_ppPassengers[i] == NULL )
                                {
#ifdef _JK2MP
                                        pVeh->m_ppPassengers[i] = (bgEntity_t *)ent;
#ifdef QAGAME
                                        //Server just needs to tell client which passengernum he is
                                        if ( ent->client )
                                        {
                                                ent->client->ps.generic1 = i+1;
                                        }
#endif
#else
                                        pVeh->m_ppPassengers[i] = ent;
#endif
                                        break;
                                }
                        }
                        pVeh->m_iNumPassengers++;
                }
                // We're full, sorry...
                else
                {
                        return false;
                }
        }
        
        // Make sure the entity knows it's in a vehicle.
#ifdef _JK2MP
        ent->client->ps.m_iVehicleNum = parent->s.number;
        ent->r.ownerNum = parent->s.number;
        ent->s.owner = ent->r.ownerNum; //for prediction
        if (pVeh->m_pPilot == (bgEntity_t *)ent)
        {
                parent->client->ps.m_iVehicleNum = ent->s.number+1; //always gonna be under MAX_CLIENTS so no worries about 1 byte overflow
        }
#else
        ent->s.m_iVehicleNum = parent->s.number;
        ent->owner = parent;
        parent->s.m_iVehicleNum = ent->s.number+1;
#endif

        //memset( &ent->client->usercmd, 0, sizeof( usercmd_t ) );

        //FIXME: no saber or weapons if numHands = 2, should switch to speeder weapon, no attack anim on player
        if ( pVeh->m_pVehicleInfo->numHands == 2 )
        {//switch to vehicle weapon
#ifndef _JK2MP //rwwFIXMEFIXMEFIXME
                if (ent->s.number<MAX_CLIENTS)
                {
                        CG_ChangeWeapon(WP_NONE);
                }

                ent->client->ps.weapon = WP_NONE;
                G_RemoveWeaponModels( ent );
#endif
        }

        if ( pVeh->m_pVehicleInfo->hideRider )
        {//hide the rider
                pVeh->m_pVehicleInfo->Ghost( pVeh, (bgEntity_t *)ent );
        }

        // Play the start sounds
        if ( pVeh->m_pVehicleInfo->soundOn )
        {
#ifdef _JK2MP
                G_Sound( parent, CHAN_AUTO, pVeh->m_pVehicleInfo->soundOn );
#else
                // NOTE: Use this type so it's spatialized and updates play origin as bike moves - MCG
                G_SoundIndexOnEnt( parent, CHAN_AUTO, pVeh->m_pVehicleInfo->soundOn );
#endif
        }

#ifdef VEH_CONTROL_SCHEME_4
        if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
        {//clear their angles
                FighterStorePilotViewAngles( pVeh, (bgEntity_t *)parent );
        }
#endif //VEH_CONTROL_SCHEME_4

        VectorCopy( pVeh->m_vOrientation, vPlayerDir );
        vPlayerDir[ROLL] = 0;
        SetClientViewAngle( ent, vPlayerDir );

        return true;
}

bool VEH_TryEject( Vehicle_t *pVeh, 
                                  gentity_t *parent, 
                                  gentity_t *ent, 
                                  int ejectDir, 
                                  vec3_t vExitPos )
{
        float           fBias;
        float           fVehDiag;
        float           fEntDiag;
        int                     oldOwner;
        vec3_t          vEntMins, vEntMaxs, vVehLeaveDir, vVehAngles;
        trace_t         m_ExitTrace;

        // Make sure that the entity is not 'stuck' inside the vehicle (since their bboxes will now intersect).
        // This makes the entity leave the vehicle from the right side.
        VectorSet(vVehAngles, 0, parent->currentAngles[YAW], 0);
        switch ( ejectDir )
        {
                // Left.
                case VEH_EJECT_LEFT:
                        AngleVectors( vVehAngles, NULL, vVehLeaveDir, NULL ); 
                        vVehLeaveDir[0] = -vVehLeaveDir[0];
                        vVehLeaveDir[1] = -vVehLeaveDir[1];
                        vVehLeaveDir[2] = -vVehLeaveDir[2];
                        break;
                // Right.
                case VEH_EJECT_RIGHT:
                        AngleVectors( vVehAngles, NULL, vVehLeaveDir, NULL ); 
                        break;
                // Front.
                case VEH_EJECT_FRONT:
                        AngleVectors( vVehAngles, vVehLeaveDir, NULL, NULL ); 
                        break;
                // Rear.
                case VEH_EJECT_REAR:
                        AngleVectors( vVehAngles, vVehLeaveDir, NULL, NULL ); 
                        vVehLeaveDir[0] = -vVehLeaveDir[0];
                        vVehLeaveDir[1] = -vVehLeaveDir[1];
                        vVehLeaveDir[2] = -vVehLeaveDir[2];
                        break;
                // Top.
                case VEH_EJECT_TOP:
                        AngleVectors( vVehAngles, NULL, NULL, vVehLeaveDir ); 
                        break;
                // Bottom?.
                case VEH_EJECT_BOTTOM:
                        break;
        }
        VectorNormalize( vVehLeaveDir );
        //NOTE: not sure why following line was needed - MCG
        //pVeh->m_EjectDir = VEH_EJECT_LEFT;

        // Since (as of this time) the collidable geometry of the entity is just an axis 
        // aligned box, we need to get the diagonal length of it in case we come out on that side.
        // Diagonal Length == squareroot( squared( Sidex / 2 ) + squared( Sidey / 2 ) );

        // TODO: DO diagonal for entity.

        fBias = 1.0f;
        if (pVeh->m_pVehicleInfo->type == VH_WALKER)
        { //hacktastic!
                fBias += 0.2f;
        }
        VectorCopy( ent->currentOrigin, vExitPos );
        fVehDiag = sqrtf( ( parent->maxs[0] * parent->maxs[0] ) + ( parent->maxs[1] * parent->maxs[1] ) );
        VectorCopy( ent->maxs, vEntMaxs );
#ifdef _JK2MP
        if ( ent->s.number < MAX_CLIENTS )
        {//for some reason, in MP, player client mins and maxs are never stored permanently, just set to these hardcoded numbers in PMove
                vEntMaxs[0] = 15;
                vEntMaxs[1] = 15;
        }
#endif
        fEntDiag = sqrtf( ( vEntMaxs[0] * vEntMaxs[0] ) + ( vEntMaxs[1] * vEntMaxs[1] ) );
        vVehLeaveDir[0] *= ( fVehDiag + fEntDiag ) * fBias;     // x
        vVehLeaveDir[1] *= ( fVehDiag + fEntDiag ) * fBias;     // y
        vVehLeaveDir[2] *= ( fVehDiag + fEntDiag ) * fBias;
        VectorAdd( vExitPos, vVehLeaveDir, vExitPos );

        //we actually could end up *not* getting off if the trace fails...
        // Check to see if this new position is a valid place for our entity to go.
#ifdef _JK2MP
        VectorSet(vEntMins, -15.0f, -15.0f, DEFAULT_MINS_2);
        VectorSet(vEntMaxs, 15.0f, 15.0f, DEFAULT_MAXS_2);
#else
        VectorCopy(ent->mins, vEntMins);
        VectorCopy(ent->maxs, vEntMaxs);
#endif
        oldOwner = ent->r.ownerNum;
        ent->r.ownerNum = ENTITYNUM_NONE;
        G_VehicleTrace( &m_ExitTrace, ent->currentOrigin, vEntMins, vEntMaxs, vExitPos, ent->s.number, ent->clipmask );
        ent->r.ownerNum = oldOwner;

        if ( m_ExitTrace.allsolid//in solid
                || m_ExitTrace.startsolid)
        {
                return false;
        }
        // If the trace hit something, we can't go there!
        if ( m_ExitTrace.fraction < 1.0f )
        {//not totally clear
#ifdef _JK2MP
//              if ( (parent->clipmask&ent->r.contents) )//vehicle could actually get stuck on body
#else
                if ( (parent->clipmask&ent->contents) )//vehicle could actually get stuck on body
#endif
                {//the trace hit the vehicle, don't let them get out, just in case
                        return false;
                }
                //otherwise, use the trace.endpos
                VectorCopy( m_ExitTrace.endpos, vExitPos );
        }
        return true;
}

void G_EjectDroidUnit( Vehicle_t *pVeh, qboolean kill )
{
        pVeh->m_pDroidUnit->s.m_iVehicleNum = ENTITYNUM_NONE;
#ifdef _JK2MP
        pVeh->m_pDroidUnit->s.owner = ENTITYNUM_NONE;
#else
        pVeh->m_pDroidUnit->owner = NULL;
#endif
//      pVeh->m_pDroidUnit->s.otherEntityNum2 = ENTITYNUM_NONE;
#ifdef QAGAME
        {
                gentity_t *droidEnt = (gentity_t *)pVeh->m_pDroidUnit;
                droidEnt->flags &= ~FL_UNDYING;
                droidEnt->r.ownerNum = ENTITYNUM_NONE;
                if ( droidEnt->client )
                {
                        droidEnt->client->ps.m_iVehicleNum = ENTITYNUM_NONE;
                }
                if ( kill )
                {//Kill them, too
                        //FIXME: proper origin, MOD and attacker (for credit/death message)?  Get from vehicle?
                        G_MuteSound(droidEnt->s.number, CHAN_VOICE);
                        G_Damage( droidEnt, NULL, NULL, NULL, droidEnt->s.origin, 10000, 0, MOD_SUICIDE );//FIXME: proper MOD?  Get from vehicle?
                }
        }
#endif
        pVeh->m_pDroidUnit = NULL;
}

// Eject the pilot from the vehicle.
bool Eject( Vehicle_t *pVeh, bgEntity_t *pEnt, qboolean forceEject )
{
        gentity_t       *parent;
        vec3_t          vExitPos;
#ifndef _JK2MP
        vec3_t          vPlayerDir;
#endif
        gentity_t       *ent = (gentity_t *)pEnt;
        int                     firstEjectDir;

#ifdef _JK2MP
        qboolean        taintedRider = qfalse;
        qboolean        deadRider = qfalse;

        if ( pEnt == pVeh->m_pDroidUnit )
        {
                G_EjectDroidUnit( pVeh, qfalse );
                return true;
        }

        if (ent)
        {
                if (!ent->inuse || !ent->client || ent->client->pers.connected != CON_CONNECTED)
                {
                        taintedRider = qtrue;
                        parent = (gentity_t *)pVeh->m_pParentEntity;
                        goto getItOutOfMe;
                }
                else if (ent->health < 1)
                {
                        deadRider = qtrue;
                }
        }
#endif

        // Validate.
        if ( !ent )
        {
                return false;
        }
        if ( !forceEject )
        {
                if ( !( pVeh->m_iBoarding == 0 || pVeh->m_iBoarding == -999 || ( pVeh->m_iBoarding < -3 && pVeh->m_iBoarding >= -9 ) ) )
                {
#ifdef _JK2MP //I don't care, if he's dead get him off even if he died while boarding
                        deadRider = qtrue;
                        pVeh->m_iBoarding = 0;
                        pVeh->m_bWasBoarding = false;
#else
                        return false;
#endif
                }
        }

#ifndef _JK2MP //rwwFIXMEFIXMEFIXME
        if (ent->s.number<MAX_CLIENTS)
        {
                CG_ChangeWeapon(WP_NONE);
        }
        ent->client->ps.weapon = WP_NONE;
        G_RemoveWeaponModels( ent );
#endif

        parent = (gentity_t *)pVeh->m_pParentEntity;

        //Try ejecting in every direction
        if ( pVeh->m_EjectDir < VEH_EJECT_LEFT )
        {
                pVeh->m_EjectDir = VEH_EJECT_LEFT;
        }
        else if ( pVeh->m_EjectDir > VEH_EJECT_BOTTOM )
        {
                pVeh->m_EjectDir = VEH_EJECT_BOTTOM;
        }
        firstEjectDir = pVeh->m_EjectDir;
        while ( !VEH_TryEject( pVeh, parent, ent, pVeh->m_EjectDir, vExitPos ) )
        {
                pVeh->m_EjectDir++;
                if ( pVeh->m_EjectDir > VEH_EJECT_BOTTOM )
                {
                        pVeh->m_EjectDir = VEH_EJECT_LEFT;
                }
                if ( pVeh->m_EjectDir == firstEjectDir )
                {//they all failed
#ifdef _JK2MP
                        if (!deadRider)
                        { //if he's dead.. just shove him in solid, who cares.
                                return false;
                        }
#endif
                        if ( forceEject )
                        {//we want to always get out, just eject him here
                                VectorCopy( ent->currentOrigin, vExitPos );
                                break;
                        }
                        else
                        {//can't eject
                                return false;
                        }
                }
        }

        // Move them to the exit position.
        G_SetOrigin( ent, vExitPos );
#ifdef _JK2MP
        VectorCopy(ent->currentOrigin, ent->client->ps.origin);
        trap_LinkEntity( ent );
#else
        gi.linkentity( ent );
#endif

        // If it's the player, stop overrides.
        if ( ent->s.number < MAX_CLIENTS )
        {
#ifndef _JK2MP
                cg.overrides.active = 0;
#else

#endif
        }

#ifdef _JK2MP //in MP if someone disconnects on us, we still have to clear our owner
getItOutOfMe:
#endif

        // If he's the pilot...
        if ( (gentity_t *)pVeh->m_pPilot == ent )
        {
#ifdef _JK2MP
                int j = 0;
#endif

                pVeh->m_pPilot = NULL;
#ifdef _JK2MP
                parent->r.ownerNum = ENTITYNUM_NONE;
                parent->s.owner = parent->r.ownerNum; //for prediction

                //keep these current angles
                //SetClientViewAngle( parent, pVeh->m_vOrientation );
                memset( &parent->client->pers.cmd, 0, sizeof( usercmd_t ) );
#else
                parent->owner = NULL;

                //keep these current angles
                //SetClientViewAngle( parent, pVeh->m_vOrientation );
                memset( &parent->client->usercmd, 0, sizeof( usercmd_t ) );
#endif
                memset( &pVeh->m_ucmd, 0, sizeof( usercmd_t ) );

#ifdef _JK2MP //if there are some passengers, promote the first passenger to pilot
                while (j < pVeh->m_iNumPassengers)
                {
                        if (pVeh->m_ppPassengers[j])
                        {
                                int k = 1;
                                pVeh->m_pVehicleInfo->SetPilot( pVeh, pVeh->m_ppPassengers[j] );
                                parent->r.ownerNum = pVeh->m_ppPassengers[j]->s.number;
                                parent->s.