import of Jake2 version sunrisesunrise

1 files changed, 1261 insertions, 0 deletions

diff --git a/src/jake2/qcommon/PMove.java b/src/jake2/qcommon/PMove.java
new file mode 100644
index 0000000..ed82432
--- /dev/null
+++ b/src/jake2/qcommon/PMove.java
@@ -0,0 +1,1261 @@
+/*
+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.
+
+*/
+
+// Created on 25.01.2004 by RST.
+// $Id: PMove.java,v 1.1 2004-07-07 19:59:33 hzi Exp $
+
+package jake2.qcommon;
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+import jake2.server.*;
+
+public class PMove extends Game
+{
+
+	public final static int 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
+
+	public static class pml_t
+	{
+		float[] origin = { 0, 0, 0 }; // full float precision
+		float[] velocity = { 0, 0, 0 }; // full float precision
+
+		float[] forward = { 0, 0, 0 }, right = { 0, 0, 0 }, up = { 0, 0, 0 };
+		float frametime;
+
+		csurface_t groundsurface;
+		cplane_t groundplane = new cplane_t();
+		int groundcontents;
+
+		float[] previous_origin = { 0, 0, 0 };
+		boolean ladder;
+	}
+
+	public static pmove_t pm;
+	public static pml_t pml = new pml_t();
+
+	// movement parameters
+	public static float pm_stopspeed = 100;
+	public static float pm_maxspeed = 300;
+	public static float pm_duckspeed = 100;
+	public static float pm_accelerate = 10;
+	public static float pm_airaccelerate = 0;
+	public static float pm_wateraccelerate = 10;
+	public static float pm_friction = 6;
+	public static float pm_waterfriction = 1;
+	public static 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)
+	==================
+	*/
+	public static final float STOP_EPSILON = 0.1f;
+
+	public static void PM_ClipVelocity(float[] in, float[] normal, float[] 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?
+	==================
+	*/
+	public final static float MIN_STEP_NORMAL = 0.7f; // can't step up onto very steep slopes
+
+	public static void PM_StepSlideMove_()
+	{
+		int bumpcount, numbumps;
+		float[] dir = { 0, 0, 0 };
+		float d;
+		int numplanes;
+		float[] planes[] = new float[MAX_CLIP_PLANES][3];
+		float[] primal_velocity = { 0, 0, 0 };
+		int i, j;
+		trace_t trace;
+		float[] end = { 0, 0, 0 };
+		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.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 != null)
+			{
+				if (trace.ent.index != -1) 
+					Com.p("touch: " + trace.ent.classname + " (" + trace.ent.index + ")" );
+					
+				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.01f);
+				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 != 0)
+		{
+			VectorCopy(primal_velocity, pml.velocity);
+		}
+	}
+
+	/*
+	==================
+	PM_StepSlideMove
+	
+	==================
+	*/
+	public static void PM_StepSlideMove()
+	{
+		float[] start_o = { 0, 0, 0 }, start_v = { 0, 0, 0 };
+		float[] down_o = { 0, 0, 0 }, down_v = { 0, 0, 0 };
+		trace_t trace;
+		float down_dist, up_dist;
+		//	float [] 		delta;
+		float[] up = { 0, 0, 0 }, down = { 0, 0, 0 };
+
+		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.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.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;
+		}
+		//!! 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
+	==================
+	*/
+	public static void PM_Friction()
+	{
+		float vel[];
+		float speed, newspeed, control;
+		float friction;
+		float drop;
+
+		vel = pml.velocity;
+
+		speed = (float) (Math.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 != null && pml.groundsurface != null && 0 == (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 != 0 && !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
+	==============
+	*/
+	public static void PM_Accelerate(float[] 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];
+	}
+
+	public static void PM_AirAccelerate(float[] 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
+	=============
+	*/
+	public static void PM_AddCurrents(float[] wishvel)
+	{
+		float[] v = { 0, 0, 0 };
+		float s;
+
+		//
+		// account for ladders
+		//
+
+		if (pml.ladder && Math.abs(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) != 0)
+		{
+			VectorClear(v);
+
+			if ((pm.watertype & CONTENTS_CURRENT_0) != 0)
+				v[0] += 1;
+			if ((pm.watertype & CONTENTS_CURRENT_90) != 0)
+				v[1] += 1;
+			if ((pm.watertype & CONTENTS_CURRENT_180) != 0)
+				v[0] -= 1;
+			if ((pm.watertype & CONTENTS_CURRENT_270) != 0)
+				v[1] -= 1;
+			if ((pm.watertype & CONTENTS_CURRENT_UP) != 0)
+				v[2] += 1;
+			if ((pm.watertype & CONTENTS_CURRENT_DOWN) != 0)
+				v[2] -= 1;
+
+			s = pm_waterspeed;
+			if ((pm.waterlevel == 1) && (pm.groundentity != null))
+				s /= 2;
+
+			VectorMA(wishvel, s, v, wishvel);
+		}
+
+		//
+		// add conveyor belt velocities
+		//
+
+		if (pm.groundentity != null)
+		{
+			VectorClear(v);
+
+			if ((pml.groundcontents & CONTENTS_CURRENT_0) != 0)
+				v[0] += 1;
+			if ((pml.groundcontents & CONTENTS_CURRENT_90) != 0)
+				v[1] += 1;
+			if ((pml.groundcontents & CONTENTS_CURRENT_180) != 0)
+				v[0] -= 1;
+			if ((pml.groundcontents & CONTENTS_CURRENT_270) != 0)
+				v[1] -= 1;
+			if ((pml.groundcontents & CONTENTS_CURRENT_UP) != 0)
+				v[2] += 1;
+			if ((pml.groundcontents & CONTENTS_CURRENT_DOWN) != 0)
+				v[2] -= 1;
+
+			VectorMA(wishvel, 100 /* pm.groundentity.speed */
+			, v, wishvel);
+		}
+	}
+
+	/*
+	===================
+	PM_WaterMove
+	
+	===================
+	*/
+	public static void PM_WaterMove()
+	{
+		int i;
+		float[] wishvel = { 0, 0, 0 };
+		float wishspeed;
+		float[] wishdir = { 0, 0, 0 };
+
+		//
+		// user intentions
+		//
+		for (i = 0; i < 3; i++)
+			wishvel[i] = pml.forward[i] * pm.cmd.forwardmove + pml.right[i] * pm.cmd.sidemove;
+
+		if (0 == pm.cmd.forwardmove && 0 == pm.cmd.sidemove && 0 == 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
+	
+	===================
+	*/
+	public static void PM_AirMove()
+	{
+		int i;
+		float[] wishvel = { 0, 0, 0 };
+		float fmove, smove;
+		float[] wishdir = { 0, 0, 0 };
+		float wishspeed;
+		float maxspeed;
+
+		fmove = pm.cmd.forwardmove;
+		smove = pm.cmd.sidemove;
+
+		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) != 0 ? pm_duckspeed : pm_maxspeed;
+
+		if (wishspeed > maxspeed)
+		{
+			VectorScale(wishvel, maxspeed / wishspeed, wishvel);
+			wishspeed = maxspeed;
+		}
+
+		if (pml.ladder)
+		{
+			PM_Accelerate(wishdir, wishspeed, pm_accelerate);
+			if (0 == 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 != null)
+		{ // 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 (0 == pml.velocity[0] && 0 == pml.velocity[1])
+				return;
+			PM_StepSlideMove();
+		}
+		else
+		{ // not on ground, so little effect on velocity
+			if (pm_airaccelerate != 0)
+				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
+	=============
+	*/
+	public static void PM_CatagorizePosition()
+	{
+		float[] point = { 0, 0, 0 };
+		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) //!!ZOID changed from 100 to 180 (ramp accel)
+		{
+			pm.s.pm_flags &= ~PMF_ON_GROUND;
+			pm.groundentity = null;
+		}
+		else
+		{
+			trace = pm.trace.trace(pml.origin, pm.mins, pm.maxs, point);
+			pml.groundplane = trace.plane;
+			pml.groundsurface = trace.surface;
+			pml.groundcontents = trace.contents;
+
+			if (null == 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) != 0)
+				{
+					pm.s.pm_flags &= ~(PMF_TIME_WATERJUMP | PMF_TIME_LAND | PMF_TIME_TELEPORT);
+					pm.s.pm_time = 0;
+				}
+
+				if (0 == (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 (pm.numtouch < MAXTOUCH && trace.ent != null)
+			{
+				pm.touchents[pm.numtouch] = trace.ent;
+				pm.numtouch++;
+			}
+		}
+
+		//
+		// get waterlevel, accounting for ducking
+		//
+		pm.waterlevel = 0;
+		pm.watertype = 0;
+
+		sample2 = (int) (pm.viewheight - pm.mins[2]);
+		sample1 = sample2 / 2;
+
+		point[2] = pml.origin[2] + pm.mins[2] + 1;
+		cont = pm.pointcontents.pointcontents(point);
+
+		if ((cont & MASK_WATER) != 0)
+		{
+			pm.watertype = cont;
+			pm.waterlevel = 1;
+			point[2] = pml.origin[2] + pm.mins[2] + sample1;
+			cont = pm.pointcontents.pointcontents(point);
+			if ((cont & MASK_WATER) != 0)
+			{
+				pm.waterlevel = 2;
+				point[2] = pml.origin[2] + pm.mins[2] + sample2;
+				cont = pm.pointcontents.pointcontents(point);
+				if ((cont & MASK_WATER) != 0)
+					pm.waterlevel = 3;
+			}
+		}
+
+	}
+
+	/*
+	=============
+	PM_CheckJump
+	=============
+	*/
+	public static void PM_CheckJump()
+	{
+		if ((pm.s.pm_flags & PMF_TIME_LAND) != 0)
+		{ // 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) != 0)
+			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
+	=============
+	*/
+	public static void PM_CheckSpecialMovement()
+	{
+		float[] spot = { 0, 0, 0 };
+		int cont;
+		float[] flatforward = { 0, 0, 0 };
+		trace_t trace;
+
+		if (pm.s.pm_time != 0)
+			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.trace(pml.origin, pm.mins, pm.maxs, spot);
+		if ((trace.fraction < 1) && (trace.contents & CONTENTS_LADDER) != 0)
+			pml.ladder = true;
+
+		// check for water jump
+		if (pm.waterlevel != 2)
+			return;
+
+		VectorMA(pml.origin, 30, flatforward, spot);
+		spot[2] += 4;
+		cont = pm.pointcontents.pointcontents(spot);
+		if (0 == (cont & CONTENTS_SOLID))
+			return;
+
+		spot[2] += 16;
+		cont = pm.pointcontents.pointcontents(spot);
+		if (cont != 0)
+			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 = -1; // was 255
+	}
+
+	/*
+	===============
+	PM_FlyMove
+	===============
+	*/
+	public static void PM_FlyMove(boolean doclip)
+	{
+		float speed, drop, friction, control, newspeed;
+		float currentspeed, addspeed, accelspeed;
+		int i;
+		float[] wishvel = { 0, 0, 0 };
+		float fmove, smove;
+		float[] wishdir = { 0, 0, 0 };
+		float wishspeed;
+		float[] end = { 0, 0, 0 };
+		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.5f; // 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.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
+	==============
+	*/
+	public static void PM_CheckDuck()
+	{
+		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) != 0)
+		{ // duck
+			pm.s.pm_flags |= PMF_DUCKED;
+		}
+		else
+		{ // stand up if possible
+			if ((pm.s.pm_flags & PMF_DUCKED) != 0)
+			{
+				// try to stand up
+				pm.maxs[2] = 32;
+				trace = pm.trace.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) != 0)
+		{
+			pm.maxs[2] = 4;
+			pm.viewheight = -2;
+		}
+		else
+		{
+			pm.maxs[2] = 32;
+			pm.viewheight = 22;
+		}
+	}
+
+	/*
+	==============
+	PM_DeadMove
+	==============
+	*/
+	public static void PM_DeadMove()
+	{
+		float forward;
+
+		if (null == 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);
+		}
+	}
+
+	public static boolean PM_GoodPosition()
+	{
+		trace_t trace;
+		float[] origin = { 0, 0, 0 }, end = { 0, 0, 0 };
+		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.125f;
+		trace = pm.trace.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.
+	================
+	*/
+	// try all single bits first
+	static int jitterbits[] = { 0, 4, 1, 2, 3, 5, 6, 7 };
+	public static void PM_SnapPosition()
+	{
+		int sign[] = { 0, 0, 0 };
+		int i, j, bits;
+		short base[] = { 0, 0, 0 };
+
+		// snap velocity to eigths
+		for (i = 0; i < 3; i++)
+			pm.s.velocity[i] = (short) (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] = (short) (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)) != 0)
+					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");
+	}
+
+	/*
+	================
+	PM_InitialSnapPosition
+	
+	================
+	*/
+	static int offset[] = { 0, -1, 1 };
+	public static void PM_InitialSnapPosition()
+	{
+		int x, y, z;
+		short base[] = { 0, 0, 0 };
+
+		VectorCopy(pm.s.origin, base);
+
+		for (z = 0; z < 3; z++)
+		{
+			pm.s.origin[2] = (short) (base[2] + offset[z]);
+			for (y = 0; y < 3; y++)
+			{
+				pm.s.origin[1] = (short) (base[1] + offset[y]);
+				for (x = 0; x < 3; x++)
+				{
+					pm.s.origin[0] = (short) (base[0] + offset[x]);
+					if (PM_GoodPosition())
+					{
+						pml.origin[0] = pm.s.origin[0] * 0.125f;
+						pml.origin[1] = pm.s.origin[1] * 0.125f;
+						pml.origin[2] = pm.s.origin[2] * 0.125f;
+						VectorCopy(pm.s.origin, pml.previous_origin);
+						return;
+					}
+				}
+			}
+		}
+
+		Com.DPrintf("Bad InitialSnapPosition\n");
+	}
+
+	/*
+	================
+	PM_ClampAngles
+	
+	================
+	*/
+	public static void PM_ClampAngles()
+	{
+		short temp;
+		int i;
+
+		if ((pm.s.pm_flags & PMF_TIME_TELEPORT) != 0)
+		{
+			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 = (short) (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
+	================
+	*/
+	public static void Pmove(pmove_t pmove)
+	{
+		pm = pmove;
+
+		// 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));
+		pml = new pml_t();
+
+		// convert origin and velocity to float values
+		pml.origin[0] = pm.s.origin[0] * 0.125f;
+		pml.origin[1] = pm.s.origin[1] * 0.125f;
+		pml.origin[2] = pm.s.origin[2] * 0.125f;
+
+		pml.velocity[0] = pm.s.velocity[0] * 0.125f;
+		pml.velocity[1] = pm.s.velocity[1] * 0.125f;
+		pml.velocity[2] = pm.s.velocity[2] * 0.125f;
+
+		// save old org in case we get stuck
+		VectorCopy(pm.s.origin, pml.previous_origin);
+
+		pml.frametime = (pm.cmd.msec & 0xFF) * 0.001f;
+
+		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 != 0)
+		{
+			int msec;
+
+			// TOD o bugfix cwei
+			msec = pm.cmd.msec >>> 3;
+			if (msec == 0)
+				msec = 1;
+			if (msec >= (pm.s.pm_time & 0xFF))
+			{
+				pm.s.pm_flags &= ~(PMF_TIME_WATERJUMP | PMF_TIME_LAND | PMF_TIME_TELEPORT);
+				pm.s.pm_time = 0;
+			}
+			else
+				pm.s.pm_time = (byte)((pm.s.pm_time & 0xFF) - msec);
+		}
+
+		if ((pm.s.pm_flags & PMF_TIME_TELEPORT) != 0)
+		{ // teleport pause stays exactly in place
+		}
+		else if ((pm.s.pm_flags & PMF_TIME_WATERJUMP) != 0)
+		{ // 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
+			{
+				float[] angles={0,0,0};
+
+				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();
+	}
+
+}