pmove.c

Go to the documentation of this file.

/*
Copyright (C) 1997-2001 Id Software, Inc.
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
*/
 
#include "qcommon.h"
 
 
 
#define STEPSIZE    18
 
// all of the locals will be zeroed before each
// pmove, just to make damn sure we don't have
// any differences when running on client or server
 
typedef struct
{
    vec3_t      origin;         // full float precision
    vec3_t      velocity;       // full float precision
 
    vec3_t      forward, right, up;
    float       frametime;
 
 
    csurface_t  *groundsurface;
    cplane_t    groundplane;
    int         groundcontents;
 
    vec3_t      previous_origin;
    qboolean    ladder;
} pml_t;
 
pmove_t     *pm;
pml_t       pml;
 
 
// movement parameters
float   pm_stopspeed = 100;
float   pm_maxspeed = 300;
float   pm_duckspeed = 100;
float   pm_accelerate = 10;
float   pm_airaccelerate = 0;
float   pm_wateraccelerate = 10;
float   pm_friction = 6;
float   pm_waterfriction = 1;
float   pm_waterspeed = 400;
 
/*
 
  walking up a step should kill some velocity
 
*/
 
 
/*
==================
PM_ClipVelocity
 
Slide off of the impacting object
returns the blocked flags (1 = floor, 2 = step / wall)
==================
*/
#define STOP_EPSILON    0.1
 
void PM_ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce)
{
    float   backoff;
    float   change;
    int     i;
    
    backoff = DotProduct (in, normal) * overbounce;
 
    for (i=0 ; i<3 ; i++)
    {
        change = normal[i]*backoff;
        out[i] = in[i] - change;
        if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON)
            out[i] = 0;
    }
}
 
 
 
 
/*
==================
PM_StepSlideMove
 
Each intersection will try to step over the obstruction instead of
sliding along it.
 
Returns a new origin, velocity, and contact entity
Does not modify any world state?
==================
*/
#define MIN_STEP_NORMAL 0.7     // can't step up onto very steep slopes
#define MAX_CLIP_PLANES 5
void PM_StepSlideMove_ (void)
{
    int         bumpcount, numbumps;
    vec3_t      dir;
    float       d;
    int         numplanes;
    vec3_t      planes[MAX_CLIP_PLANES];
    vec3_t      primal_velocity;
    int         i, j;
    trace_t trace;
    vec3_t      end;
    float       time_left;
    
    numbumps = 4;
    
    VectorCopy (pml.velocity, primal_velocity);
    numplanes = 0;
    
    time_left = pml.frametime;
 
    for (bumpcount=0 ; bumpcount<numbumps ; bumpcount++)
    {
        for (i=0 ; i<3 ; i++)
            end[i] = pml.origin[i] + time_left * pml.velocity[i];
 
        trace = pm->trace (pml.origin, pm->mins, pm->maxs, end);
 
        if (trace.allsolid)
        {   // entity is trapped in another solid
            pml.velocity[2] = 0;    // don't build up falling damage
            return;
        }
 
        if (trace.fraction > 0)
        {   // actually covered some distance
            VectorCopy (trace.endpos, pml.origin);
            numplanes = 0;
        }
 
        if (trace.fraction == 1)
             break;     // moved the entire distance
 
        // save entity for contact
        if (pm->numtouch < MAXTOUCH && trace.ent)
        {
            pm->touchents[pm->numtouch] = trace.ent;
            pm->numtouch++;
        }
        
        time_left -= time_left * trace.fraction;
 
        // slide along this plane
        if (numplanes >= MAX_CLIP_PLANES)
        {   // this shouldn't really happen
            VectorCopy (vec3_origin, pml.velocity);
            break;
        }
 
        VectorCopy (trace.plane.normal, planes[numplanes]);
        numplanes++;
 
#if 0
    float       rub;
 
        //
        // modify velocity so it parallels all of the clip planes
        //
        if (numplanes == 1)
        {   // go along this plane
            VectorCopy (pml.velocity, dir);
            VectorNormalize (dir);
            rub = 1.0 + 0.5 * DotProduct (dir, planes[0]);
 
            // slide along the plane
            PM_ClipVelocity (pml.velocity, planes[0], pml.velocity, 1.01);
            // rub some extra speed off on xy axis
            // not on Z, or you can scrub down walls
            pml.velocity[0] *= rub;
            pml.velocity[1] *= rub;
            pml.velocity[2] *= rub;
        }
        else if (numplanes == 2)
        {   // go along the crease
            VectorCopy (pml.velocity, dir);
            VectorNormalize (dir);
            rub = 1.0 + 0.5 * DotProduct (dir, planes[0]);
 
            // slide along the plane
            CrossProduct (planes[0], planes[1], dir);
            d = DotProduct (dir, pml.velocity);
            VectorScale (dir, d, pml.velocity);
 
            // rub some extra speed off
            VectorScale (pml.velocity, rub, pml.velocity);
        }
        else
        {
//          Con_Printf ("clip velocity, numplanes == %i\n",numplanes);
            VectorCopy (vec3_origin, pml.velocity);
            break;
        }
 
#else
//
// modify original_velocity so it parallels all of the clip planes
//
        for (i=0 ; i<numplanes ; i++)
        {
            PM_ClipVelocity (pml.velocity, planes[i], pml.velocity, 1.01);
            for (j=0 ; j<numplanes ; j++)
                if (j != i)
                {
                    if (DotProduct (pml.velocity, planes[j]) < 0)
                        break;  // not ok
                }
            if (j == numplanes)
                break;
        }
        
        if (i != numplanes)
        {   // go along this plane
        }
        else
        {   // go along the crease
            if (numplanes != 2)
            {
//              Con_Printf ("clip velocity, numplanes == %i\n",numplanes);
                VectorCopy (vec3_origin, pml.velocity);
                break;
            }
            CrossProduct (planes[0], planes[1], dir);
            d = DotProduct (dir, pml.velocity);
            VectorScale (dir, d, pml.velocity);
        }
#endif
        //
        // if velocity is against the original velocity, stop dead
        // to avoid tiny occilations in sloping corners
        //
        if (DotProduct (pml.velocity, primal_velocity) <= 0)
        {
            VectorCopy (vec3_origin, pml.velocity);
            break;
        }
    }
 
    if (pm->s.pm_time)
    {
        VectorCopy (primal_velocity, pml.velocity);
    }
}
 
