codemp/game/bg_pmove.c

Go to the documentation of this file.

// Copyright (C) 1999-2000 Id Software, Inc.
//
// bg_pmove.c -- both games player movement code
// takes a playerstate and a usercmd as input and returns a modifed playerstate

#include "q_shared.h"
#include "bg_public.h"
#include "bg_local.h"
#include "bg_strap.h"
#include "../ghoul2/G2.h"

#ifdef QAGAME
#include "g_local.h" //ahahahahhahahaha@$!$!
#endif

#define MAX_WEAPON_CHARGE_TIME 5000

#ifdef QAGAME
extern void G_CheapWeaponFire(int entNum, int ev);
extern qboolean TryGrapple(gentity_t *ent); //g_cmds.c
extern void trap_FX_PlayEffect( const char *file, vec3_t org, vec3_t fwd, int vol, int rad );
#endif

#include "../namespace_begin.h"
extern qboolean BG_FullBodyTauntAnim( int anim );
extern float PM_WalkableGroundDistance(void);
extern qboolean PM_GroundSlideOkay( float zNormal );
extern saberInfo_t *BG_MySaber( int clientNum, int saberNum );

pmove_t         *pm;
pml_t           pml;

bgEntity_t *pm_entSelf = NULL;
bgEntity_t *pm_entVeh = NULL;

qboolean gPMDoSlowFall = qfalse;

qboolean pm_cancelOutZoom = qfalse;

// movement parameters
float   pm_stopspeed = 100.0f;
float   pm_duckScale = 0.50f;
float   pm_swimScale = 0.50f;
float   pm_wadeScale = 0.70f;

float   pm_vehicleaccelerate = 36.0f;
float   pm_accelerate = 10.0f;
float   pm_airaccelerate = 1.0f;
float   pm_wateraccelerate = 4.0f;
float   pm_flyaccelerate = 8.0f;

float   pm_friction = 6.0f;
float   pm_waterfriction = 1.0f;
float   pm_flightfriction = 3.0f;
float   pm_spectatorfriction = 5.0f;

int             c_pmove = 0;

float forceSpeedLevels[4] = 
{
        1, //rank 0?
        1.25,
        1.5,
        1.75
};

int forcePowerNeeded[NUM_FORCE_POWER_LEVELS][NUM_FORCE_POWERS] = 
{
        { //nothing should be usable at rank 0..
                999,//FP_HEAL,//instant
                999,//FP_LEVITATION,//hold/duration
                999,//FP_SPEED,//duration
                999,//FP_PUSH,//hold/duration
                999,//FP_PULL,//hold/duration
                999,//FP_TELEPATHY,//instant
                999,//FP_GRIP,//hold/duration
                999,//FP_LIGHTNING,//hold/duration
                999,//FP_RAGE,//duration
                999,//FP_PROTECT,//duration
                999,//FP_ABSORB,//duration
                999,//FP_TEAM_HEAL,//instant
                999,//FP_TEAM_FORCE,//instant
                999,//FP_DRAIN,//hold/duration
                999,//FP_SEE,//duration
                999,//FP_SABER_OFFENSE,
                999,//FP_SABER_DEFENSE,
                999//FP_SABERTHROW,
                //NUM_FORCE_POWERS
        },
        {
                65,//FP_HEAL,//instant //was 25, but that was way too little
                10,//FP_LEVITATION,//hold/duration
                50,//FP_SPEED,//duration
                20,//FP_PUSH,//hold/duration
                20,//FP_PULL,//hold/duration
                20,//FP_TELEPATHY,//instant
                30,//FP_GRIP,//hold/duration
                1,//FP_LIGHTNING,//hold/duration
                50,//FP_RAGE,//duration
                50,//FP_PROTECT,//duration
                50,//FP_ABSORB,//duration
                50,//FP_TEAM_HEAL,//instant
                50,//FP_TEAM_FORCE,//instant
                20,//FP_DRAIN,//hold/duration
                20,//FP_SEE,//duration
                0,//FP_SABER_OFFENSE,
                2,//FP_SABER_DEFENSE,
                20//FP_SABERTHROW,
                //NUM_FORCE_POWERS
        },
        {
                60,//FP_HEAL,//instant
                10,//FP_LEVITATION,//hold/duration
                50,//FP_SPEED,//duration
                20,//FP_PUSH,//hold/duration
                20,//FP_PULL,//hold/duration
                20,//FP_TELEPATHY,//instant
                30,//FP_GRIP,//hold/duration
                1,//FP_LIGHTNING,//hold/duration
                50,//FP_RAGE,//duration
                25,//FP_PROTECT,//duration
                25,//FP_ABSORB,//duration
                33,//FP_TEAM_HEAL,//instant
                33,//FP_TEAM_FORCE,//instant
                20,//FP_DRAIN,//hold/duration
                20,//FP_SEE,//duration
                0,//FP_SABER_OFFENSE,
                1,//FP_SABER_DEFENSE,
                20//FP_SABERTHROW,
                //NUM_FORCE_POWERS
        },
        {
                50,//FP_HEAL,//instant //You get 5 points of health.. for 50 force points!
                10,//FP_LEVITATION,//hold/duration
                50,//FP_SPEED,//duration
                20,//FP_PUSH,//hold/duration
                20,//FP_PULL,//hold/duration
                20,//FP_TELEPATHY,//instant
                60,//FP_GRIP,//hold/duration
                1,//FP_LIGHTNING,//hold/duration
                50,//FP_RAGE,//duration
                10,//FP_PROTECT,//duration
                10,//FP_ABSORB,//duration
                25,//FP_TEAM_HEAL,//instant
                25,//FP_TEAM_FORCE,//instant
                20,//FP_DRAIN,//hold/duration
                20,//FP_SEE,//duration
                0,//FP_SABER_OFFENSE,
                0,//FP_SABER_DEFENSE,
                20//FP_SABERTHROW,
                //NUM_FORCE_POWERS
        }
};

