pmove.c File Reference

#include "shared/shared.h"
#include "common/pmove.h"

Go to the source code of this file.

Classes
struct	pml_t

Macros
#define	STEPSIZE   18
#define	STOP_EPSILON   0.1
#define	MIN_STEP_NORMAL   0.7
#define	MAX_CLIP_PLANES   5

Functions
static void	PM_ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce)
static void	PM_StepSlideMove_ (void)
static void	PM_StepSlideMove (void)
static void	PM_Friction (void)
static void	PM_Accelerate (vec3_t wishdir, float wishspeed, float accel)
static void	PM_AirAccelerate (vec3_t wishdir, float wishspeed, float accel)
static void	PM_AddCurrents (vec3_t wishvel)
static void	PM_WaterMove (void)
static void	PM_AirMove (void)
static void	PM_CategorizePosition (void)
static void	PM_CheckJump (void)
static void	PM_CheckSpecialMovement (void)
static void	PM_FlyMove (void)
static void	PM_CheckDuck (void)
static void	PM_DeadMove (void)
static qboolean	PM_GoodPosition (void)
static void	PM_SnapPosition (void)
static void	PM_InitialSnapPosition (void)
static void	PM_ClampAngles (void)
void	Pmove (pmove_t *pmove, pmoveParams_t *params)
void	PmoveInit (pmoveParams_t *pmp)
void	PmoveEnableQW (pmoveParams_t *pmp)

Variables
static pmove_t *	pm
static pml_t	pml
static pmoveParams_t *	pmp
static const float	pm_stopspeed = 100
static const float	pm_duckspeed = 100
static const float	pm_accelerate = 10
static const float	pm_wateraccelerate = 10
static const float	pm_waterspeed = 400

Macro Definition Documentation

MAX_CLIP_PLANES

#define MAX_CLIP_PLANES   5

Definition at line 104 of file pmove.c.

MIN_STEP_NORMAL

#define MIN_STEP_NORMAL   0.7

Definition at line 103 of file pmove.c.

STEPSIZE

#define STEPSIZE   18

Definition at line 22 of file pmove.c.

STOP_EPSILON

#define STOP_EPSILON   0.1

Definition at line 71 of file pmove.c.

Function Documentation

PM_Accelerate()

static void PM_Accelerate ( vec3_t  wishdir, float  wishspeed, float  accel  )

static

Definition at line 326 of file pmove.c.

{
    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];
}

Referenced by PM_AirMove(), and PM_WaterMove().

PM_AddCurrents()

static void PM_AddCurrents ( vec3_t  wishvel )

static

Definition at line 367 of file pmove.c.

{
    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);
    }
}

Referenced by PM_AirMove(), and PM_WaterMove().

PM_AirAccelerate()

static void PM_AirAccelerate ( vec3_t  wishdir, float  wishspeed, float  accel  )

static

Definition at line 343 of file pmove.c.

{
    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];
}

Referenced by PM_AirMove().

PM_AirMove()

static void PM_AirMove ( void  )

static

!!!! pitch should be 1/3 so this isn't needed??!

!! this is before the accel

Definition at line 500 of file pmove.c.

{
    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 : pmp->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 (pmp->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();
    }
}

Referenced by Pmove().

PM_CategorizePosition()

static void PM_CategorizePosition ( void  )

static

!ZOID changed from 100 to 180 (ramp accel)

Definition at line 589 of file pmove.c.

{
    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.25f;
    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 && !pmp->strafehack) {
                    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 (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;
        }
    }
 
}

Referenced by Pmove().

PM_CheckDuck()

static void PM_CheckDuck ( void  )

static

Definition at line 884 of file pmove.c.

{
    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;
    }
}

Referenced by Pmove().

PM_CheckJump()

static void PM_CheckJump ( void  )

static

Definition at line 680 of file pmove.c.

{
    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 (pmp->waterhack)
            return;
 
        if (pml.velocity[2] <= -300)
            return;
 
        // FIXME: makes velocity dependent on client FPS,
        // even causes prediction misses
        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;
    pm->s.pm_flags &= ~PMF_ON_GROUND;
    pml.velocity[2] += 270;
    if (pml.velocity[2] < 270)
        pml.velocity[2] = 270;
}

Referenced by Pmove().

PM_CheckSpecialMovement()

static void PM_CheckSpecialMovement ( void  )

static

Definition at line 739 of file pmove.c.

{
    vec3_t  spot;
    int     cont;
    vec3_t  flatforward;
    trace_t trace;
 
    if (pm->s.pm_time)
        return;
 
    pml.ladder = qfalse;
 
    // 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 = qtrue;
 
    // 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;
}

