//-----------------------------------------------------------------------------
//
//  $Logfile:: /Code/DLLs/game/bg_pmove.c                                    $
// $Revision:: 62                                                             $
//     $Date:: 10/13/03 9:42a                                                 $
//
// Copyright (C) 1999 by Ritual Entertainment, Inc.
// All rights reserved.
//
// This source is may not be distributed and/or modified without
// expressly written permission by Ritual Entertainment, Inc.
//
//
// DESCRIPTION:
//

#include "q_shared.h"
#include "bg_public.h"

// all of the locals will be zeroed before each
// pmove, just to make sure we don't have
// any differences when running on client or server
typedef struct {
	vec3_t		forward, left, up;
	vec3_t		flat_forward, flat_left, flat_up;
   //float       forward_speed, side_speed;
	float		frametime;

	int			msec;

	qboolean	walking;
	qboolean	groundPlane;
	trace_t		groundTrace;

	float		impactSpeed;

	vec3_t		previous_origin;
	vec3_t		previous_velocity;
	int			previous_waterlevel;
} pml_t;

pmove_t	*pm;
pml_t		pml;
qboolean slopeSlideFlag = qfalse;

// movement parameters
const float	pm_swimScale         = 0.50f;
const float	pm_wadeScale         = 0.70f;
const float	pm_slipperyfriction  = 0.25f;
const float pm_leaninspeed		 = 75.0f;
const float pm_leanoutspeed		 = 150.0f;
const float	pm_leanmaxdelta		 = 35.0f;

int c_pmove = 0;

void PM_CrashLand( void );
qboolean PM_ShouldCrashLand( void );

/*
===============
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
   (
   const vec3_t in,
   const vec3_t normal,
   vec3_t out,
   float overbounce
   )

   {
	float	backoff;
	float	change;
	int	i;

	backoff = DotProduct( in, normal );

	if ( backoff < 0.0f )
      {
		backoff *= overbounce;
	   }
   else
      {
		backoff /= overbounce;
	   }

	for( i = 0; i < 3; i++ )
      {
		change = normal[ i ] * backoff;
		out[ i ] = in[ i ] - change;
	   }
   }

/*
==================
PM_SlideMove

Returns qtrue if the velocity was clipped in some way
==================
*/
#define	MAX_CLIP_PLANES	5
qboolean	PM_SlideMove( qboolean gravity ) {
	int			bumpcount, numbumps;
	vec3_t		dir;
	float		d;
	int			numplanes;
	vec3_t		planes[MAX_CLIP_PLANES];
	vec3_t		primal_velocity;
	vec3_t		clipVelocity;
	int			i, j, k;
	trace_t	trace;
	vec3_t		end;
	float		time_left;
	float		into;
	vec3_t		endVelocity;
	vec3_t		endClipVelocity;
	int gravtmp;

	numbumps = 4;

	VectorCopy (pm->ps->velocity, primal_velocity);

	if ( gravity ) {
		if ( pm->ps->pm_flags & PMF_FLIGHT )
			gravtmp = 0;
		else
			gravtmp = pm->ps->gravity;

		VectorCopy( pm->ps->velocity, endVelocity );
		endVelocity[2] -= gravtmp * pml.frametime;
		pm->ps->velocity[2] = ( pm->ps->velocity[2] + endVelocity[2] ) * 0.5f;
		primal_velocity[2] = endVelocity[2];
		if ( pml.groundPlane ) {
			// slide along the ground plane
			PM_ClipVelocity (pm->ps->velocity, pml.groundTrace.plane.normal,
				pm->ps->velocity, OVERCLIP );
		}
	}

	time_left = pml.frametime;

	// never turn against the ground plane
	if ( pml.groundPlane ) {
		numplanes = 1;
		VectorCopy( pml.groundTrace.plane.normal, planes[0] );
	} else {
		numplanes = 0;
	}

	// never turn against original velocity
	VectorNormalize2( pm->ps->velocity, planes[numplanes] );
	numplanes++;

	for ( bumpcount=0 ; bumpcount < numbumps ; bumpcount++ ) {

		// calculate position we are trying to move to
		VectorMA( pm->ps->origin, time_left, pm->ps->velocity, end );

		// add exact pull from gravity
	//	if ( gravity && !(pm->ps->pm_flags & PMF_FLIGHT) ) {
	//		pm->ps->origin[2] += 0.5 * time_left * time_left;
	//	}

		// see if we can make it there
		pm->trace ( &trace, pm->ps->origin, pm->mins, pm->maxs, end, pm->ps->clientNum, pm->tracemask, qtrue );

      if ( trace.startsolid && trace.entityNum != ENTITYNUM_WORLD )
         {
         // stuck in an entity, so try to pretend it's not there
         pm->trace ( &trace, pm->ps->origin, pm->mins, pm->maxs, end, trace.entityNum, pm->tracemask, qtrue );
         }

      if (trace.allsolid) {
			// entity is completely trapped in another solid
			pm->ps->velocity[2] = 0.0f;	// don't build up falling damage, but allow sideways acceleration
			return qtrue;
		}

      if ( pm->trypush && pm->trypush( trace.entityNum, pm->ps->origin, end ) )
			continue;

		if (trace.fraction > 0.0f) {
			// actually covered some distance
			VectorCopy (trace.endpos, pm->ps->origin);
		}

		if (trace.fraction == 1.0f) {
			 break;		// moved the entire distance
		}

      /*if ( ( trace.plane.normal[ 2 ] < MIN_WALK_NORMAL ) && ( trace.plane.normal[ 2 ] > 0 ) )
      {
         // treat steep walls as vertical
         trace.plane.normal[ 2 ] = 0;
         VectorNormalize( trace.plane.normal );
      }*/

		// save entity for contact
		PM_AddTouchEnt( trace.entityNum );

      time_left -= time_left * trace.fraction;

		if (numplanes >= MAX_CLIP_PLANES) {
			// this shouldn't really happen
			VectorClear( pm->ps->velocity );
			return qtrue;
		}

		//
		// if this is the same plane we hit before, nudge velocity
		// out along it, which fixes some epsilon issues with
		// non-axial planes
		//
		for ( i = 0 ; i < numplanes ; i++ ) {
			if ( DotProduct( trace.plane.normal, planes[i] ) > 0.99f ) {
				VectorAdd( trace.plane.normal, pm->ps->velocity, pm->ps->velocity );
				break;
			}
		}
		if ( i < numplanes ) {
			continue;
		}
		VectorCopy (trace.plane.normal, planes[numplanes]);
		numplanes++;

		//
		// modify velocity so it parallels all of the clip planes
		//

		// find a plane that it enters
		for ( i = 0 ; i < numplanes ; i++ ) {
			into = DotProduct( pm->ps->velocity, planes[i] );
			if ( into >= 0.1f ) {
				continue;		// move doesn't interact with the plane
			}

			// see how hard we are hitting things
			if ( -into > pml.impactSpeed ) {
				pml.impactSpeed = -into;
			}

			// slide along the plane
			PM_ClipVelocity (pm->ps->velocity, planes[i], clipVelocity, OVERCLIP );

			// slide along the plane
			PM_ClipVelocity (endVelocity, planes[i], endClipVelocity, OVERCLIP );

			// see if there is a second plane that the new move enters
			for ( j = 0 ; j < numplanes ; j++ ) {
				if ( j == i ) {
					continue;
				}
				if ( DotProduct( clipVelocity, planes[j] ) >= 0.1f ) {
					continue;		// move doesn't interact with the plane
				}

				// try clipping the move to the plane
				PM_ClipVelocity( clipVelocity, planes[j], clipVelocity, OVERCLIP );
				PM_ClipVelocity( endClipVelocity, planes[j], endClipVelocity, OVERCLIP );

				// see if it goes back into the first clip plane
				if ( DotProduct( clipVelocity, planes[i] ) >= 0.0f ) {
					continue;
				}

				// slide the original velocity along the crease
				CrossProduct (planes[i], planes[j], dir);
				VectorNormalize( dir );
				d = DotProduct( dir, pm->ps->velocity );
				VectorScale( dir, d, clipVelocity );

				CrossProduct (planes[i], planes[j], dir);
				VectorNormalize( dir );
				d = DotProduct( dir, endVelocity );
				VectorScale( dir, d, endClipVelocity );

				// see if there is a third plane the the new move enters
				for ( k = 0 ; k < numplanes ; k++ ) {
					if ( k == i || k == j ) {
						continue;
					}
					if ( DotProduct( clipVelocity, planes[k] ) >= 0.1f ) {
						continue;		// move doesn't interact with the plane
					}

					// stop dead at a triple plane interaction
					VectorClear( pm->ps->velocity );
					return qtrue;
				}
			}

			// if we have fixed all interactions, try another move
			VectorCopy( clipVelocity, pm->ps->velocity );
			VectorCopy( endClipVelocity, endVelocity );
			break;
		}
	}

	if ( gravity ) {
		VectorCopy( endVelocity, pm->ps->velocity );
	}

	// don't change velocity if in a timer (FIXME: is this correct?)
	if ( pm->ps->pm_time ) {
		VectorCopy( primal_velocity, pm->ps->velocity );
	}

	return ( bumpcount != 0 );
}
/*
void PM_StepSlideMove( qboolean gravity ) {
	vec3_t		start_o, start_v;
	trace_t		trace;
//	float		down_dist, up_dist;
//	vec3_t		delta, delta2;
	vec3_t		up, down;
	vec3_t		down_o, down_v;

	VectorCopy (pm->ps->origin, start_o);
	VectorCopy (pm->ps->velocity, start_v);

	if ( PM_SlideMove( gravity ) == 0 ) {
		return;		// we got exactly where we wanted to go first try
	}

	VectorCopy(start_o, down);
	down[2] -= STEPSIZE;
	pm->trace (&trace, start_o, pm->mins, pm->maxs, down, pm->ps->clientNum, pm->tracemask, qtrue);
	VectorSet(up, 0, 0, 1);
	// never step up when you still have up velocity
	if ( pm->ps->velocity[2] > 0 && (trace.fraction == 1.0 ||
										DotProduct(trace.plane.normal, up) < 0.7)) {
		return;
	}

	VectorCopy (start_o, up);
	up[2] += STEPSIZE;

	// test the player position if they were a stepheight higher
	pm->trace (&trace, up, pm->mins, pm->maxs, up, pm->ps->clientNum, pm->tracemask, qtrue);
	if ( trace.allsolid ) {
		if ( pm->debugLevel ) {
			Com_Printf("%i:bend can't step\n", c_pmove);
		}
		return;		// can't step up
	}

	// try slidemove from this position
	VectorCopy (up, pm->ps->origin);
	VectorCopy (start_v, pm->ps->velocity);

	PM_SlideMove( gravity );

	VectorCopy (pm->ps->origin, down_o);
	VectorCopy (pm->ps->velocity, down_v);

	// push down the final amount
	VectorCopy (pm->ps->origin, down);
	down[2] -= STEPSIZE;
	pm->trace (&trace, pm->ps->origin, pm->mins, pm->maxs, down, pm->ps->clientNum, pm->tracemask, qtrue );

	if ( !trace.allsolid )
		{
      if ( 	( trace.fraction < 1.0 ) && trace.plane.normal[ 2 ] < MIN_WALK_NORMAL )
			{
			slopeSlideFlag = qtrue;
         //VectorCopy (start_o, pm->ps->origin);
         //return;
			} else
				slopeSlideFlag = qfalse;
		}
   

	VectorCopy (trace.endpos, pm->ps->origin);

	if ( trace.fraction < 1.0 ) {
		PM_ClipVelocity( pm->ps->velocity, trace.plane.normal, pm->ps->velocity, OVERCLIP );
	}

	// use the step move
	pm->stepped = qtrue;
	if ( pm->debugLevel ) {
		Com_Printf("%i:stepped\n", c_pmove);
	}
}*/