float forceJumpHeight[NUM_FORCE_POWER_LEVELS] = 
{
        32,//normal jump (+stepheight+crouchdiff = 66)
        96,//(+stepheight+crouchdiff = 130)
        192,//(+stepheight+crouchdiff = 226)
        384//(+stepheight+crouchdiff = 418)
};

float forceJumpStrength[NUM_FORCE_POWER_LEVELS] = 
{
        JUMP_VELOCITY,//normal jump
        420,
        590,
        840
};

//rww - Get a pointer to the bgEntity by the index
bgEntity_t *PM_BGEntForNum( int num )
{
        bgEntity_t *ent;

        if (!pm)
        {
                assert(!"You cannot call PM_BGEntForNum outside of pm functions!");
                return NULL;
        }

        if (!pm->baseEnt)
        {
                assert(!"Base entity address not set");
                return NULL;
        }

        if (!pm->entSize)
        {
                assert(!"sizeof(ent) is 0, impossible (not set?)");
                return NULL;
        }

        assert(num >= 0 && num < MAX_GENTITIES);

    ent = (bgEntity_t *)((byte *)pm->baseEnt + pm->entSize*(num));

        return ent;
}

qboolean BG_SabersOff( playerState_t *ps )
{
        if ( !ps->saberHolstered )
        {
                return qfalse;
        }
        if ( ps->fd.saberAnimLevelBase == SS_DUAL
                || ps->fd.saberAnimLevelBase == SS_STAFF )
        {
                if ( ps->saberHolstered < 2 )
                {
                        return qfalse;
                }
        }
        return qtrue;
}

qboolean BG_KnockDownable(playerState_t *ps)
{
        if (!ps)
        { //just for safety
                return qfalse;
        }

        if (ps->m_iVehicleNum)
        { //riding a vehicle, don't knock me down
                return qfalse;
        }

        if (ps->emplacedIndex)
        { //using emplaced gun or eweb, can't be knocked down
                return qfalse;
        }

        //ok, I guess?
        return qtrue;
}

//I should probably just do a global inline sometime.
#ifndef __LCC__
#define PM_INLINE ID_INLINE
#else
#define PM_INLINE //none
#endif

//hacky assumption check, assume any client non-humanoid is a rocket trooper
qboolean PM_INLINE PM_IsRocketTrooper(void)
{
        /*
        if (pm->ps->clientNum < MAX_CLIENTS &&
                pm->gametype == GT_SIEGE &&
                pm->nonHumanoid)
        {
                return qtrue;
        }
        */

        return qfalse;
}

int PM_GetSaberStance(void)
{
        int anim = BOTH_STAND2;
        saberInfo_t *saber1 = BG_MySaber( pm->ps->clientNum, 0 );
        saberInfo_t *saber2 = BG_MySaber( pm->ps->clientNum, 1 );

        if (!pm->ps->saberEntityNum)
        { //lost it
                return BOTH_STAND1;
        }

        if ( BG_SabersOff( pm->ps ) )
        {
                return BOTH_STAND1;
        }

        if ( saber1
                && saber1->readyAnim != -1 )
        {
                return saber1->readyAnim;
        }

        if ( saber2
                && saber2->readyAnim != -1 )
        {
                return saber2->readyAnim;
        }

        if ( saber1 
                && saber2
                && !pm->ps->saberHolstered )
        {//dual sabers, both on
                return BOTH_SABERDUAL_STANCE;
        }

        switch ( pm->ps->fd.saberAnimLevel )
        {
        case SS_DUAL:
                anim = BOTH_SABERDUAL_STANCE;
                break;
        case SS_STAFF:
                anim = BOTH_SABERSTAFF_STANCE;
                break;
        case SS_FAST:
        case SS_TAVION:
                anim = BOTH_SABERFAST_STANCE;
                break;
        case SS_STRONG:
                anim = BOTH_SABERSLOW_STANCE;
                break;
        case SS_NONE:
        case SS_MEDIUM:
        case SS_DESANN:
        default:
                anim = BOTH_STAND2;
                break;
        }
        return anim;
}

qboolean PM_DoSlowFall(void)
{
        if ( ( (pm->ps->legsAnim) == BOTH_WALL_RUN_RIGHT || (pm->ps->legsAnim) == BOTH_WALL_RUN_LEFT ) && pm->ps->legsTimer > 500 )
        {
                return qtrue;
        }

        return qfalse;
}

//begin vehicle functions crudely ported from sp -rww
/*
====================================================================
void pitch_roll_for_slope (edict_t *forwhom, vec3_t *slope, vec3_t storeAngles )

MG

This will adjust the pitch and roll of a monster to match
a given slope - if a non-'0 0 0' slope is passed, it will
use that value, otherwise it will use the ground underneath
the monster.  If it doesn't find a surface, it does nothinh\g
and returns.
====================================================================
*/