Referenced by Pmove().

PM_ClampAngles()

static void PM_ClampAngles ( void  )

static

Definition at line 1095 of file pmove.c.

{
    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);
}

Referenced by Pmove().

PM_ClipVelocity()

static void PM_ClipVelocity ( vec3_t  in, vec3_t  normal, vec3_t  out, float  overbounce  )

static

Definition at line 73 of file pmove.c.

{
    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;
    }
}

Referenced by PM_StepSlideMove_().

PM_DeadMove()

static void PM_DeadMove ( void  )

static

Definition at line 934 of file pmove.c.

{
    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);
    }
}

Referenced by Pmove().

PM_FlyMove()

static void PM_FlyMove ( void  )

static

Definition at line 790 of file pmove.c.

{
    float   speed, drop, friction, control, newspeed;
    float   currentspeed, addspeed, accelspeed;
    int         i;
    vec3_t      wishvel;
    float       fmove, smove;
    vec3_t      wishdir;
    float       wishspeed;
 
    pm->viewheight = 22;
 
    // friction
 
    speed = VectorLength(pml.velocity);
    if (speed < 1) {
        VectorCopy(vec3_origin, pml.velocity);
    } else {
        drop = 0;
 
        friction = pmp->flyfriction;
        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 > pmp->maxspeed) {
        VectorScale(wishvel, pmp->maxspeed / wishspeed, wishvel);
        wishspeed = pmp->maxspeed;
    }
 
    currentspeed = DotProduct(pml.velocity, wishdir);
    addspeed = wishspeed - currentspeed;
    if (addspeed <= 0) {
        if (!pmp->flyhack) {
            return; // original buggy behaviour
        }
    } else {
        accelspeed = pm_accelerate * pml.frametime * wishspeed;
        if (accelspeed > addspeed)
            accelspeed = addspeed;
 
        for (i = 0; i < 3; i++)
            pml.velocity[i] += accelspeed * wishdir[i];
    }
 
#if 0
    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
#endif
    {
        // move
        VectorMA(pml.origin, pml.frametime, pml.velocity, pml.origin);
    }
}

Referenced by Pmove().

PM_Friction()

static void PM_Friction ( void  )

static

Definition at line 277 of file pmove.c.

{
    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 = pmp->friction;
        control = speed < pm_stopspeed ? pm_stopspeed : speed;
        drop += control * friction * pml.frametime;
    }
 
// apply water friction
    if (pm->waterlevel && !pml.ladder)
        drop += speed * pmp->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;
}

Referenced by Pmove().

PM_GoodPosition()

static qboolean PM_GoodPosition ( void  )

static

Definition at line 954 of file pmove.c.

{
    trace_t trace;
    vec3_t  origin, end;
    int     i;
 
    if (pm->s.pm_type == PM_SPECTATOR)
        return qtrue;
 
    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;
}

Referenced by PM_InitialSnapPosition(), and PM_SnapPosition().

PM_InitialSnapPosition()

static void PM_InitialSnapPosition ( void  )

static

Definition at line 1063 of file pmove.c.

{
    int        x, y, z;
    short      base[3];
    static const short 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;
                }
            }
        }
    }
}

Referenced by Pmove().

PM_SnapPosition()

static void PM_SnapPosition ( void  )

static

Definition at line 978 of file pmove.c.

{
    int     sign[3];
    int     i, j, bits;
    short   base[3];
    // try all single bits first
    static const byte 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.125f == 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);
}

Referenced by Pmove().

PM_StepSlideMove()

static void PM_StepSlideMove ( void  )

static

! Special case

Definition at line 213 of file pmove.c.

{
    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);
    }
 
    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]);
 
    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];
}

Referenced by PM_AirMove(), PM_WaterMove(), and Pmove().

PM_StepSlideMove_()

static void PM_StepSlideMove_ ( void  )

static

Definition at line 105 of file pmove.c.

{
    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++;
 
//
// 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);
        }
 
        //
        // 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);
    }
}

Referenced by PM_StepSlideMove().

PM_WaterMove()

static void PM_WaterMove ( void  )

static

Definition at line 459 of file pmove.c.

{
    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 > pmp->maxspeed) {
        VectorScale(wishvel, pmp->maxspeed / wishspeed, wishvel);
        wishspeed = pmp->maxspeed;
    }
    wishspeed *= pmp->watermult;
 
    PM_Accelerate(wishdir, wishspeed, pm_wateraccelerate);
 
    PM_StepSlideMove();
}

Referenced by Pmove().

Pmove()

void Pmove	(	pmove_t *	pmove,
		pmoveParams_t *	params
	)

