ref: b10d6e123329a38a29030744bf232ac03387cee5
dir: /qcommon/pmove.c/
/*
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;
}
//!! Special case
// 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;
//!!!!! pitch should be 1/3 so this isn't needed??!
#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; //!!! this is before the accel
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) //!!ZOID changed from 100 to 180 (ramp accel)
{
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 ();
}