void PM_pitch_roll_for_slope( bgEntity_t *forwhom, vec3_t pass_slope, vec3_t storeAngles )
{
        vec3_t  slope;
        vec3_t  nvf, ovf, ovr, startspot, endspot, new_angles = { 0, 0, 0 };
        float   pitch, mod, dot;

        //if we don't have a slope, get one
        if( !pass_slope || VectorCompare( vec3_origin, pass_slope ) )
        {
                trace_t trace;

                VectorCopy( pm->ps->origin, startspot );
                startspot[2] += pm->mins[2] + 4;
                VectorCopy( startspot, endspot );
                endspot[2] -= 300;
                pm->trace( &trace, pm->ps->origin, vec3_origin, vec3_origin, endspot, forwhom->s.number, MASK_SOLID );
//              if(trace_fraction>0.05&&forwhom.movetype==MOVETYPE_STEP)
//                      forwhom.flags(-)FL_ONGROUND;

                if ( trace.fraction >= 1.0 )
                        return;

                if( !( &trace.plane ) )
                        return;

                if ( VectorCompare( vec3_origin, trace.plane.normal ) )
                        return;

                VectorCopy( trace.plane.normal, slope );
        }
        else
        {
                VectorCopy( pass_slope, slope );
        }

        if ( forwhom->s.NPC_class == CLASS_VEHICLE )
        {//special code for vehicles
                Vehicle_t *pVeh = forwhom->m_pVehicle;
                vec3_t tempAngles;

                tempAngles[PITCH] = tempAngles[ROLL] = 0;
                tempAngles[YAW] = pVeh->m_vOrientation[YAW];
                AngleVectors( tempAngles, ovf, ovr, NULL );
        }
        else
        {
                AngleVectors( pm->ps->viewangles, ovf, ovr, NULL );
        }

        vectoangles( slope, new_angles );
        pitch = new_angles[PITCH] + 90;
        new_angles[ROLL] = new_angles[PITCH] = 0;

        AngleVectors( new_angles, nvf, NULL, NULL );

        mod = DotProduct( nvf, ovr );

        if ( mod<0 )
                mod = -1;
        else
                mod = 1;

        dot = DotProduct( nvf, ovf );

        if ( storeAngles )
        {
                storeAngles[PITCH] = dot * pitch;
                storeAngles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod);
        }
        else //if ( forwhom->client )
        {
                float oldmins2;

                pm->ps->viewangles[PITCH] = dot * pitch;
                pm->ps->viewangles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod);
                oldmins2 = pm->mins[2];
                pm->mins[2] = -24 + 12 * fabs(pm->ps->viewangles[PITCH])/180.0f;
                //FIXME: if it gets bigger, move up
                if ( oldmins2 > pm->mins[2] )
                {//our mins is now lower, need to move up
                        //FIXME: trace?
                        pm->ps->origin[2] += (oldmins2 - pm->mins[2]);
                        //forwhom->currentOrigin[2] = forwhom->client->ps.origin[2];
                        //gi.linkentity( forwhom );
                }
        }
        /*
        else
        {
                forwhom->currentAngles[PITCH] = dot * pitch;
                forwhom->currentAngles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod);
        }
        */
}

#define         FLY_NONE        0
#define         FLY_NORMAL      1
#define         FLY_VEHICLE     2
#define         FLY_HOVER       3
static int pm_flying = FLY_NONE;

void PM_SetSpecialMoveValues (void)
{
        bgEntity_t *pEnt;
        
        if (pm->ps->clientNum < MAX_CLIENTS)
        { //we know that real players aren't vehs
                pm_flying = FLY_NONE;
                return;
        }

        //default until we decide otherwise
        pm_flying = FLY_NONE;

        pEnt = pm_entSelf;

        if ( pEnt )
        {
                if ( (pm->ps->eFlags2&EF2_FLYING) )// pm->gent->client->moveType == MT_FLYSWIM )
                {
                        pm_flying = FLY_NORMAL;
                }
                else if ( pEnt->s.NPC_class == CLASS_VEHICLE )
                {
                        if ( pEnt->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER )
                        {
                                pm_flying = FLY_VEHICLE;
                        }
                        else if ( pEnt->m_pVehicle->m_pVehicleInfo->hoverHeight > 0 )
                        {
                                pm_flying = FLY_HOVER;
                        }
                }
        }
}