Definition at line 1127 of file pmove.c.

{
    pm = pmove;
    pmp = params;
 
    // clear results
    pm->numtouch = 0;
    VectorClear(pm->viewangles);
    pm->viewheight = 0;
    pm->groundentity = NULL;
    pm->watertype = 0;
    pm->waterlevel = 0;
 
    // clear all pmove local vars
    memset(&pml, 0, sizeof(pml));
 
    // convert origin and velocity to float values
    VectorScale(pm->s.origin, 0.125f, pml.origin);
    VectorScale(pm->s.velocity, 0.125f, pml.velocity);
 
    // save old org in case we get stuck
    VectorCopy(pm->s.origin, pml.previous_origin);
 
    PM_ClampAngles();
 
    if (pm->s.pm_type == PM_SPECTATOR) {
        pml.frametime = pmp->speedmult * pm->cmd.msec * 0.001f;
        PM_FlyMove();
        PM_SnapPosition();
        return;
    }
 
    pml.frametime = pm->cmd.msec * 0.001f;
 
    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_CategorizePosition();
 
    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_CategorizePosition();
 
    PM_SnapPosition();
}

Referenced by CL_PredictMovement(), and PF_Pmove().

PmoveEnableQW()

void PmoveEnableQW

(

pmoveParams_t *

pmp

)

Definition at line 1250 of file pmove.c.

{
    pmp->qwmode = qtrue;
    pmp->watermult = 0.7f;
    pmp->maxspeed = 320;
    //pmp->upspeed = (sv_qwmod->integer > 1) ? 310 : 350;
    pmp->friction = 4;
    pmp->waterfriction = 4;
    pmp->airaccelerate = qtrue;
}

Referenced by CL_ParseServerData(), and init_pmove_and_es_flags().

PmoveInit()

void PmoveInit

(

pmoveParams_t *

pmp

)

Definition at line 1237 of file pmove.c.

{
    // set up default pmove parameters
    memset(pmp, 0, sizeof(*pmp));
 
    pmp->speedmult = 1;
    pmp->watermult = 0.5f;
    pmp->maxspeed = 300;
    pmp->friction = 6;
    pmp->waterfriction = 1;
    pmp->flyfriction = 9;
}

Referenced by CL_ParseServerData(), and SV_Init().

Variable Documentation

pm

pmove_t* pm

static

Definition at line 44 of file pmove.c.

Referenced by CL_PredictMovement(), ClientThink(), MVD_GameClientThink(), PF_Pmove(), PM_AddCurrents(), PM_AirMove(), PM_CategorizePosition(), PM_CheckDuck(), PM_CheckJump(), PM_CheckSpecialMovement(), PM_ClampAngles(), PM_DeadMove(), PM_FlyMove(), PM_Friction(), PM_GoodPosition(), PM_InitialSnapPosition(), PM_SnapPosition(), PM_StepSlideMove(), PM_StepSlideMove_(), PM_WaterMove(), Pmove(), and PrintPmove().

pm_accelerate

const float pm_accelerate = 10

static

Definition at line 52 of file pmove.c.

Referenced by PM_AirMove(), and PM_FlyMove().

pm_duckspeed

const float pm_duckspeed = 100

static

Definition at line 51 of file pmove.c.

Referenced by PM_AirMove().

pm_stopspeed

const float pm_stopspeed = 100

static

Definition at line 50 of file pmove.c.

Referenced by PM_FlyMove(), and PM_Friction().

pm_wateraccelerate

const float pm_wateraccelerate = 10

static

Definition at line 53 of file pmove.c.

Referenced by PM_WaterMove().

pm_waterspeed

const float pm_waterspeed = 400

static

Definition at line 54 of file pmove.c.

Referenced by PM_AddCurrents().

pml

pml_t pml

static

Definition at line 45 of file pmove.c.

Referenced by PM_Accelerate(), PM_AddCurrents(), PM_AirAccelerate(), PM_AirMove(), PM_CategorizePosition(), PM_CheckDuck(), PM_CheckJump(), PM_CheckSpecialMovement(), PM_ClampAngles(), PM_DeadMove(), PM_FlyMove(), PM_Friction(), PM_InitialSnapPosition(), PM_SnapPosition(), PM_StepSlideMove(), PM_StepSlideMove_(), PM_WaterMove(), and Pmove().

pmp

pmoveParams_t* pmp

static

Definition at line 47 of file pmove.c.

Referenced by PM_AirMove(), PM_CategorizePosition(), PM_CheckJump(), PM_FlyMove(), PM_Friction(), PM_WaterMove(), Pmove(), PmoveEnableQW(), and PmoveInit().