float PM_TryStepSlideMove( qboolean gravity, float stepSize )
{
	trace_t		trace;
	vec3_t		up, down;
	vec3_t		diff;
	float		distance;

	VectorCopy( pm->ps->origin, up );
	up[2] += stepSize;

	// test the player position if they were a stepheight higher
	pm->trace( &trace, up, pm->mins, pm->maxs, up, pm->ps->clientNum, pm->tracemask, qtrue );

	if ( trace.allsolid ) 
	{
		if ( pm->debugLevel ) 
		{
			Com_WPrintf("%i:bend can't step\n", c_pmove);
		}
		return 0.0f;		// can't step up
	}

	// try slidemove from this position
	VectorCopy( up, pm->ps->origin );
	//VectorCopy( start_v, pm->ps->velocity );

	PM_SlideMove( gravity );

	VectorSubtract( pm->ps->origin, up, diff );
	distance = VectorLength( diff );

	// push down the final amount
	VectorCopy (pm->ps->origin, down);
	down[2] -= stepSize;
	pm->trace (&trace, pm->ps->origin, pm->mins, pm->maxs, down, pm->ps->clientNum, pm->tracemask, qtrue );

	if ( !trace.allsolid ) 
	{
		VectorCopy (trace.endpos, pm->ps->origin);
	}

	if ( trace.fraction < 1.0f ) 
	{
		PM_ClipVelocity( pm->ps->velocity, trace.plane.normal, pm->ps->velocity, OVERCLIP );
	}

	return distance;
}

void PM_StepSlideMove( qboolean gravity ) 
{
	vec3_t		start_o, start_v;
	float		try1Distance, try2Distance, simpleTryDistance;
	vec3_t		try1_o, try1_v;
	vec3_t		simpleTry1_o, simpleTry1_v;
	vec3_t		simpleDiff;

	// Save off the starting info

	VectorCopy( pm->ps->origin, start_o );
	VectorCopy( pm->ps->velocity, start_v );

	// Try the movement directly forward first

	if ( PM_SlideMove( gravity ) == 0 ) 
	{
		return;		// we got exactly where we wanted to go first try	
	}

	// Save off attempt

	VectorCopy( pm->ps->origin, simpleTry1_o );
	VectorCopy( pm->ps->velocity, simpleTry1_v );

	VectorSubtract( simpleTry1_o, start_o, simpleDiff );
	simpleTryDistance = VectorLength( simpleDiff );

	// Reset everything that could have changed so far

	VectorCopy( start_o, pm->ps->origin );
	VectorCopy( start_v, pm->ps->velocity );

	// Try movement when stepping up a full stepsize

	try1Distance = PM_TryStepSlideMove( gravity, STEPSIZE );

	// Save off attempt

	VectorCopy( pm->ps->origin, try1_o );
	VectorCopy( pm->ps->velocity, try1_v );

	// Reset everything that could have changed so far

	VectorCopy( start_o, pm->ps->origin );
	VectorCopy( start_v, pm->ps->velocity );

	// Try movement when stepping up half the stepsize

	try2Distance = PM_TryStepSlideMove( gravity, STEPSIZE / 2.0f );

	// Pick the move that went the furthest forward

	if ( try1Distance > try2Distance )
	{
		VectorCopy( try1_o, pm->ps->origin );
		VectorCopy( try1_v, pm->ps->velocity );
	}

	if ( ( try1Distance < 0.001f ) && ( try2Distance < 0.001f ) && ( simpleTryDistance > 0.0f ) )
	{
		VectorCopy( simpleTry1_o, pm->ps->origin );
		VectorCopy( simpleTry1_v, pm->ps->velocity );
	}

	pm->stepped = qtrue;		// allow client to smooth out the step

	if ( pm->debugLevel ) 
	{
		Com_Printf("%i:stepped\n", c_pmove);
	}
}

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