static void PM_SetVehicleAngles( vec3_t normal )
{
        bgEntity_t *pEnt = pm_entSelf;
        Vehicle_t *pVeh;
        vec3_t  vAngles;
        float vehicleBankingSpeed;
        float pitchBias;
        int i;

        if ( !pEnt || pEnt->s.NPC_class != CLASS_VEHICLE )
        {
                return;
        }

        pVeh = pEnt->m_pVehicle;
        
        //float curVehicleBankingSpeed;
        vehicleBankingSpeed = (pVeh->m_pVehicleInfo->bankingSpeed*32.0f)*pml.frametime;//0.25f

        if ( vehicleBankingSpeed <= 0 
                || ( pVeh->m_pVehicleInfo->pitchLimit == 0 && pVeh->m_pVehicleInfo->rollLimit == 0 ) )
        {//don't bother, this vehicle doesn't bank
                return;
        }
        //FIXME: do 3 traces to define a plane and use that... smoothes it out some, too...
        //pitch_roll_for_slope( pm->gent, normal, vAngles );
        //FIXME: maybe have some pitch control in water and/or air?
        
        if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
        {
                pitchBias = 0.0f;
        }
        else
        {
                //FIXME: gravity does not matter in SPACE!!!
                //center of gravity affects pitch in air/water (FIXME: what about roll?)
                pitchBias = 90.0f*pVeh->m_pVehicleInfo->centerOfGravity[0];//if centerOfGravity is all the way back (-1.0f), vehicle pitches up 90 degrees when in air
        }

        VectorClear( vAngles );
        if ( pm->waterlevel > 0 )
        {//in water
                //view pitch has some influence when in water
                //FIXME: take center of gravity into account?
                vAngles[PITCH] += (pm->ps->viewangles[PITCH]-vAngles[PITCH])*0.75f + (pitchBias*0.5);
        }
        else if ( normal )
        {//have a valid surface below me
                PM_pitch_roll_for_slope( pEnt, normal, vAngles );
                if ( (pml.groundTrace.contents&(CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA)) )
                {//on water
                        //view pitch has some influence when on a fluid surface
                        //FIXME: take center of gravity into account
                        vAngles[PITCH] += (pm->ps->viewangles[PITCH]-vAngles[PITCH])*0.5f + (pitchBias*0.5f);
                }
        }
        else
        {//in air, let pitch match view...?
                //FIXME: take center of gravity into account
                vAngles[PITCH] = pm->ps->viewangles[PITCH]*0.5f + pitchBias;
                //don't bank so fast when in the air
                vehicleBankingSpeed *= (0.125f*pml.frametime);
        }
        //NOTE: if angles are flat and we're moving through air (not on ground),
        //              then pitch/bank?
        if ( pVeh->m_pVehicleInfo->rollLimit > 0 )
        {
                //roll when banking
                vec3_t  velocity;
                float   speed;
                VectorCopy( pm->ps->velocity, velocity );
                velocity[2] = 0.0f;
                speed = VectorNormalize( velocity );
                if ( speed > 32.0f || speed < -32.0f ) 
                {
                        vec3_t  rt, tempVAngles;
                        float   side;
                        float   dp;

                        // Magic number fun!  Speed is used for banking, so modulate the speed by a sine wave
                        //FIXME: this banks too early
                        speed *= sin( (150 + pml.frametime) * 0.003 );

                        // Clamp to prevent harsh rolling
                        if ( speed > 60 )
                                speed = 60;

                        VectorCopy( pVeh->m_vOrientation, tempVAngles );
                        tempVAngles[ROLL] = 0;
                        AngleVectors( tempVAngles, NULL, rt, NULL );
                        dp = DotProduct( velocity, rt );
                        side = speed * dp;
                        vAngles[ROLL] -= side;
                }
        }

        //cap
        if ( pVeh->m_pVehicleInfo->pitchLimit != -1 )
        {
                if ( vAngles[PITCH] > pVeh->m_pVehicleInfo->pitchLimit )
                {
                        vAngles[PITCH] = pVeh->m_pVehicleInfo->pitchLimit;
                }
                else if ( vAngles[PITCH] < -pVeh->m_pVehicleInfo->pitchLimit )
                {
                        vAngles[PITCH] = -pVeh->m_pVehicleInfo->pitchLimit;
                }
        }

        if ( vAngles[ROLL] > pVeh->m_pVehicleInfo->rollLimit )
        {
                vAngles[ROLL] = pVeh->m_pVehicleInfo->rollLimit;
        }
        else if ( vAngles[ROLL] < -pVeh->m_pVehicleInfo->rollLimit )
        {
                vAngles[ROLL] = -pVeh->m_pVehicleInfo->rollLimit;
        }
        
        //do it
        for ( i = 0; i < 3; i++ )
        {
                if ( i == YAW )
                {//yawing done elsewhere
                        continue;
                }
                //bank faster the higher the difference is
                /*
                else if ( i == PITCH )
                {
                        curVehicleBankingSpeed = vehicleBankingSpeed*fabs(AngleNormalize180(AngleSubtract( vAngles[PITCH], pVeh->m_vOrientation[PITCH] )))/(g_vehicleInfo[pm->ps->vehicleIndex].pitchLimit/2.0f);
                }
                else if ( i == ROLL )
                {
                        curVehicleBankingSpeed = vehicleBankingSpeed*fabs(AngleNormalize180(AngleSubtract( vAngles[ROLL], pVeh->m_vOrientation[ROLL] )))/(g_vehicleInfo[pm->ps->vehicleIndex].rollLimit/2.0f);
                }

                if ( curVehicleBankingSpeed )
                */
                {
                        if ( pVeh->m_vOrientation[i] >= vAngles[i] + vehicleBankingSpeed )
                        {
                                pVeh->m_vOrientation[i] -= vehicleBankingSpeed;
                        }
                        else if ( pVeh->m_vOrientation[i] <= vAngles[i] - vehicleBankingSpeed )
                        {
                                pVeh->m_vOrientation[i] += vehicleBankingSpeed;
                        }
                        else
                        {
                                pVeh->m_vOrientation[i] = vAngles[i];
                        }
                }
        }
}

#ifndef QAGAME
extern vmCvar_t cg_paused;
#endif