/*
==================
PM_StepSlideMove
 
==================
*/
void PM_StepSlideMove (void)
{
    vec3_t      start_o, start_v;
    vec3_t      down_o, down_v;
    trace_t     trace;
    float       down_dist, up_dist;
//  vec3_t      delta;
    vec3_t      up, down;
 
    VectorCopy (pml.origin, start_o);
    VectorCopy (pml.velocity, start_v);
 
    PM_StepSlideMove_ ();
 
    VectorCopy (pml.origin, down_o);
    VectorCopy (pml.velocity, down_v);
 
    VectorCopy (start_o, up);
    up[2] += STEPSIZE;
 
    trace = pm->trace (up, pm->mins, pm->maxs, up);
    if (trace.allsolid)
        return;     // can't step up
 
    // try sliding above
    VectorCopy (up, pml.origin);
    VectorCopy (start_v, pml.velocity);
 
    PM_StepSlideMove_ ();
 
    // push down the final amount
    VectorCopy (pml.origin, down);
    down[2] -= STEPSIZE;
    trace = pm->trace (pml.origin, pm->mins, pm->maxs, down);
    if (!trace.allsolid)
    {
        VectorCopy (trace.endpos, pml.origin);
    }
 
#if 0
    VectorSubtract (pml.origin, up, delta);
    up_dist = DotProduct (delta, start_v);
 
    VectorSubtract (down_o, start_o, delta);
    down_dist = DotProduct (delta, start_v);
#else
    VectorCopy(pml.origin, up);
 
    // decide which one went farther
    down_dist = (down_o[0] - start_o[0])*(down_o[0] - start_o[0])
        + (down_o[1] - start_o[1])*(down_o[1] - start_o[1]);
    up_dist = (up[0] - start_o[0])*(up[0] - start_o[0])
        + (up[1] - start_o[1])*(up[1] - start_o[1]);
#endif
 
    if (down_dist > up_dist || trace.plane.normal[2] < MIN_STEP_NORMAL)
    {
        VectorCopy (down_o, pml.origin);
        VectorCopy (down_v, pml.velocity);
        return;
    }
    // if we were walking along a plane, then we need to copy the Z over
    pml.velocity[2] = down_v[2];
}
 
 
/*
==================
PM_Friction
 
Handles both ground friction and water friction
==================
*/
void PM_Friction (void)
{
    float   *vel;
    float   speed, newspeed, control;
    float   friction;
    float   drop;
    
    vel = pml.velocity;
    
    speed = sqrt(vel[0]*vel[0] +vel[1]*vel[1] + vel[2]*vel[2]);
    if (speed < 1)
    {
        vel[0] = 0;
        vel[1] = 0;
        return;
    }
 
    drop = 0;
 
// apply ground friction
    if ((pm->groundentity && pml.groundsurface && !(pml.groundsurface->flags & SURF_SLICK) ) || (pml.ladder) )
    {
        friction = pm_friction;
        control = speed < pm_stopspeed ? pm_stopspeed : speed;
        drop += control*friction*pml.frametime;
    }
 
// apply water friction
    if (pm->waterlevel && !pml.ladder)
        drop += speed*pm_waterfriction*pm->waterlevel*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
==============
*/
void PM_Accelerate (vec3_t wishdir, float wishspeed, float accel)
{
    int         i;
    float       addspeed, accelspeed, currentspeed;
 
    currentspeed = DotProduct (pml.velocity, wishdir);
    addspeed = wishspeed - currentspeed;
    if (addspeed <= 0)
        return;
    accelspeed = accel*pml.frametime*wishspeed;
    if (accelspeed > addspeed)
        accelspeed = addspeed;
    
    for (i=0 ; i<3 ; i++)
        pml.velocity[i] += accelspeed*wishdir[i];   
}
 
void PM_AirAccelerate (vec3_t wishdir, float wishspeed, float accel)
{
    int         i;
    float       addspeed, accelspeed, currentspeed, wishspd = wishspeed;
        
    if (wishspd > 30)
        wishspd = 30;
    currentspeed = DotProduct (pml.velocity, wishdir);
    addspeed = wishspd - currentspeed;
    if (addspeed <= 0)
        return;
    accelspeed = accel * wishspeed * pml.frametime;
    if (accelspeed > addspeed)
        accelspeed = addspeed;
    
    for (i=0 ; i<3 ; i++)
        pml.velocity[i] += accelspeed*wishdir[i];   
}
 
/*
=============
PM_AddCurrents
=============
*/
void PM_AddCurrents (vec3_t wishvel)
{
    vec3_t  v;
    float   s;
 
    //
    // account for ladders
    //
 
    if (pml.ladder && fabs(pml.velocity[2]) <= 200)
    {
        if ((pm->viewangles[PITCH] <= -15) && (pm->cmd.forwardmove > 0))
            wishvel[2] = 200;
        else if ((pm->viewangles[PITCH] >= 15) && (pm->cmd.forwardmove > 0))
            wishvel[2] = -200;
        else if (pm->cmd.upmove > 0)
            wishvel[2] = 200;
        else if (pm->cmd.upmove < 0)
            wishvel[2] = -200;
        else
            wishvel[2] = 0;
 
        // limit horizontal speed when on a ladder
        if (wishvel[0] < -25)
            wishvel[0] = -25;
        else if (wishvel[0] > 25)
            wishvel[0] = 25;
 
        if (wishvel[1] < -25)
            wishvel[1] = -25;
        else if (wishvel[1] > 25)
            wishvel[1] = 25;
    }
 
 
    //
    // add water currents
    //
 
    if (pm->watertype & MASK_CURRENT)
    {
        VectorClear (v);
 
        if (pm->watertype & CONTENTS_CURRENT_0)
            v[0] += 1;
        if (pm->watertype & CONTENTS_CURRENT_90)
            v[1] += 1;
        if (pm->watertype & CONTENTS_CURRENT_180)
            v[0] -= 1;
        if (pm->watertype & CONTENTS_CURRENT_270)
            v[1] -= 1;
        if (pm->watertype & CONTENTS_CURRENT_UP)
            v[2] += 1;
        if (pm->watertype & CONTENTS_CURRENT_DOWN)
            v[2] -= 1;
 
        s = pm_waterspeed;
        if ((pm->waterlevel == 1) && (pm->groundentity))
            s /= 2;
 
        VectorMA (wishvel, s, v, wishvel);
    }
 
    //
    // add conveyor belt velocities
    //
 
    if (pm->groundentity)
    {
        VectorClear (v);
 
        if (pml.groundcontents & CONTENTS_CURRENT_0)
            v[0] += 1;
        if (pml.groundcontents & CONTENTS_CURRENT_90)
            v[1] += 1;
        if (pml.groundcontents & CONTENTS_CURRENT_180)
            v[0] -= 1;
        if (pml.groundcontents & CONTENTS_CURRENT_270)
            v[1] -= 1;
        if (pml.groundcontents & CONTENTS_CURRENT_UP)
            v[2] += 1;
        if (pml.groundcontents & CONTENTS_CURRENT_DOWN)
            v[2] -= 1;
 
        VectorMA (wishvel, 100 /* pm->groundentity->speed */, v, wishvel);
    }
}
 
 
/*
===================
PM_WaterMove
 
===================
*/
void PM_WaterMove (void)
{
    int     i;
    vec3_t  wishvel;
    float   wishspeed;
    vec3_t  wishdir;
 
//
// user intentions
//
    for (i=0 ; i<3 ; i++)
        wishvel[i] = pml.forward[i]*pm->cmd.forwardmove + pml.right[i]*pm->cmd.sidemove;
 
    if (!pm->cmd.forwardmove && !pm->cmd.sidemove && !pm->cmd.upmove)
        wishvel[2] -= 60;       // drift towards bottom
    else
        wishvel[2] += pm->cmd.upmove;
 
    PM_AddCurrents (wishvel);
 
    VectorCopy (wishvel, wishdir);
    wishspeed = VectorNormalize(wishdir);
 
    if (wishspeed > pm_maxspeed)
    {
        VectorScale (wishvel, pm_maxspeed/wishspeed, wishvel);
        wishspeed = pm_maxspeed;
    }
    wishspeed *= 0.5;
 
    PM_Accelerate (wishdir, wishspeed, pm_wateraccelerate);
 
    PM_StepSlideMove ();
}
 
 
/*
===================
PM_AirMove
 
===================
*/
void PM_AirMove (void)
{
    int         i;
    vec3_t      wishvel;
    float       fmove, smove;
    vec3_t      wishdir;
    float       wishspeed;
    float       maxspeed;
 
    fmove = pm->cmd.forwardmove;
    smove = pm->cmd.sidemove;
    
#if 0
    pml.forward[2] = 0;
    pml.right[2] = 0;
    VectorNormalize (pml.forward);
    VectorNormalize (pml.right);
#endif
 
    for (i=0 ; i<2 ; i++)
        wishvel[i] = pml.forward[i]*fmove + pml.right[i]*smove;
    wishvel[2] = 0;
 
    PM_AddCurrents (wishvel);
 
    VectorCopy (wishvel, wishdir);
    wishspeed = VectorNormalize(wishdir);
 
//
// clamp to server defined max speed
//
    maxspeed = (pm->s.pm_flags & PMF_DUCKED) ? pm_duckspeed : pm_maxspeed;
 
    if (wishspeed > maxspeed)
    {
        VectorScale (wishvel, maxspeed/wishspeed, wishvel);
        wishspeed = maxspeed;
    }
    
    if ( pml.ladder )
    {
        PM_Accelerate (wishdir, wishspeed, pm_accelerate);
        if (!wishvel[2])
        {
            if (pml.velocity[2] > 0)
            {
                pml.velocity[2] -= pm->s.gravity * pml.frametime;
                if (pml.velocity[2] < 0)
                    pml.velocity[2]  = 0;
            }
            else
            {
                pml.velocity[2] += pm->s.gravity * pml.frametime;
                if (pml.velocity[2] > 0)
                    pml.velocity[2]  = 0;
            }
        }
        PM_StepSlideMove ();
    }
    else if ( pm->groundentity )
    {   // walking on ground
        pml.velocity[2] = 0; 
        PM_Accelerate (wishdir, wishspeed, pm_accelerate);
 
// PGM  -- fix for negative trigger_gravity fields
//      pml.velocity[2] = 0;
        if(pm->s.gravity > 0)
            pml.velocity[2] = 0;
        else
            pml.velocity[2] -= pm->s.gravity * pml.frametime;
// PGM
 
        if (!pml.velocity[0] && !pml.velocity[1])
            return;
        PM_StepSlideMove ();
    }
    else
    {   // not on ground, so little effect on velocity
        if (pm_airaccelerate)
            PM_AirAccelerate (wishdir, wishspeed, pm_accelerate);
        else
            PM_Accelerate (wishdir, wishspeed, 1);
        // add gravity
        pml.velocity[2] -= pm->s.gravity * pml.frametime;
        PM_StepSlideMove ();
    }
}
 
 
 
/*
=============
PM_CatagorizePosition
=============
*/
void PM_CatagorizePosition (void)
{
    vec3_t      point;
    int         cont;
    trace_t     trace;
    int         sample1;
    int         sample2;
 
// if the player hull point one unit down is solid, the player
// is on ground
 
// see if standing on something solid   
    point[0] = pml.origin[0];
    point[1] = pml.origin[1];
    point[2] = pml.origin[2] - 0.25;
    if (pml.velocity[2] > 180) 
    {
        pm->s.pm_flags &= ~PMF_ON_GROUND;
        pm->groundentity = NULL;
    }
    else
    {
        trace = pm->trace (pml.origin, pm->mins, pm->maxs, point);
        pml.groundplane = trace.plane;
        pml.groundsurface = trace.surface;
        pml.groundcontents = trace.contents;
 
        if (!trace.ent || (trace.plane.normal[2] < 0.7 && !trace.startsolid) )
        {
            pm->groundentity = NULL;
            pm->s.pm_flags &= ~PMF_ON_GROUND;
        }
        else
        {
            pm->groundentity = trace.ent;
 
            // hitting solid ground will end a waterjump
            if (pm->s.pm_flags & PMF_TIME_WATERJUMP)
            {
                pm->s.pm_flags &= ~(PMF_TIME_WATERJUMP | PMF_TIME_LAND | PMF_TIME_TELEPORT);
                pm->s.pm_time = 0;
            }
 
            if (! (pm->s.pm_flags & PMF_ON_GROUND) )
            {   // just hit the ground
                pm->s.pm_flags |= PMF_ON_GROUND;
                // don't do landing time if we were just going down a slope
                if (pml.velocity[2] < -200)
                {
                    pm->s.pm_flags |= PMF_TIME_LAND;
                    // don't allow another jump for a little while
                    if (pml.velocity[2] < -400)
                        pm->s.pm_time = 25; 
                    else
                        pm->s.pm_time = 18;
                }
            }
        }
 
#if 0
        if (trace.fraction < 1.0 && trace.ent && pml.velocity[2] < 0)
            pml.velocity[2] = 0;
#endif
 
        if (pm->numtouch < MAXTOUCH && trace.ent)
        {
            pm->touchents[pm->numtouch] = trace.ent;
            pm->numtouch++;
        }
    }
 
//
// get waterlevel, accounting for ducking
//
    pm->waterlevel = 0;
    pm->watertype = 0;
 
    sample2 = pm->viewheight - pm->mins[2];
    sample1 = sample2 / 2;
 
    point[2] = pml.origin[2] + pm->mins[2] + 1; 
    cont = pm->pointcontents (point);
 
    if (cont & MASK_WATER)
    {
        pm->watertype = cont;
        pm->waterlevel = 1;
        point[2] = pml.origin[2] + pm->mins[2] + sample1;
        cont = pm->pointcontents (point);
        if (cont & MASK_WATER)
        {
            pm->waterlevel = 2;
            point[2] = pml.origin[2] + pm->mins[2] + sample2;
            cont = pm->pointcontents (point);
            if (cont & MASK_WATER)
                pm->waterlevel = 3;
        }
    }
 
}
 
 
/*
=============
PM_CheckJump
=============
*/
void PM_CheckJump (void)
{
    if (pm->s.pm_flags & PMF_TIME_LAND)
    {   // hasn't been long enough since landing to jump again
        return;
    }
 
    if (pm->cmd.upmove < 10)
    {   // not holding jump
        pm->s.pm_flags &= ~PMF_JUMP_HELD;
        return;
    }
 
    // must wait for jump to be released
    if (pm->s.pm_flags & PMF_JUMP_HELD)
        return;
 
    if (pm->s.pm_type == PM_DEAD)
        return;
 
    if (pm->waterlevel >= 2)
    {   // swimming, not jumping
        pm->groundentity = NULL;
 
        if (pml.velocity[2] <= -300)
            return;
 
        if (pm->watertype == CONTENTS_WATER)
            pml.velocity[2] = 100;
        else if (pm->watertype == CONTENTS_SLIME)
            pml.velocity[2] = 80;
        else
            pml.velocity[2] = 50;
        return;
    }
 
    if (pm->groundentity == NULL)
        return;     // in air, so no effect
 
    pm->s.pm_flags |= PMF_JUMP_HELD;
 
    pm->groundentity = NULL;
    pml.velocity[2] += 270;
    if (pml.velocity[2] < 270)
        pml.velocity[2] = 270;
}
 
 
/*
=============
PM_CheckSpecialMovement
=============
*/
void PM_CheckSpecialMovement (void)
{
    vec3_t  spot;
    int     cont;
    vec3_t  flatforward;
    trace_t trace;
 
    if (pm->s.pm_time)
        return;
 
    pml.ladder = false;
 
    // check for ladder
    flatforward[0] = pml.forward[0];
    flatforward[1] = pml.forward[1];
    flatforward[2] = 0;
    VectorNormalize (flatforward);
 
    VectorMA (pml.origin, 1, flatforward, spot);
    trace = pm->trace (pml.origin, pm->mins, pm->maxs, spot);
    if ((trace.fraction < 1) && (trace.contents & CONTENTS_LADDER))
        pml.ladder = true;
 
    // check for water jump
    if (pm->waterlevel != 2)
        return;
 
    VectorMA (pml.origin, 30, flatforward, spot);
    spot[2] += 4;
    cont = pm->pointcontents (spot);
    if (!(cont & CONTENTS_SOLID))
        return;
 
    spot[2] += 16;
    cont = pm->pointcontents (spot);
    if (cont)
        return;
    // jump out of water
    VectorScale (flatforward, 50, pml.velocity);
    pml.velocity[2] = 350;
 
    pm->s.pm_flags |= PMF_TIME_WATERJUMP;
    pm->s.pm_time = 255;
}
 
 
/*
===============
PM_FlyMove
===============
*/
void PM_FlyMove (qboolean doclip)
{
    float   speed, drop, friction, control, newspeed;
    float   currentspeed, addspeed, accelspeed;
    int         i;
    vec3_t      wishvel;
    float       fmove, smove;
    vec3_t      wishdir;
    float       wishspeed;
    vec3_t      end;
    trace_t trace;
 
    pm->viewheight = 22;
 
    // friction
 
    speed = VectorLength (pml.velocity);
    if (speed < 1)
    {
        VectorCopy (vec3_origin, pml.velocity);
    }
    else
    {
        drop = 0;
 
        friction = pm_friction*1.5; // extra friction
        control = speed < pm_stopspeed ? pm_stopspeed : speed;
        drop += control*friction*pml.frametime;
 
        // scale the velocity
        newspeed = speed - drop;
        if (newspeed < 0)
            newspeed = 0;
        newspeed /= speed;
 
        VectorScale (pml.velocity, newspeed, pml.velocity);
    }
 
    // accelerate
    fmove = pm->cmd.forwardmove;
    smove = pm->cmd.sidemove;
    
    VectorNormalize (pml.forward);
    VectorNormalize (pml.right);
 
    for (i=0 ; i<3 ; i++)
        wishvel[i] = pml.forward[i]*fmove + pml.right[i]*smove;
    wishvel[2] += pm->cmd.upmove;
 
    VectorCopy (wishvel, wishdir);
    wishspeed = VectorNormalize(wishdir);
 
    //
    // clamp to server defined max speed
    //
    if (wishspeed > pm_maxspeed)
    {
        VectorScale (wishvel, pm_maxspeed/wishspeed, wishvel);
        wishspeed = pm_maxspeed;
    }
 
 
    currentspeed = DotProduct(pml.velocity, wishdir);
    addspeed = wishspeed - currentspeed;
    if (addspeed <= 0)
        return;
    accelspeed = pm_accelerate*pml.frametime*wishspeed;
    if (accelspeed > addspeed)
        accelspeed = addspeed;
    
    for (i=0 ; i<3 ; i++)
        pml.velocity[i] += accelspeed*wishdir[i];   
 
    if (doclip) {
        for (i=0 ; i<3 ; i++)
            end[i] = pml.origin[i] + pml.frametime * pml.velocity[i];
 
        trace = pm->trace (pml.origin, pm->mins, pm->maxs, end);
 
        VectorCopy (trace.endpos, pml.origin);
    } else {
        // move
        VectorMA (pml.origin, pml.frametime, pml.velocity, pml.origin);
    }
}
 
 
/*
==============
PM_CheckDuck
 
Sets mins, maxs, and pm->viewheight
==============
*/
void PM_CheckDuck (void)
{
    trace_t trace;
 
    pm->mins[0] = -16;
    pm->mins[1] = -16;
 
    pm->maxs[0] = 16;
    pm->maxs[1] = 16;
 
    if (pm->s.pm_type == PM_GIB)
    {
        pm->mins[2] = 0;
        pm->maxs[2] = 16;
        pm->viewheight = 8;
        return;
    }
 
    pm->mins[2] = -24;
 
    if (pm->s.pm_type == PM_DEAD)
    {
        pm->s.pm_flags |= PMF_DUCKED;
    }
    else if (pm->cmd.upmove < 0 && (pm->s.pm_flags & PMF_ON_GROUND) )
    {   // duck
        pm->s.pm_flags |= PMF_DUCKED;
    }
    else
    {   // stand up if possible
        if (pm->s.pm_flags & PMF_DUCKED)
        {
            // try to stand up
            pm->maxs[2] = 32;
            trace = pm->trace (pml.origin, pm->mins, pm->maxs, pml.origin);
            if (!trace.allsolid)
                pm->s.pm_flags &= ~PMF_DUCKED;
        }
    }
 
    if (pm->s.pm_flags & PMF_DUCKED)
    {
        pm->maxs[2] = 4;
        pm->viewheight = -2;
    }
    else
    {
        pm->maxs[2] = 32;
        pm->viewheight = 22;
    }
}
 
 
/*
==============
PM_DeadMove
==============
*/
void PM_DeadMove (void)
{
    float   forward;
 
    if (!pm->groundentity)
        return;
 
    // extra friction
 
    forward = VectorLength (pml.velocity);
    forward -= 20;
    if (forward <= 0)
    {
        VectorClear (pml.velocity);
    }
    else
    {
        VectorNormalize (pml.velocity);
        VectorScale (pml.velocity, forward, pml.velocity);
    }
}
 
 
qboolean    PM_GoodPosition (void)
{
    trace_t trace;
    vec3_t  origin, end;
    int     i;
 
    if (pm->s.pm_type == PM_SPECTATOR)
        return true;
 
    for (i=0 ; i<3 ; i++)
        origin[i] = end[i] = pm->s.origin[i]*0.125;
    trace = pm->trace (origin, pm->mins, pm->maxs, end);
 
    return !trace.allsolid;
}
 
/*
================
PM_SnapPosition
 
On exit, the origin will have a value that is pre-quantized to the 0.125
precision of the network channel and in a valid position.
================
*/
void PM_SnapPosition (void)
{
    int     sign[3];
    int     i, j, bits;
    short   base[3];
    // try all single bits first
    static int jitterbits[8] = {0,4,1,2,3,5,6,7};
 
    // snap velocity to eigths
    for (i=0 ; i<3 ; i++)
        pm->s.velocity[i] = (int)(pml.velocity[i]*8);
 
    for (i=0 ; i<3 ; i++)
    {
        if (pml.origin[i] >= 0)
            sign[i] = 1;
        else 
            sign[i] = -1;
        pm->s.origin[i] = (int)(pml.origin[i]*8);
        if (pm->s.origin[i]*0.125 == pml.origin[i])
            sign[i] = 0;
    }
    VectorCopy (pm->s.origin, base);
 
    // try all combinations
    for (j=0 ; j<8 ; j++)
    {
        bits = jitterbits[j];
        VectorCopy (base, pm->s.origin);
        for (i=0 ; i<3 ; i++)
            if (bits & (1<<i) )
                pm->s.origin[i] += sign[i];
 
        if (PM_GoodPosition ())
            return;
    }
 
    // go back to the last position
    VectorCopy (pml.previous_origin, pm->s.origin);
//  Com_DPrintf ("using previous_origin\n");
}
 
#if 0
//NO LONGER USED
/*
================
PM_InitialSnapPosition
 
================
*/
void PM_InitialSnapPosition (void)
{
    int     x, y, z;
    short   base[3];
 
    VectorCopy (pm->s.origin, base);
 
    for (z=1 ; z>=-1 ; z--)
    {
        pm->s.origin[2] = base[2] + z;
        for (y=1 ; y>=-1 ; y--)
        {
            pm->s.origin[1] = base[1] + y;
            for (x=1 ; x>=-1 ; x--)
            {
                pm->s.origin[0] = base[0] + x;
                if (PM_GoodPosition ())
                {
                    pml.origin[0] = pm->s.origin[0]*0.125;
                    pml.origin[1] = pm->s.origin[1]*0.125;
                    pml.origin[2] = pm->s.origin[2]*0.125;
                    VectorCopy (pm->s.origin, pml.previous_origin);
                    return;
                }
            }
        }
    }
 
    Com_DPrintf ("Bad InitialSnapPosition\n");
}
#else
/*
================
PM_InitialSnapPosition
 
================
*/
void PM_InitialSnapPosition(void)
{
    int        x, y, z;
    short      base[3];
    static int offset[3] = { 0, -1, 1 };
 
    VectorCopy (pm->s.origin, base);
 
    for ( z = 0; z < 3; z++ ) {
        pm->s.origin[2] = base[2] + offset[ z ];
        for ( y = 0; y < 3; y++ ) {
            pm->s.origin[1] = base[1] + offset[ y ];
            for ( x = 0; x < 3; x++ ) {
                pm->s.origin[0] = base[0] + offset[ x ];
                if (PM_GoodPosition ()) {
                    pml.origin[0] = pm->s.origin[0]*0.125;
                    pml.origin[1] = pm->s.origin[1]*0.125;
                    pml.origin[2] = pm->s.origin[2]*0.125;
                    VectorCopy (pm->s.origin, pml.previous_origin);
                    return;
                }
            }
        }
    }
 
    Com_DPrintf ("Bad InitialSnapPosition\n");
}
 
#endif
 
/*
================
PM_ClampAngles
 
================
*/
void PM_ClampAngles (void)
{
    short   temp;
    int     i;
 
    if (pm->s.pm_flags & PMF_TIME_TELEPORT)
    {
        pm->viewangles[YAW] = SHORT2ANGLE(pm->cmd.angles[YAW] + pm->s.delta_angles[YAW]);
        pm->viewangles[PITCH] = 0;
        pm->viewangles[ROLL] = 0;
    }
    else
    {
        // circularly clamp the angles with deltas
        for (i=0 ; i<3 ; i++)
        {
            temp = pm->cmd.angles[i] + pm->s.delta_angles[i];
            pm->viewangles[i] = SHORT2ANGLE(temp);
        }
 
        // don't let the player look up or down more than 90 degrees
        if (pm->viewangles[PITCH] > 89 && pm->viewangles[PITCH] < 180)
            pm->viewangles[PITCH] = 89;
        else if (pm->viewangles[PITCH] < 271 && pm->viewangles[PITCH] >= 180)
            pm->viewangles[PITCH] = 271;
    }
    AngleVectors (pm->viewangles, pml.forward, pml.right, pml.up);
}
 
/*
================
Pmove
 
Can be called by either the server or the client
================
*/
void Pmove (pmove_t *pmove)
{
    pm = pmove;
 
    // clear results
    pm->numtouch = 0;
    VectorClear (pm->viewangles);
    pm->viewheight = 0;
    pm->groundentity = 0;
    pm->watertype = 0;
    pm->waterlevel = 0;
 
    // clear all pmove local vars
    memset (&pml, 0, sizeof(pml));
 
    // convert origin and velocity to float values
    pml.origin[0] = pm->s.origin[0]*0.125;
    pml.origin[1] = pm->s.origin[1]*0.125;
    pml.origin[2] = pm->s.origin[2]*0.125;
 
    pml.velocity[0] = pm->s.velocity[0]*0.125;
    pml.velocity[1] = pm->s.velocity[1]*0.125;
    pml.velocity[2] = pm->s.velocity[2]*0.125;
 
    // save old org in case we get stuck
    VectorCopy (pm->s.origin, pml.previous_origin);
 
    pml.frametime = pm->cmd.msec * 0.001;
 
    PM_ClampAngles ();
 
    if (pm->s.pm_type == PM_SPECTATOR)
    {
        PM_FlyMove (false);
        PM_SnapPosition ();
        return;
    }
 
    if (pm->s.pm_type >= PM_DEAD)
    {
        pm->cmd.forwardmove = 0;
        pm->cmd.sidemove = 0;
        pm->cmd.upmove = 0;
    }
 
    if (pm->s.pm_type == PM_FREEZE)
        return;     // no movement at all
 
    // set mins, maxs, and viewheight
    PM_CheckDuck ();
 
    if (pm->snapinitial)
        PM_InitialSnapPosition ();
 
    // set groundentity, watertype, and waterlevel
    PM_CatagorizePosition ();
 
    if (pm->s.pm_type == PM_DEAD)
        PM_DeadMove ();
 
    PM_CheckSpecialMovement ();
 
    // drop timing counter
    if (pm->s.pm_time)
    {
        int     msec;
 
        msec = pm->cmd.msec >> 3;
        if (!msec)
            msec = 1;
        if ( msec >= pm->s.pm_time) 
        {
            pm->s.pm_flags &= ~(PMF_TIME_WATERJUMP | PMF_TIME_LAND | PMF_TIME_TELEPORT);
            pm->s.pm_time = 0;
        }
        else
            pm->s.pm_time -= msec;
    }
 
    if (pm->s.pm_flags & PMF_TIME_TELEPORT)
    {   // teleport pause stays exactly in place
    }
    else if (pm->s.pm_flags & PMF_TIME_WATERJUMP)
    {   // waterjump has no control, but falls
        pml.velocity[2] -= pm->s.gravity * pml.frametime;
        if (pml.velocity[2] < 0)
        {   // cancel as soon as we are falling down again
            pm->s.pm_flags &= ~(PMF_TIME_WATERJUMP | PMF_TIME_LAND | PMF_TIME_TELEPORT);
            pm->s.pm_time = 0;
        }
 
        PM_StepSlideMove ();
    }
    else
    {
        PM_CheckJump ();
 
        PM_Friction ();
 
        if (pm->waterlevel >= 2)
            PM_WaterMove ();
        else {
            vec3_t  angles;
 
            VectorCopy(pm->viewangles, angles);
            if (angles[PITCH] > 180)
                angles[PITCH] = angles[PITCH] - 360;
            angles[PITCH] /= 3;
 
            AngleVectors (angles, pml.forward, pml.right, pml.up);
 
            PM_AirMove ();
        }
    }
 
    // set groundentity, watertype, and waterlevel for final spot
    PM_CatagorizePosition ();
 
    PM_SnapPosition ();
}