Handles both ground friction and water friction
==================
*/
void PM_Friction
   (
   void
   )

   {
	vec3_t	vec;
	float	   *vel;
	float	   speed;
   float	   newspeed;
   float	   control;
	float	   drop;

	vel = pm->ps->velocity;

	VectorCopy( vel, vec );
	if ( pml.walking )
      {
      // ignore slope movement
		vec[ 2 ] = 0.0f;
	   }

	speed = VectorLength( vec );
	if ( speed < 1.0f )
      {
      // allow sinking underwater
		vel[ 0 ] = 0;
		vel[ 1 ] = 0;

		return;
	   }

	drop = 0;

	// apply ground friction
	if ( pml.walking )
      {
		// if getting knocked back, no friction
		if ( !( pm->ps->pm_flags & PMF_TIME_KNOCKBACK ) )
         {
			control = ( speed < (float)pm->ps->pm_stopspeed ) ? (float)pm->ps->pm_stopspeed : speed;
         if ( pml.groundTrace.surfaceFlags & SURF_SLICK )
            {
   			drop += control * pm_slipperyfriction * pml.frametime;
            }
         else
            {
   			drop += control * (float)pm->ps->pm_friction * pml.frametime;
            }
		   }
	   }

	// apply water friction
	if ( pm->waterlevel )
      {
      if ( pm->watertype & CONTENTS_SLIME )
         {
   		drop += speed * (float)pm->ps->pm_waterfriction * 5.0f * pm->waterlevel * pml.frametime;
   		//drop += speed * pm->ps->pm_waterfriction * 2 * pml.frametime;
         }
      else
         {
   		drop += speed * (float)pm->ps->pm_waterfriction * (float)pm->waterlevel * pml.frametime;
         }
	   }

	// scale the velocity
	newspeed = speed - drop;
	if ( newspeed < 0.0f )
      {
		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
   (
   const vec3_t wishdir,
   float wishspeed,
   float accel
   )

   {
	int	i;
	float	addspeed;
   float accelspeed;
   float currentspeed;

	currentspeed = DotProduct( pm->ps->velocity, wishdir );
	addspeed = wishspeed - currentspeed;
	if ( addspeed <= 0.0f )
      {
		return;
	   }

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

	for( i = 0; i < 3; i++ )
      {
		pm->ps->velocity[ i ] += accelspeed * wishdir[ i ];
	   }
   }


/*
============
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.
============
*/

float PM_CmdScale
   (
   const usercmd_t *cmd
   )

   {
	int	max;
	float	total;
	float	scale;

	max = abs( cmd->forwardmove );
	if ( abs( cmd->rightmove ) > max )
      {
		max = abs( cmd->rightmove );
	   }

	if ( abs( cmd->upmove ) > max )
      {
		max = abs( cmd->upmove );
	   }

	if ( !max )
      {
		return 0;
	   }

	if ( ( pm->ps->pm_flags & PMF_DUCKED ) && ( cmd->upmove >= 0 ) )
	{
		// This means we are being forced to duck (take into account this forced down movement)
		total = sqrt( ( cmd->forwardmove * cmd->forwardmove ) + ( cmd->rightmove * cmd->rightmove ) + ( -127 * -127 ) );
	}
	else
	{
		// This is the normal case 
		total = sqrt( ( cmd->forwardmove * cmd->forwardmove ) + ( cmd->rightmove * cmd->rightmove ) + ( cmd->upmove * cmd->upmove ) );
	}

	scale = (float)pm->ps->speed * (float)max / ( 127.0f * total );

	return scale;
   }

/*
=============
PM_CheckJump
=============
*/

qboolean PM_CheckJump( void ) {

	//If we are ducked, then we can't jump
	//PMF_DUCKED means the player is either 
	//pressing duck, or the player is ducked in
	//an area where they cannot stand up.
	if(pm->ps->pm_flags & PMF_DUCKED)
		return qfalse;

/*	jhefty/jwaters -- another strafe-jump fix
	if (pm->ps->commandTime < pm->ps->pm_landtime)
		return qfalse;
*/
	/* if ( pm->ps->pm_flags & PMF_TIME_LAND ) {
		// hasn't been long enough since landing to jump again
		return qfalse;
	} */

	if ( pm->cmd.upmove < 10 ) {
		// not holding jump
		return qfalse;
	}

	// must wait for jump to be released
	if ( pm->ps->pm_flags & PMF_JUMP_HELD ) {
		return qfalse;
	}

	pml.groundPlane = qfalse;		// jumping away
 	pml.walking = qfalse;
	pm->ps->pm_flags |= PMF_JUMP_HELD;

	pm->ps->groundEntityNum = ENTITYNUM_NONE;
	pm->ps->velocity[2] = pm->ps->jumpvelocity;

	return qtrue;
}

/*
=============
PM_CheckWaterJump
=============
*/
qboolean	PM_CheckWaterJump
   (
   void
   )

   {
	vec3_t	spot;
	int		cont;

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

	// check for water jump
	if ( ( pm->waterlevel < 2 ) )
      {
		return qfalse;
	   }
   // if we are below the surface and not in slime, return
	if ( !( pm->watertype & CONTENTS_SLIME ) && ( pm->waterlevel == 3 ) )
      {
		return qfalse;
	   }

   VectorMA( pm->ps->origin, 80.0f, pml.flat_forward, spot );
	spot[ 2 ] += pm->ps->viewheight - 16.0f;
	cont = pm->pointcontents( spot, pm->ps->clientNum );
	if ( !( cont & pm->tracemask ) )
      {
		return qfalse;
	   }

	spot[ 2 ] += 48.0f;
	cont = pm->pointcontents( spot, pm->ps->clientNum );
	if ( cont )
      {
		return qfalse;
	   }

	// jump out of water
	VectorScale( pml.flat_forward, 150, pm->ps->velocity );
	pm->ps->velocity[ 2 ] = 600;

	pm->ps->pm_flags |= PMF_TIME_WATERJUMP;
	pm->ps->pm_time = 2000;

	return qtrue;
   }

//============================================================================


/*
===================
PM_WaterJumpMove

Flying out of the water
===================
*/
void PM_WaterJumpMove
   (
   void
   )

   {
	// waterjump has no control, but falls
	PM_StepSlideMove( !( pm->ps->pm_flags & PMF_NO_GRAVITY ) );

	pm->ps->velocity[ 2 ] -= (float)pm->ps->gravity * pml.frametime;
	if ( pm->ps->velocity[ 2 ] < 0.0f )
      {
		// cancel as soon as we are falling down again
		pm->ps->pm_flags &= ~PMF_ALL_TIMES;
		pm->ps->pm_time = 0;
	   }
   }

#define SLIME_SINK_SPEED -10.0f
/*
===================
PM_WaterMove

===================
*/
void PM_WaterMove
   (
   void
   )

   {
	int		i;
	vec3_t	wishvel;
	float	   wishspeed;
	vec3_t	wishdir;
	float	   scale;

	if ( PM_CheckWaterJump() )
      {
		PM_WaterJumpMove();
		return;
   	}

   //
   // clamp our speed if we are in slime
   //
   if ( pm->watertype & CONTENTS_SLIME )
      {
      if ( pm->ps->velocity[ 2 ] < SLIME_SINK_SPEED )
         {
         pm->ps->velocity[ 2 ] = SLIME_SINK_SPEED;
         }
      }

	PM_Friction();

	scale = PM_CmdScale( &pm->cmd );

	//
	// user intentions
	//
	if ( !scale )
      {
		wishvel[ 0 ] = 0;
		wishvel[ 1 ] = 0;
      if ( pm->watertype & CONTENTS_SLIME )
         {
	      wishvel[ 2 ] = SLIME_SINK_SPEED;		// sink towards bottom
         }
      else
         {
		   wishvel[ 2 ] = -60;		// sink towards bottom
         }
	   }
   else
      {
		for( i = 0; i < 3; i++ )
         {
			wishvel[ i ] = ( scale * pml.flat_forward[ i ] * pm->cmd.forwardmove ) - ( scale * pml.flat_left[ i ] * pm->cmd.rightmove );
         }

		wishvel[ 2 ] += scale * pm->cmd.upmove;
	   }
   if ( ( pm->watertype & CONTENTS_SLIME ) && ( pm->waterlevel > 2 ) && ( wishvel[ 2 ] < 0.0f ) )
      {
      wishvel[ 2 ] = 0;
      }

	VectorCopy( wishvel, wishdir );
	wishspeed = VectorNormalize( wishdir );

	if ( wishspeed > ( pm->ps->speed * pm_swimScale ) )
      {
		wishspeed = pm->ps->speed * pm_swimScale;
	   }

	PM_Accelerate( wishdir, wishspeed, pm->ps->pm_wateraccelerate );

	PM_SlideMove( qfalse );
   }

/*
===================
PM_StuckJumpMove

Flying out of someplace we were stuck
===================
*/
void PM_StuckJumpMove
   (
   void
   )

   {
	// stuckjump has no control, but falls
	PM_StepSlideMove( !( pm->ps->pm_flags & PMF_NO_GRAVITY ) );

	pm->ps->velocity[ 2 ] -= pm->ps->gravity * pml.frametime;
	if ( pm->ps->velocity[ 2 ] < -48.0f )
      {
		// cancel as soon as we are falling at decent clip again
		pm->ps->pm_flags &= ~PMF_ALL_TIMES;
		pm->ps->pm_time = 0;
	   }
   }

/*
===================
PM_FlyMove

Only with the flight powerup
===================
*/
void PM_FlyMove( void ) {
	float	   speed;
   float    drop;
   float    friction;
   float    control;
   float    newspeed;
	int		i;
	vec3_t	wishvel;
	float		fmove;
   float    smove;
	vec3_t	wishdir;
	float		wishspeed;
	float		scale;

	// friction

	speed = VectorLength( pm->ps->velocity );
	if ( speed < 1.0f )
	   {
		VectorCopy( vec3_origin, pm->ps->velocity );
	   }
	else
	   {
		drop = 0;

      // extra friction
		friction = pm->ps->pm_friction * 1.5f;

		control = speed < pm->ps->pm_stopspeed ? pm->ps->pm_stopspeed : speed;
		drop += control * friction * pml.frametime;

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

		VectorScale( pm->ps->velocity, newspeed, pm->ps->velocity );
	   }

	// accelerate
	scale = PM_CmdScale( &pm->cmd );

	fmove = pm->cmd.forwardmove;
	smove = pm->cmd.rightmove;
   pm->ps->pm_runtime = 0;

	for( i = 0; i < 3; i++ )
      {
		wishvel[ i ] = ( pml.flat_forward[ i ] * fmove ) - ( pml.flat_left[ i ] * smove );
      }

	wishvel[ 2 ] += pm->cmd.upmove;

	VectorCopy( wishvel, wishdir );
	wishspeed = VectorNormalize( wishdir );
	wishspeed *= scale;

	PM_Accelerate( wishdir, wishspeed, pm->ps->pm_accelerate );

	// move
	PM_StepSlideMove( qtrue );
	//VectorMA( pm->ps->origin, pml.frametime, pm->ps->velocity, pm->ps->origin );
}

/*
=============
PM_CheckStuckJump
=============
*/
//#define MAX_XY_VELOCITY 50
qboolean	PM_CheckStuckJump
   (
   void
   )

   {
   vec3_t   diff;

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

	if ( pm->waterlevel > 1 )
      {
		return qfalse;
	   }

   VectorSubtract( pm->ps->origin, pml.previous_origin, diff );
   if ( VectorLength( diff ) )
      {
      return qfalse;
      }
   if ( VectorLength( pm->ps->velocity ) < 100.0f )
      {
      return qfalse;
      }

   // we have been falling, we haven't moved and our velocity is getting dangerously high
   // let's give ourselves a boost straight up and opposite our current velocity
  /* pm->ps->velocity[ 0 ] = -pm->ps->velocity[ 0 ];
   if ( pm->ps->velocity[ 0 ] > MAX_XY_VELOCITY )
      pm->ps->velocity[ 0 ] = MAX_XY_VELOCITY;
   else if ( pm->ps->velocity[ 0 ] < -MAX_XY_VELOCITY )
      pm->ps->velocity[ 0 ] = -MAX_XY_VELOCITY;

   pm->ps->velocity[ 1 ] = -pm->ps->velocity[ 1 ];
   if ( pm->ps->velocity[ 1 ] > MAX_XY_VELOCITY )
      pm->ps->velocity[ 1 ] = MAX_XY_VELOCITY;
   else if ( pm->ps->velocity[ 1 ] < -MAX_XY_VELOCITY )
      pm->ps->velocity[ 1 ] = -MAX_XY_VELOCITY;

	pm->ps->velocity[ 2 ] = 500;

	pm->ps->pm_flags |= PMF_TIME_STUCKJUMP;
	pm->ps->pm_time = 2000;*/

	return qtrue;
   }

/*
=============
PM_CheckTerminalVelocity
=============
*/
#define TERMINAL_VELOCITY 1200.0f

void PM_CheckTerminalVelocity
   (
   void
   )
   {
   float oldspeed;
   float speed;

   //
   // how fast were we falling
   //
   oldspeed = -pml.previous_velocity[ 2 ];

   //
   // how fast are we falling
   //
   speed = -pm->ps->velocity[ 2 ];

	if ( speed <= 0.0f )
      {
		return;
	   }

	if ( ( oldspeed <= TERMINAL_VELOCITY ) && ( speed > TERMINAL_VELOCITY ) )
      {
		pm->pmoveEvent = EV_TERMINAL_VELOCITY;
   	}
   }

/*
===================
PM_AirMove

===================
*/
void PM_AirMove
   (
   void
   )

   {
	vec3_t		wishvel;
	float		   fmove;
   float       smove;
	vec3_t		wishdir;
	float		   wishspeed;
	float		   scale;
	usercmd_t	cmd;

	vec3_t		original_start;
	vec3_t		original_end;
	float			old_speed;
	vec3_t original_diff;
	float original_dist;
	vec3_t new_diff;
	float new_dist;
	float new_speed;
	float max_new_speed;

	// Save some information about original state of things

	VectorCopy( pm->ps->origin, original_start );
	VectorMA( pm->ps->origin, pml.frametime, pm->ps->velocity, original_end );
	old_speed = VectorLength( pm->ps->velocity );

   //PM_Friction();

	fmove = pm->cmd.forwardmove;
	smove = pm->cmd.rightmove;
   pm->ps->pm_runtime = 0;

	cmd = pm->cmd;
	scale = PM_CmdScale( &cmd );

   wishvel[ 0 ] = ( pml.flat_forward[ 0 ] * fmove ) - ( pml.flat_left[ 0 ] * smove );
   wishvel[ 1 ] = ( pml.flat_forward[ 1 ] * fmove ) - ( pml.flat_left[ 1 ] * smove );
	wishvel[ 2 ] = 0.0f;

	VectorCopy( wishvel, wishdir );
	wishspeed = VectorNormalize( wishdir );
	wishspeed *= scale;

	// not on ground, so little effect on velocity
	PM_Accelerate( wishdir, wishspeed, pm->ps->pm_airaccelerate );

	// we may have a ground plane that is very steep, even
	// though we don't have a groundentity
	// slide along the steep plane
	if ( pml.groundPlane )
      {
		PM_ClipVelocity( pm->ps->velocity, pml.groundTrace.plane.normal, pm->ps->velocity, OVERCLIP );
	   }

   if ( !pml.walking && pml.groundPlane )
      {
      vec3_t vel;

		VectorCopy( pm->ps->velocity, vel );
		vel[ 2 ] -= pm->ps->gravity * pml.frametime;
		pm->ps->velocity[ 2 ] = ( pm->ps->velocity[ 2 ] + vel[ 2 ] ) * 0.5f;
      PM_SlideMove( qfalse );
      VectorCopy( vel, pm->ps->velocity );
      }
   else
      {
      PM_SlideMove( !( pm->ps->pm_flags & PMF_NO_GRAVITY ) );
      }
	
	if ( PM_CheckStuckJump() )
      {
		PM_StuckJumpMove();
   	}

	// Get the distance we tried to move

	VectorSubtract( original_start, original_end, original_diff );
	original_dist = VectorLength( original_diff );

	// Get the distance we actually moved

	VectorSubtract( original_start, pm->ps->origin, new_diff );
	new_dist = VectorLength( new_diff );

	if ( ( new_dist < original_dist ) && ( new_dist > 0 ) )
		{
		// Modify our velocity based on how far we got to move

		max_new_speed = old_speed * ( new_dist / original_dist );

		new_speed = VectorLength( pm->ps->velocity );

		if ( new_speed > max_new_speed )
			{
			VectorNormalize( pm->ps->velocity );
			VectorScale( pm->ps->velocity, max_new_speed, pm->ps->velocity );
			}
		}

   PM_CheckTerminalVelocity();
   }

void AddPlane
   (
   const vec3_t norm,
   vec3_t planes[ MAX_CLIP_PLANES ],
   int *numplanes
   )

   {
   int i;

   if ( *numplanes >= MAX_CLIP_PLANES )
      {
      return;
      }

   for( i = 0; i < *numplanes; i++ )
      {
      if ( VectorCompare( planes[ i ], norm ) )
         {
         // don't add the plane twice
         return;
         }
      }

   VectorCopy( norm, planes[ *numplanes ] );
	( *numplanes )++;
   }

void PM_StepMove
   (
   void
   )

   {
   trace_t trace;
   vec3_t up;
   vec3_t down;
   vec3_t oldvelocity;
   vec3_t oldorigin;
   vec3_t velocity1;
   vec3_t origin1;

   VectorCopy( pm->ps->velocity, oldvelocity );
   VectorCopy( pm->ps->origin, oldorigin );

   if ( PM_SlideMove( !( pm->ps->pm_flags & PMF_NO_GRAVITY ) ) )
      {
      VectorCopy( pm->ps->velocity, velocity1 );
      VectorCopy( pm->ps->origin, origin1 );

      VectorCopy( oldvelocity, pm->ps->velocity );

      VectorCopy( oldorigin, up );
      up[ 2 ] += STEPSIZE;

      //pm->trace( &trace, oldorigin, pm->mins, pm->maxs, up, pm->ps->clientNum, pm->tracemask, qtrue );
      pm->trace( &trace, up, pm->mins, pm->maxs, up, pm->ps->clientNum, pm->tracemask, qtrue );
      VectorCopy( trace.endpos, pm->ps->origin );

      PM_SlideMove( !( pm->ps->pm_flags & PMF_NO_GRAVITY ) );

      VectorCopy( pm->ps->origin, down );
      down[ 2 ] = oldorigin[ 2 ];

      pm->trace( &trace, pm->ps->origin, pm->mins, pm->maxs, down, pm->ps->clientNum, pm->tracemask, qtrue );
      if ( trace.plane.normal[ 2 ] < MIN_WALK_NORMAL )
         {
         // use the first move
         VectorCopy( velocity1, pm->ps->velocity );
         VectorCopy( origin1, pm->ps->origin );
         }
      else
         {
         VectorCopy( trace.endpos, pm->ps->origin );
         pm->stepped = qtrue;
         }
      }
   }

/*
===================
PM_WalkMove

===================
*/

void PM_WalkMove
   (
   void
   )

   {
   int         i;
	vec3_t		wishvel;
	float		   fmove;
   float       smove;
	vec3_t		wishdir;
	float		   wishspeed;
	float		   scale;
	usercmd_t	cmd;
	float		   accelerate;
   float	      waterScale;

	if ( ( pm->waterlevel > 2 ) && ( DotProduct( pml.forward, pml.groundTrace.plane.normal ) > 0.0f ) )
      {
		// begin swimming
		PM_WaterMove();

		return;
	   }

	if ( pm->ps->instantJump )
		if ( PM_CheckJump () ) {
			// jumped away
			pm->ps->jumped = qtrue;
			pm->ps->pm_time = 150;
			pm->ps->pm_flags |= PMF_TIME_JUMP_START;
			if ( pm->waterlevel > 1 ) {
				PM_WaterMove();
			} else {
				PM_AirMove();
			}
			return;
		}

	PM_Friction();

   fmove = pm->cmd.forwardmove;
   smove = pm->cmd.rightmove;

	cmd = pm->cmd;
	scale = PM_CmdScale( &cmd );

   if ( ( pm->cmd.buttons & BUTTON_RUN ) && fmove && !smove )
      {
      pm->ps->pm_runtime += pml.msec;
      }
   else
      {
      pm->ps->pm_runtime = 0;
      }

   //
   // only run faster if we have exceeded our running time
   //
/*   if ( ( pm->ps->stats[STAT_WATER_LEVEL] >= MINIMUM_WATER_FOR_TURBO ) && ( pm->ps->pm_runtime > WATER_TURBO_TIME ) )
      {
      scale *= WATER_TURBO_SPEED;
      }*/

	// project the forward and right directions onto the ground plane
	PM_ClipVelocity (pml.flat_forward, pml.groundTrace.plane.normal, pml.flat_forward, OVERCLIP );
	PM_ClipVelocity (pml.flat_left, pml.groundTrace.plane.normal, pml.flat_left, OVERCLIP );

	VectorNormalize (pml.flat_forward);
	VectorNormalize (pml.flat_left);

	for( i = 0 ; i < 3 ; i++ )
      {
		wishvel[ i ] = pml.flat_forward[ i ] * fmove - pml.flat_left[ i ] * smove;
	   }

	VectorCopy( wishvel, wishdir );
	wishspeed = VectorNormalize( wishdir );
	wishspeed *= scale;

	// clamp the speed lower if wading or walking on the bottom
	if ( pm->waterlevel )
      {
		waterScale = pm->waterlevel / 3.0f;
		waterScale = 1.0f - ( 1.0f - pm_swimScale ) * waterScale;
		if ( wishspeed > ( pm->ps->speed * waterScale ) )
         {
			wishspeed = pm->ps->speed * waterScale;
		   }
	   }

	// when a player gets hit, they temporarily lose
	// full control, which allows them to be moved a bit
	if ( ( pml.groundTrace.surfaceFlags & SURF_SLICK ) || ( pm->ps->pm_flags & PMF_TIME_KNOCKBACK ) )
      {
		accelerate = pm->ps->pm_airaccelerate;
	   }
   else
      {
		accelerate = pm->ps->pm_accelerate;
	   }

	PM_Accelerate( wishdir, wishspeed, accelerate );

	if ( ( pml.groundTrace.surfaceFlags & SURF_SLICK ) || ( pm->ps->pm_flags & PMF_TIME_KNOCKBACK ) )
      {
		pm->ps->velocity[ 2 ] -= pm->ps->gravity * pml.frametime;
	   }

	// don't do anything if standing still
	if ( !pm->ps->velocity[ 0 ] && !pm->ps->velocity[ 1 ] && !pm->ps->velocity[ 2 ] )
		return;

   PM_StepSlideMove ( !( pm->ps->pm_flags & PMF_NO_GRAVITY ) );
   }

/*
==============
PM_DeadMove
==============
*/
void PM_DeadMove
   (
   void
   )

   {
	float	forward;

	if ( !pml.walking )
      {
		return;
	   }

	// extra friction
	forward = VectorLength( pm->ps->velocity );
	forward -= 20.0f;
	if ( forward <= 0.0f )
      {
		VectorClear( pm->ps->velocity );
	   }
   else
      {
		VectorNormalize( pm->ps->velocity );
		VectorScale( pm->ps->velocity, forward, pm->ps->velocity );
	   }
   }


/*
===============
PM_NoclipMove
===============
*/
void PM_VehicleMove
   (
   void
   )

   {
	
  	vec3_t		wishvel;
	//float		   fmove;
   //float       smove;
	vec3_t		wishdir;
	float		   wishspeed;
	float		   scale;
	usercmd_t	cmd;
	float		   accelerate;
  
   //fmove = pm->cmd.forwardmove;
   //smove = pm->cmd.rightmove;

	cmd = pm->cmd;
	scale = PM_CmdScale( &cmd );

   pm->ps->pm_runtime = 0;

	wishvel[0] = pm->ps->velocity[0];
	wishvel[1] = pm->ps->velocity[1];
	wishvel[2] = pm->ps->velocity[2];

	VectorCopy( wishvel, wishdir );
	wishspeed = VectorNormalize( wishdir );
	wishspeed *= scale;
	
	accelerate = pm->ps->pm_accelerate;
	PM_Accelerate( wishdir, wishspeed, accelerate );

	// don't do anything if standing still
	if ( !pm->ps->velocity[ 0 ] && !pm->ps->velocity[ 1 ] )
		return;

   //PM_StepSlideMove ( !( pm->ps->pm_flags & PMF_NO_GRAVITY ) );
   }



/*
===============
PM_NoclipMove
===============
*/
void PM_NoclipMove
   (
   void
   )

   {
	float	   speed;
   float    drop;
   float    friction;
   float    control;
   float    newspeed;
	int		i;
	vec3_t	wishvel;
	float		fmove;
   float    smove;
	vec3_t	wishdir;
	float		wishspeed;
	float		scale;

	pm->ps->viewheight = pm->ps->pm_defaultviewheight;

	// friction

	speed = VectorLength( pm->ps->velocity );
	if ( speed < 1.0f )
	   {
		VectorCopy( vec3_origin, pm->ps->velocity );
	   }
	else
	   {
		drop = 0;

      // extra friction
		friction = pm->ps->pm_friction * 1.5f;

		control = speed < pm->ps->pm_stopspeed ? pm->ps->pm_stopspeed : speed;
		drop += control * friction * pml.frametime;

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

		VectorScale( pm->ps->velocity, newspeed, pm->ps->velocity );
	   }

	// accelerate
   // allow the player to move twice as fast in noclip
	scale = PM_CmdScale( &pm->cmd ) * 2.0f;

	fmove = pm->cmd.forwardmove;
	smove = pm->cmd.rightmove;
   pm->ps->pm_runtime = 0;

	for( i = 0; i < 3; i++ )
      {
		wishvel[ i ] = ( pml.flat_forward[ i ] * fmove ) - ( pml.flat_left[ i ] * smove );
      }

	wishvel[ 2 ] += pm->cmd.upmove;

	VectorCopy( wishvel, wishdir );
	wishspeed = VectorNormalize( wishdir );
	wishspeed *= scale;

	PM_Accelerate( wishdir, wishspeed, pm->ps->pm_accelerate );

	// move
	VectorMA( pm->ps->origin, pml.frametime, pm->ps->velocity, pm->ps->origin );
   }

//============================================================================

/*
=============
PM_CorrectAllSolid
=============
*/
void PM_CorrectAllSolid
   (
   void
   )

   {
	if ( pm->debugLevel )
      {
		Com_Printf( "%i:allsolid\n", c_pmove );
	   }

	// FIXME: jitter around
	pm->ps->groundEntityNum = ENTITYNUM_NONE;
	pml.groundPlane = qfalse;
	pml.walking = qfalse;
   }

/*
=============
PM_GroundTrace
=============
*/
void PM_GroundTrace
   (
   qboolean onlyTrace
   )

   {
	vec3_t   point;
	vec3_t	tmporg;
	trace_t  trace;

	point[ 0 ] = pm->ps->origin[ 0 ];
	point[ 1 ] = pm->ps->origin[ 1 ];
	point[ 2 ] = pm->ps->origin[ 2 ] - 9.0f; // long trace to avoid potential terrain hitches

	pm->trace( &trace, pm->ps->origin, pm->mins, pm->maxs, point, pm->ps->clientNum, pm->tracemask, qtrue );

	if (!(trace.surfaceFlags & SURF_TERRAIN )) // if we're not on terrain, go back to 0.25f trace distance
	{
		point[ 2 ] = pm->ps->origin[ 2 ] - 0.25f;
		pm->trace( &trace, pm->ps->origin, pm->mins, pm->maxs, point, pm->ps->clientNum, pm->tracemask, qtrue );
	}

	pml.groundTrace = trace;
	pm->ps->groundTrace = trace;

	// do something corrective if the trace starts in a solid...
	if ( trace.allsolid )
      {
		// We're gonna start with our origin a tad higher and see if it works
		tmporg[ 0 ] = pm->ps->origin[ 0 ];
		tmporg[ 1 ] = pm->ps->origin[ 1 ];
		tmporg[ 2 ] = pm->ps->origin[ 2 ] + 2.0f;

		// Trace down to the same point
		pm->trace( &trace, tmporg, pm->mins, pm->maxs, point, pm->ps->clientNum, pm->tracemask, qtrue );
		pml.groundTrace = trace;
		pm->ps->groundTrace = trace;

		// It's hopeless if we start all solid again
		if ( trace.allsolid )
			{
			PM_CorrectAllSolid();
			pm->ps->walking = pml.walking;
			pm->ps->groundPlane = pml.groundPlane;

			return;
			}
	   }

	// if the trace didn't hit anything, we are in free fall
	if ( trace.fraction == 1.0f )
      {
		if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
         {
			if ( pm->debugLevel )
            {
				Com_Printf( "%i:lift\n", c_pmove );
			   }
		   }

		pm->ps->groundEntityNum = ENTITYNUM_NONE;
		pml.groundPlane = qfalse;
		pml.walking = qfalse;

      pm->ps->walking = pml.walking;
      pm->ps->groundPlane = pml.groundPlane;

      return;
	   }

	// slopes that are too steep will not be considered onground
	// check slopeSlideFlag to avoid the "falling" bug
	if ( trace.plane.normal[ 2 ] < MIN_WALK_NORMAL )
      {
      vec3_t oldvel;
      float d;

		if ( pm->debugLevel )
         {
			Com_Printf( "%i:steep\n", c_pmove );
		   }

		// if they can't slide down the slope, let them
		// walk (sharp crevices)
      VectorCopy( pm->ps->velocity, oldvel );
      VectorSet( pm->ps->velocity, 0.0f, 0.0f, -1.0f / pml.frametime );
      PM_SlideMove( qfalse );

      d = VectorLength( pm->ps->velocity );
      VectorCopy( oldvel, pm->ps->velocity );
      if ( d > ( 0.1f / pml.frametime ) )
         {
		   pm->ps->groundEntityNum = ENTITYNUM_NONE;
		   pml.groundPlane = qtrue;
		   pml.walking = qfalse;

         pm->ps->walking = pml.walking;
         pm->ps->groundPlane = pml.groundPlane;

		   return;
         }
	   }

	// check if getting thrown off the ground
	if ( ( pm->ps->velocity[ 2 ] > 0.0f ) && ( DotProduct( pm->ps->velocity, trace.plane.normal ) > 10.0f ) )
      {
		if ( pm->debugLevel )
         {
			Com_Printf( "%i:kickoff\n", c_pmove );
		   }
		pm->ps->groundEntityNum = ENTITYNUM_NONE;
		pml.groundPlane = qfalse;
		pml.walking = qfalse;

      pm->ps->walking = pml.walking;
      pm->ps->groundPlane = pml.groundPlane;

		return;
	   }

	pml.groundPlane = qtrue;
	pml.walking = qtrue;

	// hitting solid ground will end a waterjump
	if ( pm->ps->pm_flags & PMF_TIME_WATERJUMP )
	   {
		//pm->ps->pm_flags &= ~( PMF_TIME_WATERJUMP | PMF_TIME_LAND);
		pm->ps->pm_flags &= ~( PMF_TIME_WATERJUMP );
		pm->ps->pm_time = 0;
	   }

	// hitting solid ground will end a stuckjump
	if ( pm->ps->pm_flags & PMF_TIME_STUCKJUMP )
	   {
		pm->ps->pm_flags &= ~( PMF_TIME_STUCKJUMP );
		pm->ps->pm_time = 0;
	   }

	if ( !onlyTrace && !( pml.groundTrace.surfaceFlags & SURF_SLICK ) )
		pm->ps->velocity[ 2 ] = 0;

	pm->ps->groundEntityNum = trace.entityNum;

	PM_AddTouchEnt( trace.entityNum );

   pm->ps->walking = pml.walking;
   pm->ps->groundPlane = pml.groundPlane;
   }


/*
=============
PM_SetWaterLevel	FIXME: avoid this twice?  certainly if not moving
=============
*/
void PM_SetWaterLevel
   (
   void
   )

   {
	vec3_t  point;
	int	  cont;
	int	  sample1;
	int	  sample2;

   //
   // get waterlevel, accounting for ducking
   //
	pm->waterlevel = 0;
	pm->watertype = 0;

	sample2 = pm->ps->viewheight - MINS_Z;
	sample1 = sample2 * 3 / 4;

   VectorCopy( pm->ps->origin, point );
   point[ 2 ] += MINS_Z + 1.0f;
	cont = pm->pointcontents( point, pm->ps->clientNum );
	if ( cont & MASK_WATER )
	   {
		pm->watertype = cont;
		pm->waterlevel = 1;

      point[ 2 ] = pm->ps->origin[ 2 ] + MINS_Z + sample1;
		cont = pm->pointcontents( point, 0 );
		if ( cont & MASK_WATER )
		   {
			pm->waterlevel = 2;
         point[ 2 ] = pm->ps->origin[ 2 ] + MINS_Z + sample2;
			cont = pm->pointcontents( point, 0 );
			if ( cont & MASK_WATER )
            {
				pm->waterlevel = 3;
            }
		   }
	   }
   }


/*
==============
PM_CheckDuck

Sets mins, maxs, and pm->ps->viewheight
==============
*/
void PM_CheckDuck
   (
   void
   )

   {
	pm->mins[ 0 ] = MINS_X;
	pm->mins[ 1 ] = MINS_Y;
	pm->mins[ 2 ] = MINS_Z;
	pm->maxs[ 0 ] = MAXS_X;
	pm->maxs[ 1 ] = MAXS_Y;
	pm->maxs[ 2 ] = MAXS_Z;

	pm->ps->viewheight = pm->ps->pm_defaultviewheight;
	
	if ( pm->ps->pm_type == PM_DEAD )
      {
		pm->maxs[ 2 ] = DEAD_MINS_Z;
		return;
	   }

	if ( pm->ps->pm_flags & PMF_DUCKED )
	   {
		
			pm->maxs[ 2 ] = CROUCH_MAXS_Z;
			pm->ps->viewheight = CROUCH_VIEWHEIGHT;
	   }
   }


//-----------------------------------------------------
//
// Name:		PM_CheckCrouchJump
// Class:		None
//
// Description:	Checks to see if the player is ducking and jumping, which is a crouch jump.
//
// Parameters:	None
//
// Returns:		None
//-----------------------------------------------------
void PM_CheckCrouchJump(void)
{
	//if the player is not on the ground and is ducking,
	//set the crouch jump flag.
	if ( pm->ps->jumped && 
		 ( ( ( pm->ps->pm_flags & PMF_DUCKED ) && ( pm->ps->pm_flags & PMF_TIME_JUMP_START ) ) || 
		   ( !( pm->ps->pm_flags & PMF_TIME_JUMP_START ) && ( pm->ps->pm_flags & PMF_JUMP_HELD ) ) ) )
	{
 		if(pm->ps->crouchjumpset == qfalse)
		{
			pm->ps->pm_flags |= PMF_TIME_CROUCH_JUMP;
			pm->ps->crouchjumpset = qtrue;
		}
	}

	//This really sucks to put this code here, since the 
	//primary function of this procedure is to check if
	//crouch jump is active. Since CheckDuck sets the 
	//default height down if duck is pressed, this moves
	//it back up if the player is crouch jumping
	if(pm->ps->crouchjumpset == qtrue)
	{
		pm->ps->viewheight = pm->ps->pm_defaultviewheight;	
		pm->maxs[ 2 ] = MAXS_Z;
	}

	if(pm->ps->groundPlane)
	{
		pm->ps->crouchjumpset = qfalse;
	}
}


//-----------------------------------------------------
//
// Name:		PM_CrouchJumpMove
// Class:		None
//
// Description:	Allows the player to clear objects a little higher than a normal jump could. 
//
// Parameters:	None
//
// Returns:		None
//-----------------------------------------------------
void PM_CrouchJumpMove(void)
{
	PM_StepSlideMove( !( pm->ps->pm_flags & PMF_NO_GRAVITY ) );
	pm->ps->velocity[2] += pm->ps->crouchjumpvelocity;

	//turn off the jump crouch flag.
	pm->ps->pm_flags &= ~PMF_TIME_CROUCH_JUMP;
}

//===================================================================

qboolean PM_ShouldCrashLand( void )
{

	
/*	jhefty/jwaters -- another strafe-jump fix
	if (pml.impactSpeed)
		pm->ps->pm_landtime = pm->ps->commandTime + 175;
*/
	if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
	{
		//vec3_t diff;
		float delta;

		// We're on the ground, see if we hit it hard enough for a crash land

		//VectorSubtract( pm->ps->velocity, pml.previous_velocity, diff );
		//delta = VectorLength( diff );
		//delta = abs( pm->ps->velocity[ 2 ] - pml.previous_velocity[ 2 ] );
		delta = pm->ps->velocity[ 2 ] - pml.previous_velocity[ 2 ];

		if ( delta < 0.0f || pml.previous_velocity[ 2 ] > -400 )
			return qfalse;

		if ( delta > 600.0f )
		{
			return qtrue;
		}
	}

	return qfalse;
}

/*
=================
PM_CrashLand

Check for hard landings that generate sound events

  fall from 128: 400 = 160000
  fall from 256: 580 = 336400
  fall from 384: 720 = 518400
  fall from 512: 800 = 640000
  fall from 640: 960 =

  damage = deltavelocity*deltavelocity  * 0.0001

=================
*/
void PM_CrashLand
   (
   void
   )

   {
	float delta;
	/* float	dist;
	float	vel;
   float	acc;
	float	t;
	float	a, b, c, den; */
	//vec3_t diff;

	// calculate the exact velocity on landing
	/* dist = pm->ps->origin[ 2 ] - pml.previous_origin[ 2 ];
	vel = pml.previous_velocity[ 2 ];
	acc = -pm->ps->gravity;

	a = acc / 2;
	b = vel;
	c = -dist;

	den =  b * b - 4 * a * c;
	if ( den < 0 )
      {
		return;
	   }

	t = ( -b - sqrt( den ) ) / ( 2 * a );

	delta = vel + t * acc;

	if (delta < -200)
		{
		pm->ps->pm_flags |= PMF_TIME_LAND;
		// don't allow another jump for a little while
		if (delta < -400)
			pm->ps->pm_time = 200;	
		else
			pm->ps->pm_time = 144;
		} */

	// Get the change in speed

	//VectorSubtract( pm->ps->velocity, pml.previous_velocity, diff );
	//delta = VectorLength( diff );
	//delta = abs( pm->ps->velocity[ 2 ] - pml.previous_velocity[ 2 ] );

	delta = pm->ps->velocity[ 2 ] - pml.previous_velocity[ 2 ];

	if ( delta < 0.0f || pml.previous_velocity[ 2 ] > -400 )
		return;

	//delta = delta * delta * 0.0001f;

	// never take falling damage if completely underwater
	if ( pm->waterlevel == 3 )
      {
		return;
	   }

	// reduce falling damage if there is standing water
	if ( pm->waterlevel == 2 )
      {
		delta *= 0.25f;
	   }

	if ( pm->waterlevel == 1 )
      {
		delta *= 0.5f;
	   }

	if ( delta < 1.0f )
      {
		return;
	   }

	pm->landed = qtrue;
	pm->landedVelocity = pml.previous_velocity[2];

	// SURF_NODAMAGE is used for bounce pads where you don't ever
	// want to take damage or play a crunch sound
	if ( !( pml.groundTrace.surfaceFlags & SURF_NODAMAGE ) )
	{
		if ( delta > 1500.0f )
		{
			pm->pmoveEvent = EV_FALL_FATAL;
		}
		else if ( delta > 1300.0f )
		{
			pm->pmoveEvent = EV_FALL_VERY_FAR;
		}
		else if ( delta > 1100.0f )
		{
			pm->pmoveEvent = EV_FALL_FAR;
		}
		else if ( delta > 900.0f )
		{
			pm->pmoveEvent = EV_FALL_MEDIUM;
		}
		else if ( delta > 750.0f )
		{
			pm->pmoveEvent = EV_FALL_SHORT;
		}
		else if ( delta > 600.0f )
		{
			pm->pmoveEvent = EV_FALL_VERY_SHORT;
		}
	}

   }

/*
==============
PM_WaterEvents

Generate sound events for entering and leaving water
==============
*/
void PM_WaterEvents
   (
   void
   )

   {

	if ( ( pm->ps->pm_type == PM_SPECTATOR ) || ( pm->ps->pm_type == PM_SPECTATOR_FOLLOW ) )
		return;


   // FIXME?
	//
	// if just entered a water volume, play a sound
	//
	if ( !pml.previous_waterlevel && pm->waterlevel )
      {
		pm->pmoveEvent = EV_WATER_TOUCH;
	   }

	//
	// if just completely exited a water volume, play a sound
	//
	if ( pml.previous_waterlevel && ! pm->waterlevel )
      {
		pm->pmoveEvent = EV_WATER_LEAVE;
	   }

	//
	// check for head just going under water
	//
	if ( ( pml.previous_waterlevel != 3 ) && ( pm->waterlevel == 3 ) )
      {
		pm->pmoveEvent = EV_WATER_UNDER;
	   }

	//
	// check for head just coming out of water
	//
	if ( ( pml.previous_waterlevel == 3 ) && ( pm->waterlevel != 3 ) )
      {
		pm->pmoveEvent = EV_WATER_CLEAR;
	   }
   }

/*
================
PM_DropTimers
================
*/
void PM_DropTimers
   (
   void
   )

   {
	// drop misc timing counter
	if ( pm->ps->pm_time )
      {
		if ( pml.msec >= pm->ps->pm_time )
         {
			pm->ps->pm_flags &= ~PMF_ALL_TIMES;
			pm->ps->pm_time = 0;
		   }
      else
         {
			pm->ps->pm_time -= pml.msec;
		   }
	   }
   }



//-----------------------------------------------------
//
// Name:		PM_UpdateLeanIn
// Class:		None
//
// Description:	Calculates the lean in movement
//
// Parameters:	
//
// Returns:		
//-----------------------------------------------------
void PM_UpdateLeanIn( playerState_t* ps, const usercmd_t* cmd )
{
	vec3_t	viewOrigin;
	vec3_t	leanTraceMins;
	vec3_t	leanTraceMaxs;
	vec3_t	leftVector;
	vec3_t	leanTraceEnd;
	vec3_t	playerViewAngles;
	trace_t leanTrace;

	float leanDelta = ps->leanDelta;

	if( cmd->lean > 0 )
	{
		//We are leaning left, so calculate the new lean delta.
		//If lean delta is greater then the max lean delta
		//then set lean delta to be the max.
		leanDelta += ((( float ) pml.msec / ( float ) pm_leaninspeed) * pm_leanmaxdelta);
		if( leanDelta > pm_leanmaxdelta )
			leanDelta = pm_leanmaxdelta;
	}
	else
	{
		//We are leaning right, so calculate the new lean delta.
		//If lean delta is less than the negative max lean delta
		//then set lean delta to be the negative max lean delta.
		leanDelta -= ((( float ) pml.msec / ( float ) pm_leaninspeed) * pm_leanmaxdelta);
		if( leanDelta < -pm_leanmaxdelta )
			leanDelta = -pm_leanmaxdelta;
	}

	//We calculate our lean by scaling our view origin vector by the amount of the lean delta, 
	//then adding the left vector to get the delta amount of the lean.

	//Get the view origin
	VectorCopy( ps->origin, viewOrigin );
	viewOrigin[2] += ps->viewheight;

	//Get the view angles, remove all roll from the view angles.
	VectorCopy( ps->viewangles, playerViewAngles );
	playerViewAngles[ROLL] = 0;

	AngleVectors( ps->viewangles, NULL, leftVector, NULL );
	VectorMA( viewOrigin, leanDelta, leftVector, leanTraceEnd );
	
	
	//Run a trace to check if we collide with any object when we lean.
	VectorSet( leanTraceMins, -5, -5, -4 );
	VectorSet( leanTraceMaxs, 5, 5, 4 );

	if( pm != 0)
	{
		pm->trace(&leanTrace, viewOrigin, leanTraceMins, leanTraceMaxs, 
						leanTraceEnd, ps->clientNum, MASK_PLAYERSOLID, qfalse);

		//Scale the lean delta by the end result of the trace. 
		//This will scale our delta to the object that the trace has hit.
		leanDelta *= leanTrace.fraction;
	}

	ps->leanDelta = leanDelta;
}


//-----------------------------------------------------
//
// Name:		PM_UpdateLeanOut
// Class:		
//
// Description:	Calculates the lean out movement.
//
// Parameters:	ps - the current player state.
//
// Returns:		
//-----------------------------------------------------
void PM_UpdateLeanOut( playerState_t* ps )
{
	float leanDelta = ps->leanDelta;

	if( leanDelta > 0 )
	{
		leanDelta -= (( (float) pml.msec / (float) pm_leanoutspeed) * pm_leanmaxdelta);
		if( leanDelta < 0 )
			leanDelta = 0;
	}
	else if ( leanDelta < 0 )
	{
		leanDelta += (((float)pml.msec / ( float ) pm_leanoutspeed) * pm_leanmaxdelta);
		if( leanDelta > 0)
			leanDelta = 0;
	}

	ps->leanDelta = leanDelta;
}


//-----------------------------------------------------
//
// Name:		PM_UpdateLeanView
// Class:		
//
// Description:	Calculates the lean movement.
//
// Parameters:	ps  - the player state 
//				cmd - the input commands struct.
//
// Returns:		None
//-----------------------------------------------------
void PM_UpdateLeanView( playerState_t* ps, const usercmd_t* cmd )
{
	// We are not leaning, so move back to center position
	if(	cmd->lean == 0 )
	{
		PM_UpdateLeanOut(ps);
	}
	else 
	{
		PM_UpdateLeanIn(ps, cmd);
	}
}


/*
================
PM_UpdateViewAngles

This can be used as another entry point when only the viewangles
are being updated isntead of a full move
================
*/
void PM_UpdateViewAngles
   (
   playerState_t *ps,
   const usercmd_t *cmd
   )

   {
	short	temp;
	int	i;

	if ( ps->pm_flags & PMF_FROZEN )
      {
      // no view changes at all
		return;
	   }

   /*
	if ( ps->stats[ STAT_HEALTH ] <= 0 )
      {
      // no view changes at all
		return;
	   }
   */

	// circularly clamp the angles with deltas
	for( i = 0; i < 3; i++ )
      {
		temp = cmd->angles[ i ] + ps->delta_angles[ i ];
		if ( i == PITCH )
         {
			// don't let the player look up or down more than 90 degrees
			if ( temp > 16000 )
            {
				ps->delta_angles[ i ] = 16000 - cmd->angles[ i ];
				temp = 16000;
			   }
         else if ( temp < -16000 )
            {
				ps->delta_angles[ i ] = -16000 - cmd->angles[ i ];
				temp = -16000;
			   }
		   }

		ps->viewangles[ i ] = SHORT2ANGLE( temp );
	   }


	PM_UpdateLeanView( ps, cmd );
   }


void Pmove_GroundTrace
   (
   pmove_t *pmove
   )

   {
   memset (&pml, 0, sizeof(pml));
   pml.msec = 1;
	pml.frametime = 0.001f;
	pm = pmove;
	if ( !( pm->ps->pm_flags & PMF_NO_MOVE ) )
	{
		PM_CheckDuck();
		PM_CheckCrouchJump();
	}

   PM_GroundTrace( qtrue );
   }


/*
================
Pmove

Can be called by either the server or the client
================
*/
void PmoveSingle (pmove_t *pmove)
   {
   vec3_t tempVec;
   qboolean walking;
   vec3_t temp;

	pm = pmove;

	// this counter lets us debug movement problems with a journal
	// by setting a conditional breakpoint fot the previous frame
	c_pmove++;

	// clear results
	pm->numtouch = 0;
	pm->watertype = 0;
	pm->waterlevel = 0;
	pm->landed = qfalse;

	if(pm->ps->groundPlane)
	{
		//only set this to false if we are on the ground. 
		//when jump is hit, this is set to true. This 
		//allows the code to know if the player jumped or not.
		pm->ps->jumped = qfalse;
	}

	if ( pm->ps->stats[STAT_HEALTH] <= 0 )
      {
		pm->tracemask &= ~CONTENTS_BODY;	// corpses can fly through bodies
	   }

	// adding fake talk balloons
	/* if ( pmove->cmd.buttons & BUTTON_TALK )
      {
		pmove->cmd.buttons = 0;
		pmove->cmd.forwardmove = 0;
		pmove->cmd.rightmove = 0;
		pmove->cmd.upmove = 0;
		pmove->cmd.lean = 0;
	   } */

	// clear all pmove local vars
	memset (&pml, 0, sizeof(pml));

	// determine the time
	pml.msec = pmove->cmd.serverTime - pm->ps->commandTime;
	if ( pml.msec < 1 )
      {
		pml.msec = 1;
	   }
   else if ( pml.msec > 200 )
      {
		pml.msec = 200;
	   }

	pm->ps->commandTime = pmove->cmd.serverTime;

	// save old org in case we get stuck
	VectorCopy( pm->ps->origin, pml.previous_origin );

	// save old velocity for crashlanding
	VectorCopy( pm->ps->velocity, pml.previous_velocity );
	VectorCopy( pm->ps->velocity, temp );

	pml.frametime = pml.msec * 0.001f;

	// update the viewangles
	if (!pm->ps->in_vehicle )
		{
		PM_UpdateViewAngles( pm->ps, &pm->cmd );

		AngleVectors( pm->ps->viewangles, pml.forward, pml.left, pml.up );
	   VectorClear( tempVec );
	   tempVec[ YAW ] = pm->ps->viewangles[ YAW ];
		AngleVectors( tempVec, pml.flat_forward, pml.flat_left, pml.flat_up );
		}

	if ( pm->ps->in_vehicle )
		{
		PM_VehicleMove();
		return;
		}

	if ( pm->cmd.upmove < 10 ) {
		// not holding jump
		pm->ps->pm_flags &= ~PMF_JUMP_HELD;
	}

	if ( pm->ps->pm_type == PM_DEAD )
      {
		pm->cmd.forwardmove = 0;
		pm->cmd.rightmove = 0;
		pm->cmd.upmove = 0;
		pm->cmd.lean = 0;
	   }

	if ( pm->ps->pm_type == PM_NOCLIP )
      {
		PM_NoclipMove ();
		PM_DropTimers ();
 		return;
	   }

	if ( ( pm->ps->pm_flags & PMF_FROZEN ) || ( pm->ps->pm_flags & PMF_NO_MOVE ) )
      {
		return;		// no movement at all
	   }

	PM_CheckDuck();

	PM_CheckCrouchJump();

	// set watertype, and waterlevel
	PM_SetWaterLevel();
	pml.previous_waterlevel = pmove->waterlevel;

	// set groundentity
	PM_GroundTrace( qfalse );

	if ( pm->ps->pm_type == PM_DEAD )
      {
		PM_DeadMove();
	   }

	PM_DropTimers();

	if ( pm->ps->pm_flags & PMF_FLIGHT )
		// flight powerup doesn't allow jump and has different friction
		PM_FlyMove();
   else if ( pm->ps->pm_flags & PMF_TIME_WATERJUMP )
      {
		PM_WaterJumpMove();
	   }
   else if ( pml.walking )
      {
		// walking on ground
		PM_WalkMove();
	   }
   else if ( pm->waterlevel > 1 )
      {
		// swimming
		PM_WaterMove();
	   }
   else if ( pm->ps->pm_flags & PMF_TIME_STUCKJUMP )
      {
		PM_StuckJumpMove();
	   }
   else if( pm->ps->pm_flags & PMF_TIME_CROUCH_JUMP)
   {
	   PM_CrouchJumpMove();
   }
   else
      {
		// airborne
		if ( !pm->ps->in_vehicle )
			PM_AirMove();
	   }

   walking = pml.walking;

	// set groundentity, watertype, and waterlevel
	PM_GroundTrace( qfalse );
	PM_SetWaterLevel();

   // don't fall down stairs or do really short falls
   if ( !pml.walking && ( walking || ( ( pml.previous_velocity[ 2 ] >= 0.0f ) && ( pm->ps->velocity[ 2 ] <= 0.0f ) ) ) )
      {
	   vec3_t   point;
	   trace_t  trace;

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

	   pm->trace( &trace, pm->ps->origin, pm->mins, pm->maxs, point, pm->ps->clientNum, pm->tracemask, qtrue );
      if ( ( trace.fraction < 1.0f ) && ( !trace.allsolid ) )
         {
   		VectorCopy( trace.endpos, pm->ps->origin );

         // allow client to smooth out the step
   		pm->stepped = qtrue;

         // requantify the player's position
         PM_GroundTrace( qfalse );
   	   PM_SetWaterLevel();
         }
      }

	// entering / leaving water splashes
	PM_WaterEvents();


	// test stuff
	
	// snap some parts of playerstate to save network bandwidth
	SnapVector( pm->ps->velocity );

	// If the player is off the ground cap his xy velocity so he can't strafe-jump and use other cheats
	//   to go too fast

	if ( !pm->ps->strafeJumpingAllowed && ( pm->ps->groundEntityNum != ENTITYNUM_NONE ) && ( pm->ps->groundEntityNum == ENTITYNUM_WORLD ) )
	{
		float speed;
		vec3_t xyVelocity;

		// Get xy velocity

		//jhefty/jwaters modifications

		VectorCopy( pm->ps->velocity, xyVelocity );
		//xyVelocity[ 2 ] = 0.0f;

		// See if the xy velocity is too fast

		speed = VectorLength( xyVelocity );

		if ( speed > pm->ps->speed )
		{
			// Cap the real velocity

			VectorNormalize( xyVelocity );
			VectorScale( xyVelocity, pm->ps->speed, pm->ps->velocity );


			//pm->ps->velocity[ 0 ] = xyVelocity[ 0 ];
			//pm->ps->velocity[ 1 ] = xyVelocity[ 1 ];
			
		}
	}

	if ( PM_ShouldCrashLand() )
	{
		// just hit the ground
		if ( pm->debugLevel )
		{
			Com_Printf( "%i:Land\n", c_pmove );
		}

		PM_CrashLand();
	}

   }

/*
================
Pmove

Can be called by either the server or the client
================
*/
void Pmove (pmove_t *pmove) {
	int			finalTime;

	finalTime = pmove->cmd.serverTime;

	if ( finalTime < pmove->ps->commandTime ) {
		return;	// should not happen
	}

	if ( finalTime > ( pmove->ps->commandTime + 1000 ) ) {
		pmove->ps->commandTime = finalTime - 1000;
	}

	// chop the move up if it is too long, to prevent framerate
	// dependent behavior
	while ( pmove->ps->commandTime != finalTime ) {
		int		msec;

		msec = finalTime - pmove->ps->commandTime;

		if ( msec > 50 ) {
			msec = 50;
		}
		pmove->cmd.serverTime = pmove->ps->commandTime + msec;
		PmoveSingle( pmove );
		//Com_Printf("Vel: %f\n",pm->ps->velocity[2]);
	}

}