void BG_ExternThisSoICanRecompileInDebug( Vehicle_t *pVeh, playerState_t *riderPS )
{
/*
        float pitchSubtract, pitchDelta, yawDelta;
        //Com_Printf( S_COLOR_RED"PITCH: %4.2f, YAW: %4.2f, ROLL: %4.2f\n", riderPS->viewangles[0],riderPS->viewangles[1],riderPS->viewangles[2]);
        yawDelta = AngleSubtract(riderPS->viewangles[YAW],pVeh->m_vPrevRiderViewAngles[YAW]);
#ifndef QAGAME
        if ( !cg_paused.integer )
        {
                //Com_Printf( "%d - yawDelta %4.2f\n", pm->cmd.serverTime, yawDelta );
        }
#endif
        yawDelta *= (4.0f*pVeh->m_fTimeModifier);
        pVeh->m_vOrientation[ROLL] -= yawDelta;

        pitchDelta = AngleSubtract(riderPS->viewangles[PITCH],pVeh->m_vPrevRiderViewAngles[PITCH]);
        pitchDelta *= (2.0f*pVeh->m_fTimeModifier);
        pitchSubtract = pitchDelta * (fabs(pVeh->m_vOrientation[ROLL])/90.0f);
        pVeh->m_vOrientation[PITCH] += pitchDelta-pitchSubtract;
        if ( pVeh->m_vOrientation[ROLL] > 0 )
        {
                pVeh->m_vOrientation[YAW] += pitchSubtract;
        }
        else
        {
                pVeh->m_vOrientation[YAW] -= pitchSubtract;
        }
        pVeh->m_vOrientation[PITCH] = AngleNormalize180( pVeh->m_vOrientation[PITCH] );
        pVeh->m_vOrientation[YAW] = AngleNormalize360( pVeh->m_vOrientation[YAW] );
        pVeh->m_vOrientation[ROLL] = AngleNormalize180( pVeh->m_vOrientation[ROLL] );

        VectorCopy( riderPS->viewangles, pVeh->m_vPrevRiderViewAngles );
*/
}

void BG_VehicleTurnRateForSpeed( Vehicle_t *pVeh, float speed, float *mPitchOverride, float *mYawOverride )
{
        if ( pVeh && pVeh->m_pVehicleInfo )
        {
                float speedFrac = 1.0f;
                if ( pVeh->m_pVehicleInfo->speedDependantTurning )
                {
                        if ( pVeh->m_LandTrace.fraction >= 1.0f 
                                || pVeh->m_LandTrace.plane.normal[2] < MIN_LANDING_SLOPE  )
                        {
                                speedFrac = (speed/(pVeh->m_pVehicleInfo->speedMax*0.75f));
                                if ( speedFrac < 0.25f )
                                {
                                        speedFrac = 0.25f;
                                }
                                else if ( speedFrac > 1.0f )
                                {
                                        speedFrac = 1.0f;
                                }
                        }
                }
                if ( pVeh->m_pVehicleInfo->mousePitch )
                {
                        *mPitchOverride = pVeh->m_pVehicleInfo->mousePitch*speedFrac;
                }
                if ( pVeh->m_pVehicleInfo->mouseYaw )
                {
                        *mYawOverride = pVeh->m_pVehicleInfo->mouseYaw*speedFrac;
                }
        }
}

#include "../namespace_end.h"

// Following couple things don't belong in the DLL namespace!
#ifdef QAGAME
typedef struct gentity_s gentity_t;
gentity_t *G_PlayEffectID(const int fxID, vec3_t org, vec3_t ang);
#endif

#include "../namespace_begin.h"

static void PM_GroundTraceMissed( void );
void PM_HoverTrace( void )
{
        Vehicle_t *pVeh;
        float hoverHeight;
        vec3_t          point, vAng, fxAxis[3];
        trace_t         *trace;
        float relativeWaterLevel;

        bgEntity_t *pEnt = pm_entSelf;
        if ( !pEnt || pEnt->s.NPC_class != CLASS_VEHICLE )
        {
                return;
        }

        pVeh = pEnt->m_pVehicle;
        hoverHeight = pVeh->m_pVehicleInfo->hoverHeight;
        trace = &pml.groundTrace;

        pml.groundPlane = qfalse;

        //relativeWaterLevel = (pm->ps->waterheight - (pm->ps->origin[2]+pm->mins[2]));
        relativeWaterLevel = pm->waterlevel; //I.. guess this works
        if ( pm->waterlevel && relativeWaterLevel >= 0 )
        {//in water
                if ( pVeh->m_pVehicleInfo->bouyancy <= 0.0f )
                {//sink like a rock
                }
                else
                {//rise up
                        float floatHeight = (pVeh->m_pVehicleInfo->bouyancy * ((pm->maxs[2]-pm->mins[2])*0.5f)) - (hoverHeight*0.5f);//1.0f should make you float half-in, half-out of water
                        if ( relativeWaterLevel > floatHeight )
                        {//too low, should rise up
                                pm->ps->velocity[2] += (relativeWaterLevel - floatHeight) * pVeh->m_fTimeModifier;
                        }
                }
                //if ( pm->ps->waterheight < pm->ps->origin[2]+pm->maxs[2] )
                if (pm->waterlevel <= 1)
                {//part of us is sticking out of water
                        if ( fabs(pm->ps->velocity[0]) + fabs(pm->ps->velocity[1]) > 100 )
                        {//moving at a decent speed
                                if ( Q_irand( pml.frametime, 100 ) >= 50 )
                                {//splash
                                        vec3_t wakeOrg;

                                        vAng[PITCH] = vAng[ROLL] = 0;
                                        vAng[YAW] = pVeh->m_vOrientation[YAW];
                                        AngleVectors( vAng, fxAxis[2], fxAxis[1], fxAxis[0] );
                                        VectorCopy( pm->ps->origin, wakeOrg );
                                        //wakeOrg[2] = pm->ps->waterheight;
                                        if (pm->waterlevel >= 2)
                                        {
                                                wakeOrg[2] = pm->ps->origin[2]+16;
                                        }
                                        else
                                        {
                                                wakeOrg[2] = pm->ps->origin[2];
                                        }
#ifdef QAGAME //yeah, this is kind of crappy and makes no use of prediction whatsoever
                                        if ( pVeh->m_pVehicleInfo->iWakeFX )
                                        {
                                                //G_PlayEffectID( pVeh->m_pVehicleInfo->iWakeFX, wakeOrg, fxAxis[0] );
                                                //tempent use bad!
                                                G_AddEvent((gentity_t *)pEnt, EV_PLAY_EFFECT_ID, pVeh->m_pVehicleInfo->iWakeFX);
                                        }
#endif
                                }
                        }
                }
        }
        else
        {
                int traceContents;
                float minNormal = (float)MIN_WALK_NORMAL;
                minNormal = pVeh->m_pVehicleInfo->maxSlope;

                point[0] = pm->ps->origin[0];
                point[1] = pm->ps->origin[1];
                point[2] = pm->ps->origin[2] - hoverHeight;

                //FIXME: check for water, too?  If over water, go slower and make wave effect
                //              If *in* water, go really slow and use bouyancy stat to determine how far below surface to float

                //NOTE: if bouyancy is 2.0f or higher, you float over water like it's solid ground.
                //              if it's 1.0f, you sink halfway into water.  If it's 0, you sink...
                traceContents = pm->tracemask;
                if ( pVeh->m_pVehicleInfo->bouyancy >= 2.0f )
                {//sit on water
                        traceContents |= (CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA);
                }
                pm->trace( trace, pm->ps->origin, pm->mins, pm->maxs, point, pm->ps->clientNum, traceContents );
                if (trace->plane.normal[0] > 0.5f || trace->plane.normal[0] < -0.5f ||
                        trace->plane.normal[1] > 0.5f || trace->plane.normal[1] < -0.5f)
                { //steep slanted hill, don't go up it.
                        float d = fabs(trace->plane.normal[0]);
                        float e = fabs(trace->plane.normal[1]);
                        if (e > d)
                        {
                                d = e;
                        }
                        pm->ps->velocity[2] = -300.0f*d;
                }
                else if ( trace->plane.normal[2] >= minNormal ) 
                {//not a steep slope, so push us up
                        if ( trace->fraction < 1.0f )
                        {//push up off ground
                                float hoverForce = pVeh->m_pVehicleInfo->hoverStrength;
                                if ( trace->fraction > 0.5f )
                                {
                                        pm->ps->velocity[2] += (1.0f-trace->fraction)*hoverForce*pVeh->m_fTimeModifier;
                                }
                                else
                                {
                                        pm->ps->velocity[2] += (0.5f-(trace->fraction*trace->fraction))*hoverForce*2.0f*pVeh->m_fTimeModifier;
                                }
                                if ( (trace->contents&(CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA)) )
                                {//hovering on water, make a spash if moving
                                        if ( fabs(pm->ps->velocity[0]) + fabs(pm->ps->velocity[1]) > 100 )
                                        {//moving at a decent speed
                                                if ( Q_irand( pml.frametime, 100 ) >= 50 )
                                                {//splash
                                                        vAng[PITCH] = vAng[ROLL] = 0;
                                                        vAng[YAW] = pVeh->m_vOrientation[YAW];
                                                        AngleVectors( vAng, fxAxis[2], fxAxis[1], fxAxis[0] );
#ifdef QAGAME
                                                        if ( pVeh->m_pVehicleInfo->iWakeFX )
                                                        {
                                                                G_PlayEffectID( pVeh->m_pVehicleInfo->iWakeFX, trace->endpos, fxAxis[0] );
                                                        }
#endif
                                                }
                                        }
                                }
                                pml.groundPlane = qtrue;
                        }
                }
        }
        if ( pml.groundPlane )
        {
                PM_SetVehicleAngles( pml.groundTrace.plane.normal );
                // We're on the ground.
                pVeh->m_ulFlags &= ~VEH_FLYING;

                pVeh->m_vAngularVelocity = 0.0f;
        }
        else
        {
                PM_SetVehicleAngles( NULL );
                // We're flying in the air.
                pVeh->m_ulFlags |= VEH_FLYING;
                //groundTrace

                if (pVeh->m_vAngularVelocity==0.0f)
                {
                        pVeh->m_vAngularVelocity = pVeh->m_vOrientation[YAW] - pVeh->m_vPrevOrientation[YAW];
                        if (pVeh->m_vAngularVelocity<-15.0f)
                        {
                                pVeh->m_vAngularVelocity = -15.0f;
                        }
                        if (pVeh->m_vAngularVelocity> 15.0f)
                        {
                                pVeh->m_vAngularVelocity =  15.0f;
                        }
                }
                //pVeh->m_vAngularVelocity *= 0.95f;            // Angular Velocity Decays Over Time
                if (pVeh->m_vAngularVelocity > 0.0f)
                {
                        pVeh->m_vAngularVelocity -= pml.frametime;
                        if (pVeh->m_vAngularVelocity < 0.0f)
                        {
                                pVeh->m_vAngularVelocity = 0.0f;
                        }
                }
                else if (pVeh->m_vAngularVelocity < 0.0f)
                {
                        pVeh->m_vAngularVelocity += pml.frametime;
                        if (pVeh->m_vAngularVelocity > 0.0f)
                        {
                                pVeh->m_vAngularVelocity = 0.0f;
                        }
                }
        }
        PM_GroundTraceMissed();
}
//end vehicle functions crudely ported from sp -rww

/*
===============
PM_AddEvent

===============
*/
void PM_AddEvent( int newEvent ) {
        BG_AddPredictableEventToPlayerstate( newEvent, 0, pm->ps );
}

void PM_AddEventWithParm( int newEvent, int parm ) 
{
        BG_AddPredictableEventToPlayerstate( newEvent, parm, pm->ps );
}

/*
===============
PM_AddTouchEnt
===============
*/
void PM_AddTouchEnt( int entityNum ) {
        int             i;

        if ( entityNum == ENTITYNUM_WORLD ) {
                return;
        }
        if ( pm->numtouch == MAXTOUCH ) {
                return;
        }

        // see if it is already added
        for ( i = 0 ; i < pm->numtouch ; i++ ) {
                if ( pm->touchents[ i ] == entityNum ) {
                        return;
                }
        }

        // add it
        pm->touchents[pm->numtouch] = entityNum;
        pm->numtouch++;
}


/*
==================
PM_ClipVelocity

Slide off of the impacting surface
==================
*/
void PM_ClipVelocity( vec3_t in, vec3_t normal, vec3_t out, float overbounce ) {
        float   backoff;
        float   change;
        float   oldInZ;
        int             i;
        
        if ( (pm->ps->pm_flags&PMF_STUCK_TO_WALL) )
        {//no sliding!
                VectorCopy( in, out );
                return;
        }
        oldInZ = in[2];

        backoff = DotProduct (in, normal);
        
        if ( backoff < 0 ) {
                backoff *= overbounce;
        } else {
                backoff /= overbounce;
        }

        for ( i=0 ; i<3 ; i++ ) {
                change = normal[i]*backoff;
                out[i] = in[i] - change;
        }
        if ( pm->stepSlideFix )
        {
                if ( pm->ps->clientNum < MAX_CLIENTS//normal player
                        && pm->ps->groundEntityNum != ENTITYNUM_NONE//on the ground
                        && normal[2] < MIN_WALK_NORMAL )//sliding against a steep slope
                {//if walking on the ground, don't slide up slopes that are too steep to walk on
                        out[2] = oldInZ;
                }
        }
}


/*
==================
PM_Friction

Handles both ground friction and water friction
==================
*/
static void PM_Friction( void ) {
        vec3_t  vec;
        float   *vel;
        float   speed, newspeed, control;
        float   drop;
        bgEntity_t *pEnt = NULL;
        
        vel = pm->ps->velocity;
        
        VectorCopy( vel, vec );
        if ( pml.walking ) {
                vec[2] = 0;     // ignore slope movement
        }

        speed = VectorLength(vec);
        if (speed < 1) {
                vel[0] = 0;
                vel[1] = 0;             // allow sinking underwater
                if (pm->ps->pm_type == PM_SPECTATOR)
                {
                        vel[2] = 0;
                }
                // FIXME: still have z friction underwater?
                return;
        }

        drop = 0;

        if (pm->ps->clientNum >= MAX_CLIENTS)
        {
                pEnt = pm_entSelf;
        }

        // apply ground friction, even if on ladder
        if (pm_flying != FLY_VEHICLE &&
                pEnt &&
                pEnt->s.NPC_class == CLASS_VEHICLE &&
                pEnt->m_pVehicle &&
                pEnt->m_pVehicle->m_pVehicleInfo->type != VH_ANIMAL &&
                pEnt->m_pVehicle->m_pVehicleInfo->type != VH_WALKER &&
                pEnt->m_pVehicle->m_pVehicleInfo->friction )
        {
                float friction = pEnt->m_pVehicle->m_pVehicleInfo->friction;
                if ( !(pm->ps->pm_flags & PMF_TIME_KNOCKBACK) /*&& !(pm->ps->pm_flags & PMF_TIME_NOFRICTION)*/ ) 
                {
                        control = speed < pm_stopspeed ? pm_stopspeed : speed;
                        drop += control*friction*pml.frametime;
                        /*
                        if ( Flying == FLY_HOVER )
                        {
                                if ( pm->cmd.rightmove )
                                {//if turning, increase friction
                                        control *= 2.0f;
                                }
                                if ( pm->ps->groundEntityNum < ENTITYNUM_NONE ) 
                                {//on the ground
                                        drop += control*friction*pml.frametime;
                                }
                                else if ( pml.groundPlane )
                                {//on a slope
                                        drop += control*friction*2.0f*pml.frametime;
                                }
                                else
                                {//in air
                                        drop += control*2.0f*friction*pml.frametime;
                                }
                        }
                        */
                }
        }
        else if ( pm_flying != FLY_NORMAL && pm_flying != FLY_VEHICLE )
        {
                // apply ground friction
                if ( pm->waterlevel <= 1 ) {
                        if ( pml.walking && !(pml.groundTrace.surfaceFlags & SURF_SLICK) ) {
                                // if getting knocked back, no friction
                                if ( ! (pm->ps->pm_flags & PMF_TIME_KNOCKBACK) ) {
                                        control = speed < pm_stopspeed ? pm_stopspeed : speed;
                                        drop += control*pm_friction*pml.frametime;
                                }
                        }
                }
        }

        if ( pm_flying == FLY_VEHICLE )
        {
                if ( !(pm->ps->pm_flags & PMF_TIME_KNOCKBACK) ) 
                {
                        control = speed;// < pm_stopspeed ? pm_stopspeed : speed;
                        drop += control*pm_friction*pml.frametime;
                }
        }

        // apply water friction even if just wading
        if ( pm->waterlevel ) {
                drop += speed*pm_waterfriction*pm->waterlevel*pml.frametime;
        }
        // If on a client then there is no friction
        else if ( pm->ps->groundEntityNum < MAX_CLIENTS )
        {
                drop = 0;
        }

        if ( pm->ps->pm_type == PM_SPECTATOR || pm->ps->pm_type == PM_FLOAT )
        {
                if (pm->ps->pm_type == PM_FLOAT)
                { //almost no friction while floating
                        drop += speed*0.1*pml.frametime;
                }
                else
                {
                        drop += speed*pm_spectatorfriction*pml.frametime;
                }
        }

        // scale the velocity
        newspeed = speed - drop;
        if (newspeed < 0) {
                newspeed = 0;
        }
        newspeed /= speed;

        vel[0] = vel[0] * newspeed;
        vel[1] = vel[1] * newspeed;
        vel[2] = vel[2] * newspeed;
}


/*
==============
PM_Accelerate

Handles user intended acceleration
==============
*/
static void PM_Accelerate( vec3_t wishdir, float wishspeed, float accel )
{
        if (pm->gametype != GT_SIEGE 
                || pm->ps->m_iVehicleNum 
                || pm->ps->clientNum >= MAX_CLIENTS 
                || pm->ps->pm_type != PM_NORMAL)
        { //standard method, allows "bunnyhopping" and whatnot
                int                     i;
                float           addspeed, accelspeed, currentspeed;

                currentspeed = DotProduct (pm->ps->velocity, wishdir);
                addspeed = wishspeed - currentspeed;
                if (addspeed <= 0 && pm->ps->clientNum < MAX_CLIENTS) {
                        return;
                }

                if (addspeed < 0)
                {
                        accelspeed = (-accel)*pml.frametime*wishspeed;
                        if (accelspeed < addspeed) {
                                accelspeed = addspeed;
                        }
                }
                else
                {
                        accelspeed = accel*pml.frametime*wishspeed;
                        if (accelspeed > addspeed) {
                                accelspeed = addspeed;
                        }
                }

                for (i=0 ; i<3 ; i++) {
                        pm->ps->velocity[i] += accelspeed*wishdir[i];   
                }
        }
        else
        { //use the proper way for siege
                vec3_t          wishVelocity;
                vec3_t          pushDir;
                float           pushLen;
                float           canPush;

                VectorScale( wishdir, wishspeed, wishVelocity );
                VectorSubtract( wishVelocity, pm->ps->velocity, pushDir );
                pushLen = VectorNormalize( pushDir );

                canPush = accel*pml.frametime*wishspeed;
                if (canPush > pushLen) {
                        canPush = pushLen;
                }

                VectorMA( pm->ps->velocity, canPush, pushDir, pm->ps->velocity );
        }
}



/*
============
PM_CmdScale

Returns the scale factor to apply to cmd movements
This allows the clients to use axial -127 to 127 values for all directions
without getting a sqrt(2) distortion in speed.
============
*/
static float PM_CmdScale( usercmd_t *cmd ) {
        int             max;
        float   total;
        float   scale;
        int             umove = 0; //cmd->upmove;
                        //don't factor upmove into scaling speed

        max = abs( cmd->forwardmove );
        if ( abs( cmd->rightmove ) > max ) {
                max = abs( cmd->rightmove );
        }
        if ( abs( umove ) > max ) {
                max = abs( umove );
        }
        if ( !max ) {
                return 0;
        }

        total = sqrt( (float)(cmd->forwardmove * cmd->forwardmove
                + cmd->rightmove * cmd->rightmove + umove * umove) );
        scale = (float)pm->ps->speed * max / ( 127.0 * total );

        return scale;
}


/*
================
PM_SetMovementDir

Determine the rotation of the legs reletive
to the facing dir
================
*/
static void PM_SetMovementDir( void ) {
        if ( pm->cmd.forwardmove || pm->cmd.rightmove ) {
                if ( pm->cmd.rightmove == 0 && pm->cmd.forwardmove > 0 ) {
                        pm->ps->movementDir = 0;
                } else if ( pm->cmd.rightmove < 0 && pm->cmd.forwardmove > 0 ) {
                        pm->ps->movementDir = 1;
                } else if ( pm->cmd.rightmove < 0 && pm->cmd.forwardmove == 0 ) {
                        pm->ps->movementDir = 2;
                } else if ( pm->cmd.rightmove < 0 && pm->cmd.forwardmove < 0 ) {
                        pm->ps->movementDir = 3;
                } else if ( pm->cmd.rightmove == 0 && pm->cmd.forwardmove < 0 ) {
                        pm->ps->movementDir = 4;
                } else if ( pm->cmd.rightmove > 0 && pm->cmd.forwardmove < 0 ) {
                        pm->ps->movementDir = 5;
                } else if ( pm->cmd.rightmove > 0 && pm->cmd.forwardmove == 0 ) {
                        pm->ps->movementDir = 6;
                } else if ( pm->cmd.rightmove > 0 && pm->cmd.forwardmove > 0 ) {
                        pm->ps->movementDir = 7;
                }
        } else {
                // if they aren't actively going directly sideways,
                // change the animation to the diagonal so they
                // don't stop too crooked
                if ( pm->ps->movementDir == 2 ) {
                        pm->ps->movementDir = 1;
                } else if ( pm->ps->movementDir == 6 ) {
                        pm->ps->movementDir = 7;
                } 
        }
}

#define METROID_JUMP 1

qboolean PM_ForceJumpingUp(void)
{
        if ( !(pm->ps->fd.forcePowersActive&(1<<FP_LEVITATION)) && pm->ps->fd.forceJumpCharge )
        {//already jumped and let go
                return qfalse;
        }

        if ( BG_InSpecialJump( pm->ps->legsAnim ) )
        {
                return qfalse;
        }

        if (BG_SaberInSpecial(pm->ps->saberMove))
        {
                return qfalse;
        }

        if (BG_SaberInSpecialAttack(pm->ps->legsAnim))
        {
                return qfalse;
        }

        if (BG_HasYsalamiri(pm->gametype, pm->ps))
        {
                return qfalse;
        }

        if (!BG_CanUseFPNow(pm->gametype, pm->ps, pm-&g