X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=cl_input.c;h=d9a061658a912dcaf0b75a6298391d5f7ffd9d50;hp=cff67be27fa6e2e5e3e0c81ee7c4f2dbcd12b907;hb=544356c7bb6288760533142b8ab402f4d8d966ef;hpb=aa150f38ef79b17d32b520bebb5fe5125c7b3ced

diff --git a/cl_input.c b/cl_input.c
index cff67be2..d9a06165 100644
--- a/cl_input.c
+++ b/cl_input.c
@@ -495,8 +495,8 @@ void CL_UpdatePrydonCursor(void)
 	cl.cmd.cursor_screen[1] = bound(-1, cl.cmd.cursor_screen[1], 1);
 	cl.cmd.cursor_screen[2] = 1;
 
-	scale[0] = -r_refdef.frustum_x;
-	scale[1] = -r_refdef.frustum_y;
+	scale[0] = -r_view.frustum_x;
+	scale[1] = -r_view.frustum_y;
 	scale[2] = 1;
 
 	// trace distance
@@ -505,9 +505,9 @@ void CL_UpdatePrydonCursor(void)
 	// calculate current view matrix
 	V_CalcRefdef();
 	VectorClear(temp);
-	Matrix4x4_Transform(&r_refdef.viewentitymatrix, temp, cl.cmd.cursor_start);
+	Matrix4x4_Transform(&r_view.matrix, temp, cl.cmd.cursor_start);
 	VectorSet(temp, cl.cmd.cursor_screen[2] * scale[2], cl.cmd.cursor_screen[0] * scale[0], cl.cmd.cursor_screen[1] * scale[1]);
-	Matrix4x4_Transform(&r_refdef.viewentitymatrix, temp, cl.cmd.cursor_end);
+	Matrix4x4_Transform(&r_view.matrix, temp, cl.cmd.cursor_end);
 	// trace from view origin to the cursor
 	cl.cmd.cursor_fraction = CL_SelectTraceLine(cl.cmd.cursor_start, cl.cmd.cursor_end, cl.cmd.cursor_impact, cl.cmd.cursor_normal, &cl.cmd.cursor_entitynumber, (chase_active.integer || cl.intermission) ? &cl.entities[cl.playerentity].render : NULL, false);
 }
@@ -519,26 +519,23 @@ void CL_ClientMovement_InputQW(qw_usercmd_t *cmd)
 	// remove stale queue items
 	n = cl.movement_numqueue;
 	cl.movement_numqueue = 0;
-	if (cl.movement)
+	for (i = 0;i < n;i++)
+		if (cl.movement_queue[i].sequence > cls.netcon->qw.incoming_sequence)
+			cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
+	// add to input queue if there is room
+	if (cl.movement_numqueue < (int)(sizeof(cl.movement_queue)/sizeof(cl.movement_queue[0])))
 	{
-		for (i = 0;i < n;i++)
-			if (cl.movement_queue[i].sequence > cls.netcon->qw.incoming_sequence)
-				cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
-		// add to input queue if there is room
-		if (cl.movement_numqueue < (int)(sizeof(cl.movement_queue)/sizeof(cl.movement_queue[0])) && cl.mtime[0] > cl.mtime[1])
-		{
-			// add to input queue
-			cl.movement_queue[cl.movement_numqueue].sequence = cls.netcon->qw.outgoing_sequence;
-			cl.movement_queue[cl.movement_numqueue].time = cl.mtime[0] + cl_movement_latency.value / 1000.0;
-			cl.movement_queue[cl.movement_numqueue].frametime = cmd->msec * 0.001;
-			VectorCopy(cmd->angles, cl.movement_queue[cl.movement_numqueue].viewangles);
-			cl.movement_queue[cl.movement_numqueue].move[0] = cmd->forwardmove;
-			cl.movement_queue[cl.movement_numqueue].move[1] = cmd->sidemove;
-			cl.movement_queue[cl.movement_numqueue].move[2] = cmd->upmove;
-			cl.movement_queue[cl.movement_numqueue].jump = (cmd->buttons & 2) != 0;
-			cl.movement_queue[cl.movement_numqueue].crouch = false;
-			cl.movement_numqueue++;
-		}
+		// add to input queue
+		cl.movement_queue[cl.movement_numqueue].sequence = cls.netcon->qw.outgoing_sequence;
+		cl.movement_queue[cl.movement_numqueue].time = realtime;
+		cl.movement_queue[cl.movement_numqueue].frametime = cmd->msec / 1000.0;
+		VectorCopy(cmd->angles, cl.movement_queue[cl.movement_numqueue].viewangles);
+		cl.movement_queue[cl.movement_numqueue].move[0] = cmd->forwardmove;
+		cl.movement_queue[cl.movement_numqueue].move[1] = cmd->sidemove;
+		cl.movement_queue[cl.movement_numqueue].move[2] = cmd->upmove;
+		cl.movement_queue[cl.movement_numqueue].jump = (cmd->buttons & 2) != 0;
+		cl.movement_queue[cl.movement_numqueue].crouch = false;
+		cl.movement_numqueue++;
 	}
 	cl.movement_replay = true;
 }
@@ -547,51 +544,72 @@ void CL_ClientMovement_Input(qboolean buttonjump, qboolean buttoncrouch)
 {
 	int i;
 	int n;
+	double lasttime = cl.movement_numqueue >= 0 ? cl.movement_queue[cl.movement_numqueue - 1].time : 0;
 	// remove stale queue items
 	n = cl.movement_numqueue;
 	cl.movement_numqueue = 0;
-	if (cl.movement)
+	if (cl.servermovesequence)
 	{
-		if (cl.servermovesequence)
-		{
-			for (i = 0;i < n;i++)
-				if (cl.movement_queue[i].sequence > cl.servermovesequence)
-					cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
-		}
-		else
-		{
-			double simulatedtime = cl.mtime[0] + cl_movement_latency.value / 1000.0;
-			for (i = 0;i < n;i++)
-				if (cl.movement_queue[i].time >= cl.mtime[0] && cl.movement_queue[i].time <= simulatedtime)
-					cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
-		}
-		// add to input queue if there is room
-		if (cl.movement_numqueue < (int)(sizeof(cl.movement_queue)/sizeof(cl.movement_queue[0])) && cl.mtime[0] > cl.mtime[1])
-		{
-			// add to input queue
-			cl.movement_queue[cl.movement_numqueue].sequence = cl.movesequence;
-			cl.movement_queue[cl.movement_numqueue].time = cl.mtime[0] + cl_movement_latency.value / 1000.0;
-			cl.movement_queue[cl.movement_numqueue].frametime = cl.mtime[0] - cl.mtime[1];
-			VectorCopy(cl.viewangles, cl.movement_queue[cl.movement_numqueue].viewangles);
-			cl.movement_queue[cl.movement_numqueue].move[0] = cl.cmd.forwardmove;
-			cl.movement_queue[cl.movement_numqueue].move[1] = cl.cmd.sidemove;
-			cl.movement_queue[cl.movement_numqueue].move[2] = cl.cmd.upmove;
-			cl.movement_queue[cl.movement_numqueue].jump = buttonjump;
-			cl.movement_queue[cl.movement_numqueue].crouch = buttoncrouch;
-			cl.movement_numqueue++;
-		}
+		for (i = 0;i < n;i++)
+			if (cl.movement_queue[i].sequence > cl.servermovesequence)
+				cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
+	}
+	else
+	{
+		for (i = 0;i < n;i++)
+			if (cl.movement_queue[i].time >= cl.mtime[0] - cl_movement_latency.value / 1000.0 && cl.movement_queue[i].time <= cl.mtime[0])
+				cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
+	}
+	// add to input queue if there is room
+	if (cl.movement_numqueue < (int)(sizeof(cl.movement_queue)/sizeof(cl.movement_queue[0])) && cl.mtime[0] > cl.mtime[1])
+	{
+		// add to input queue
+		cl.movement_queue[cl.movement_numqueue].sequence = cl.movesequence;
+		cl.movement_queue[cl.movement_numqueue].time = cl.mtime[0];
+		cl.movement_queue[cl.movement_numqueue].frametime = bound(0, cl.mtime[0] - lasttime, 0.1);
+		VectorCopy(cl.viewangles, cl.movement_queue[cl.movement_numqueue].viewangles);
+		cl.movement_queue[cl.movement_numqueue].move[0] = cl.cmd.forwardmove;
+		cl.movement_queue[cl.movement_numqueue].move[1] = cl.cmd.sidemove;
+		cl.movement_queue[cl.movement_numqueue].move[2] = cl.cmd.upmove;
+		cl.movement_queue[cl.movement_numqueue].jump = buttonjump;
+		cl.movement_queue[cl.movement_numqueue].crouch = buttoncrouch;
+		cl.movement_numqueue++;
 	}
 	cl.movement_replay = true;
 }
 
-void CL_ClientMovement_Replay(void)
+typedef enum waterlevel_e
 {
-	int i;
-	int bump;
-	int contents;
-	int crouch;
-	int onground;
-	int canjump;
+	WATERLEVEL_NONE,
+	WATERLEVEL_WETFEET,
+	WATERLEVEL_SWIMMING,
+	WATERLEVEL_SUBMERGED
+}
+waterlevel_t;
+
+typedef struct cl_clientmovement_state_s
+{
+	// position
+	vec3_t origin;
+	vec3_t velocity;
+	// current bounding box (different if crouched vs standing)
+	vec3_t mins;
+	vec3_t maxs;
+	// currently on the ground
+	qboolean onground;
+	// currently crouching
+	qboolean crouched;
+	// whether jump button has been released since last jump
+	qboolean canjump;
+	// what kind of water (SUPERCONTENTS_LAVA for instance)
+	int watertype;
+	// how deep
+	waterlevel_t waterlevel;
+	// weird hacks when jumping out of water
+	// (this is in seconds and counts down to 0)
+	float waterjumptime;
+
+	// movement parameters for physics code
 	float movevars_gravity;
 	float movevars_stopspeed;
 	float movevars_maxspeed;
@@ -606,87 +624,441 @@ void CL_ClientMovement_Replay(void)
 	float movevars_edgefriction;
 	float movevars_maxairspeed;
 	float movevars_stepheight;
-	double edgefriction;
-	double frametime;
+
+	// user command
+	client_movementqueue_t q;
+}
+cl_clientmovement_state_t;
+
+#define NUMOFFSETS 27
+static vec3_t offsets[NUMOFFSETS] =
+{
+// 1 no nudge (just return the original if this test passes)
+	{ 0.000,  0.000,  0.000},
+// 6 simple nudges
+	{ 0.000,  0.000,  0.125}, { 0.000,  0.000, -0.125},
+	{-0.125,  0.000,  0.000}, { 0.125,  0.000,  0.000},
+	{ 0.000, -0.125,  0.000}, { 0.000,  0.125,  0.000},
+// 4 diagonal flat nudges
+	{-0.125, -0.125,  0.000}, { 0.125, -0.125,  0.000},
+	{-0.125,  0.125,  0.000}, { 0.125,  0.125,  0.000},
+// 8 diagonal upward nudges
+	{-0.125,  0.000,  0.125}, { 0.125,  0.000,  0.125},
+	{ 0.000, -0.125,  0.125}, { 0.000,  0.125,  0.125},
+	{-0.125, -0.125,  0.125}, { 0.125, -0.125,  0.125},
+	{-0.125,  0.125,  0.125}, { 0.125,  0.125,  0.125},
+// 8 diagonal downward nudges
+	{-0.125,  0.000, -0.125}, { 0.125,  0.000, -0.125},
+	{ 0.000, -0.125, -0.125}, { 0.000,  0.125, -0.125},
+	{-0.125, -0.125, -0.125}, { 0.125, -0.125, -0.125},
+	{-0.125,  0.125, -0.125}, { 0.125,  0.125, -0.125},
+};
+
+qboolean CL_ClientMovement_Unstick(cl_clientmovement_state_t *s)
+{
+	int i;
+	vec3_t neworigin;
+	for (i = 0;i < NUMOFFSETS;i++)
+	{
+		VectorAdd(offsets[i], s->origin, neworigin);
+		if (!CL_TraceBox(neworigin, cl.playercrouchmins, cl.playercrouchmaxs, neworigin, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true).startsolid)
+		{
+			VectorCopy(neworigin, s->origin);
+			return true;
+		}
+	}
+	// if all offsets failed, give up
+	return false;
+}
+
+void CL_ClientMovement_UpdateStatus(cl_clientmovement_state_t *s)
+{
+	vec3_t origin1, origin2;
+	trace_t trace;
+
+	// make sure player is not stuck
+	CL_ClientMovement_Unstick(s);
+
+	// set crouched
+	if (s->q.crouch)
+	{
+		// wants to crouch, this always works..
+		if (!s->crouched)
+			s->crouched = true;
+	}
+	else
+	{
+		// wants to stand, if currently crouching we need to check for a
+		// low ceiling first
+		if (s->crouched)
+		{
+			trace = CL_TraceBox(s->origin, cl.playerstandmins, cl.playerstandmaxs, s->origin, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
+			if (!trace.startsolid)
+				s->crouched = false;
+		}
+	}
+	if (s->crouched)
+	{
+		VectorCopy(cl.playercrouchmins, s->mins);
+		VectorCopy(cl.playercrouchmaxs, s->maxs);
+	}
+	else
+	{
+		VectorCopy(cl.playerstandmins, s->mins);
+		VectorCopy(cl.playerstandmaxs, s->maxs);
+	}
+
+	// set onground
+	VectorSet(origin1, s->origin[0], s->origin[1], s->origin[2] + 1);
+	VectorSet(origin2, s->origin[0], s->origin[1], s->origin[2] - 2);
+	trace = CL_TraceBox(origin1, s->mins, s->maxs, origin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
+	s->onground = trace.fraction < 1 && trace.plane.normal[2] > 0.7;
+
+	// set watertype/waterlevel
+	VectorSet(origin1, s->origin[0], s->origin[1], s->origin[2] + s->mins[2] + 1);
+	s->waterlevel = WATERLEVEL_NONE;
+	s->watertype = CL_TraceBox(origin1, vec3_origin, vec3_origin, origin1, true, NULL, 0, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK;
+	if (s->watertype)
+	{
+		s->waterlevel = WATERLEVEL_WETFEET;
+		origin1[2] = s->origin[2] + (s->mins[2] + s->maxs[2]) * 0.5f;
+		if (CL_TraceBox(origin1, vec3_origin, vec3_origin, origin1, true, NULL, 0, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK)
+		{
+			s->waterlevel = WATERLEVEL_SWIMMING;
+			origin1[2] = s->origin[2] + 22;
+			if (CL_TraceBox(origin1, vec3_origin, vec3_origin, origin1, true, NULL, 0, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK)
+				s->waterlevel = WATERLEVEL_SUBMERGED;
+		}
+	}
+
+	// water jump prediction
+	if (s->onground || s->velocity[2] <= 0 || s->waterjumptime <= 0)
+		s->waterjumptime = 0;
+}
+
+void CL_ClientMovement_Move(cl_clientmovement_state_t *s)
+{
+	int bump;
 	double t;
+	vec_t f;
+	vec3_t neworigin;
+	vec3_t currentorigin2;
+	vec3_t neworigin2;
+	vec3_t primalvelocity;
+	trace_t trace;
+	trace_t trace2;
+	trace_t trace3;
+	CL_ClientMovement_UpdateStatus(s);
+	VectorCopy(s->velocity, primalvelocity);
+	for (bump = 0, t = s->q.frametime;bump < 8 && VectorLength2(s->velocity) > 0;bump++)
+	{
+		VectorMA(s->origin, t, s->velocity, neworigin);
+		trace = CL_TraceBox(s->origin, s->mins, s->maxs, neworigin, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
+		if (trace.fraction < 1 && trace.plane.normal[2] == 0)
+		{
+			// may be a step or wall, try stepping up
+			// first move forward at a higher level
+			VectorSet(currentorigin2, s->origin[0], s->origin[1], s->origin[2] + s->movevars_stepheight);
+			VectorSet(neworigin2, neworigin[0], neworigin[1], s->origin[2] + s->movevars_stepheight);
+			trace2 = CL_TraceBox(currentorigin2, s->mins, s->maxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
+			if (!trace2.startsolid)
+			{
+				// then move down from there
+				VectorCopy(trace2.endpos, currentorigin2);
+				VectorSet(neworigin2, trace2.endpos[0], trace2.endpos[1], s->origin[2]);
+				trace3 = CL_TraceBox(currentorigin2, s->mins, s->maxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
+				//Con_Printf("%f %f %f %f : %f %f %f %f : %f %f %f %f\n", trace.fraction, trace.endpos[0], trace.endpos[1], trace.endpos[2], trace2.fraction, trace2.endpos[0], trace2.endpos[1], trace2.endpos[2], trace3.fraction, trace3.endpos[0], trace3.endpos[1], trace3.endpos[2]);
+				// accept the new trace if it made some progress
+				if (fabs(trace3.endpos[0] - trace.endpos[0]) >= 0.03125 || fabs(trace3.endpos[1] - trace.endpos[1]) >= 0.03125)
+				{
+					trace = trace2;
+					VectorCopy(trace3.endpos, trace.endpos);
+				}
+			}
+		}
+
+		// check if it moved at all
+		if (trace.fraction >= 0.001)
+			VectorCopy(trace.endpos, s->origin);
+
+		// check if it moved all the way
+		if (trace.fraction == 1)
+			break;
+
+		//if (trace.plane.normal[2] > 0.7)
+		//	s->onground = true;
+
+		t -= t * trace.fraction;
+
+		f = DotProduct(s->velocity, trace.plane.normal);
+		VectorMA(s->velocity, -f, trace.plane.normal, s->velocity);
+	}
+	if (s->waterjumptime > 0)
+		VectorCopy(primalvelocity, s->velocity);
+}
+
+
+void CL_ClientMovement_Physics_Swim(cl_clientmovement_state_t *s)
+{
+	vec_t wishspeed;
+	vec_t f;
+	vec3_t wishvel;
+	vec3_t wishdir;
+
+	// water jump only in certain situations
+	// this mimics quakeworld code
+	if (s->q.jump && s->waterlevel == 2 && s->velocity[2] >= -180)
+	{
+		vec3_t forward;
+		vec3_t yawangles;
+		vec3_t spot;
+		VectorSet(yawangles, 0, s->q.viewangles[1], 0);
+		AngleVectors(yawangles, forward, NULL, NULL);
+		VectorMA(s->origin, 24, forward, spot);
+		spot[2] += 8;
+		if (CL_TraceBox(spot, vec3_origin, vec3_origin, spot, true, NULL, 0, false).startsolid)
+		{
+			spot[2] += 24;
+			if (!CL_TraceBox(spot, vec3_origin, vec3_origin, spot, true, NULL, 0, false).startsolid)
+			{
+				VectorScale(forward, 50, s->velocity);
+				s->velocity[2] = 310;
+				s->waterjumptime = 2;
+				s->onground = false;
+				s->canjump = false;
+			}
+		}
+	}
+
+	if (!VectorLength2(s->q.move))
+	{
+		// drift towards bottom
+		VectorSet(wishvel, 0, 0, -60);
+	}
+	else
+	{
+		// swim
+		vec3_t forward;
+		vec3_t right;
+		vec3_t up;
+		// calculate movement vector
+		AngleVectors(s->q.viewangles, forward, right, up);
+		VectorSet(up, 0, 0, 1);
+		VectorMAMAM(s->q.move[0], forward, s->q.move[1], right, s->q.move[2], up, wishvel);
+	}
+
+	// split wishvel into wishspeed and wishdir
+	wishspeed = VectorLength(wishvel);
+	if (wishspeed)
+		VectorScale(wishvel, 1 / wishspeed, wishdir);
+	else
+		VectorSet( wishdir, 0.0, 0.0, 0.0 );
+	wishspeed = min(wishspeed, s->movevars_maxspeed) * 0.7;
+
+	if (s->crouched)
+		wishspeed *= 0.5;
+
+	if (s->waterjumptime <= 0)
+	{
+		// water friction
+		f = 1 - s->q.frametime * s->movevars_waterfriction * s->waterlevel;
+		f = bound(0, f, 1);
+		VectorScale(s->velocity, f, s->velocity);
+
+		// water acceleration
+		f = wishspeed - DotProduct(s->velocity, wishdir);
+		if (f > 0)
+		{
+			f = min(s->movevars_wateraccelerate * s->q.frametime * wishspeed, f);
+			VectorMA(s->velocity, f, wishdir, s->velocity);
+		}
+
+		// holding jump button swims upward slowly
+		if (s->q.jump)
+		{
+			if (s->watertype & SUPERCONTENTS_LAVA)
+				s->velocity[2] =  50;
+			else if (s->watertype & SUPERCONTENTS_SLIME)
+				s->velocity[2] =  80;
+			else
+			{
+				if (gamemode == GAME_NEXUIZ)
+					s->velocity[2] = 200;
+				else
+					s->velocity[2] = 100;
+			}
+		}
+	}
+
+	CL_ClientMovement_Move(s);
+}
+
+void CL_ClientMovement_Physics_Walk(cl_clientmovement_state_t *s)
+{
+	vec_t friction;
 	vec_t wishspeed;
 	vec_t addspeed;
 	vec_t accelspeed;
 	vec_t f;
-	vec_t *playermins;
-	vec_t *playermaxs;
-	vec3_t currentorigin;
-	vec3_t currentvelocity;
 	vec3_t forward;
 	vec3_t right;
 	vec3_t up;
 	vec3_t wishvel;
 	vec3_t wishdir;
-	vec3_t neworigin;
-	vec3_t currentorigin2;
-	vec3_t neworigin2;
 	vec3_t yawangles;
 	trace_t trace;
-	trace_t trace2;
-	trace_t trace3;
 
+	// jump if on ground with jump button pressed but only if it has been
+	// released at least once since the last jump
+	if (s->q.jump && s->canjump && s->onground)
+	{
+		s->velocity[2] += s->movevars_jumpvelocity;
+		s->onground = false;
+		s->canjump = false;
+	}
+
+	// calculate movement vector
+	VectorSet(yawangles, 0, s->q.viewangles[1], 0);
+	AngleVectors(yawangles, forward, right, up);
+	VectorMAM(s->q.move[0], forward, s->q.move[1], right, wishvel);
+
+	// split wishvel into wishspeed and wishdir
+	wishspeed = VectorLength(wishvel);
+	if (wishspeed)
+		VectorScale(wishvel, 1 / wishspeed, wishdir);
+	else
+		VectorSet( wishdir, 0.0, 0.0, 0.0 );
+	wishspeed = min(wishspeed, s->movevars_maxspeed);
+	if (s->crouched)
+		wishspeed *= 0.5;
+
+	// check if onground
+	if (s->onground)
+	{
+		// apply edge friction
+		f = sqrt(s->velocity[0] * s->velocity[0] + s->velocity[1] * s->velocity[1]);
+		friction = s->movevars_friction;
+		if (f > 0 && s->movevars_edgefriction != 1)
+		{
+			vec3_t neworigin2;
+			vec3_t neworigin3;
+			// note: QW uses the full player box for the trace, and yet still
+			// uses s->origin[2] + s->mins[2], which is clearly an bug, but
+			// this mimics it for compatibility
+			VectorSet(neworigin2, s->origin[0] + s->velocity[0]*(16/f), s->origin[1] + s->velocity[1]*(16/f), s->origin[2] + s->mins[2]);
+			VectorSet(neworigin3, neworigin2[0], neworigin2[1], neworigin2[2] - 34);
+			if (cls.protocol == PROTOCOL_QUAKEWORLD)
+				trace = CL_TraceBox(neworigin2, s->mins, s->maxs, neworigin3, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
+			else
+				trace = CL_TraceBox(neworigin2, vec3_origin, vec3_origin, neworigin3, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
+			if (trace.fraction == 1 && !trace.startsolid)
+				friction *= s->movevars_edgefriction;
+		}
+		// apply ground friction
+		f = 1 - s->q.frametime * friction * ((f < s->movevars_stopspeed) ? (s->movevars_stopspeed / f) : 1);
+		f = max(f, 0);
+		VectorScale(s->velocity, f, s->velocity);
+		addspeed = wishspeed - DotProduct(s->velocity, wishdir);
+		if (addspeed > 0)
+		{
+			accelspeed = min(s->movevars_accelerate * s->q.frametime * wishspeed, addspeed);
+			VectorMA(s->velocity, accelspeed, wishdir, s->velocity);
+		}
+		s->velocity[2] -= cl_gravity.value * s->q.frametime;
+		if (cls.protocol == PROTOCOL_QUAKEWORLD)
+			s->velocity[2] = 0;
+		if (VectorLength2(s->velocity))
+			CL_ClientMovement_Move(s);
+	}
+	else
+	{
+		if (s->waterjumptime <= 0)
+		{
+			// apply air speed limit
+			wishspeed = min(wishspeed, s->movevars_maxairspeed);
+			// Nexuiz has no upper bound on air acceleration, but little control
+			if (gamemode == GAME_NEXUIZ)
+				addspeed = wishspeed;
+			else
+				addspeed = wishspeed - DotProduct(s->velocity, wishdir);
+			if (addspeed > 0)
+			{
+				accelspeed = min(s->movevars_accelerate * s->q.frametime * wishspeed, addspeed);
+				VectorMA(s->velocity, accelspeed, wishdir, s->velocity);
+			}
+		}
+		s->velocity[2] -= cl_gravity.value * s->q.frametime;
+		CL_ClientMovement_Move(s);
+	}
+}
+
+void CL_ClientMovement_PlayerMove(cl_clientmovement_state_t *s)
+{
+	//Con_Printf(" %f", frametime);
+	if (!s->q.jump)
+		s->canjump = true;
+	s->waterjumptime -= s->q.frametime;
+	CL_ClientMovement_UpdateStatus(s);
+	if (s->waterlevel >= WATERLEVEL_SWIMMING)
+		CL_ClientMovement_Physics_Swim(s);
+	else
+		CL_ClientMovement_Physics_Walk(s);
+}
+
+void CL_ClientMovement_Replay(void)
+{
+	int i;
+	cl_clientmovement_state_t s;
 
 	if (!cl.movement_replay)
 		return;
 	cl.movement_replay = false;
 
+	// set up starting state for the series of moves
+	memset(&s, 0, sizeof(s));
+	VectorCopy(cl.entities[cl.playerentity].state_current.origin, s.origin);
+	VectorCopy(cl.mvelocity[0], s.velocity);
+	s.crouched = true; // will be updated on first move
+	s.canjump = true;
+
+	// set up movement variables
 	if (cls.protocol == PROTOCOL_QUAKEWORLD)
 	{
-		movevars_gravity = cl.qw_movevars_gravity;
-		movevars_stopspeed = cl.qw_movevars_stopspeed;
-		movevars_maxspeed = cl.qw_movevars_maxspeed;
-		movevars_spectatormaxspeed = cl.qw_movevars_spectatormaxspeed;
-		movevars_accelerate = cl.qw_movevars_accelerate;
-		movevars_airaccelerate = cl.qw_movevars_airaccelerate;
-		movevars_wateraccelerate = cl.qw_movevars_wateraccelerate;
-		movevars_friction = cl.qw_movevars_friction;
-		movevars_waterfriction = cl.qw_movevars_waterfriction;
-		movevars_entgravity = cl.qw_movevars_entgravity;
-		movevars_jumpvelocity = cl_movement_jumpvelocity.value;
-		movevars_edgefriction = cl_movement_edgefriction.value;
-		movevars_maxairspeed = cl_movement_maxairspeed.value;
-		movevars_stepheight = cl_movement_stepheight.value;
+		s.movevars_gravity = cl.qw_movevars_gravity;
+		s.movevars_stopspeed = cl.qw_movevars_stopspeed;
+		s.movevars_maxspeed = cl.qw_movevars_maxspeed;
+		s.movevars_spectatormaxspeed = cl.qw_movevars_spectatormaxspeed;
+		s.movevars_accelerate = cl.qw_movevars_accelerate;
+		s.movevars_airaccelerate = cl.qw_movevars_airaccelerate;
+		s.movevars_wateraccelerate = cl.qw_movevars_wateraccelerate;
+		s.movevars_friction = cl.qw_movevars_friction;
+		s.movevars_waterfriction = cl.qw_movevars_waterfriction;
+		s.movevars_entgravity = cl.qw_movevars_entgravity;
+		s.movevars_jumpvelocity = cl_movement_jumpvelocity.value;
+		s.movevars_edgefriction = cl_movement_edgefriction.value;
+		s.movevars_maxairspeed = cl_movement_maxairspeed.value;
+		s.movevars_stepheight = cl_movement_stepheight.value;
 	}
 	else
 	{
-		movevars_gravity = sv_gravity.value;
-		movevars_stopspeed = cl_movement_stopspeed.value;
-		movevars_maxspeed = cl_movement_maxspeed.value;
-		movevars_spectatormaxspeed = cl_movement_maxspeed.value;
-		movevars_accelerate = cl_movement_accelerate.value;
-		movevars_airaccelerate = cl_movement_accelerate.value;
-		movevars_wateraccelerate = cl_movement_accelerate.value;
-		movevars_friction = cl_movement_friction.value;
-		movevars_waterfriction = cl_movement_friction.value;
-		movevars_entgravity = 1;
-		movevars_jumpvelocity = cl_movement_jumpvelocity.value;
-		movevars_edgefriction = cl_movement_edgefriction.value;
-		movevars_maxairspeed = cl_movement_maxairspeed.value;
-		movevars_stepheight = cl_movement_stepheight.value;
+		s.movevars_gravity = sv_gravity.value;
+		s.movevars_stopspeed = cl_movement_stopspeed.value;
+		s.movevars_maxspeed = cl_movement_maxspeed.value;
+		s.movevars_spectatormaxspeed = cl_movement_maxspeed.value;
+		s.movevars_accelerate = cl_movement_accelerate.value;
+		s.movevars_airaccelerate = cl_movement_accelerate.value;
+		s.movevars_wateraccelerate = cl_movement_accelerate.value;
+		s.movevars_friction = cl_movement_friction.value;
+		s.movevars_waterfriction = cl_movement_friction.value;
+		s.movevars_entgravity = 1;
+		s.movevars_jumpvelocity = cl_movement_jumpvelocity.value;
+		s.movevars_edgefriction = cl_movement_edgefriction.value;
+		s.movevars_maxairspeed = cl_movement_maxairspeed.value;
+		s.movevars_stepheight = cl_movement_stepheight.value;
 	}
 
-	// fetch current starting values
-	VectorCopy(cl.entities[cl.playerentity].state_current.origin, currentorigin);
-	VectorCopy(cl.mvelocity[0], currentvelocity);
-	// FIXME: try minor nudges in various directions if startsolid to find a
-	// safe place to start the walk (due to network compression in some
-	// protocols this starts in solid)
-	//currentorigin[2] += (1.0 / 32.0); // slight nudge to get out of the floor
-
-	// check if onground
-	VectorSet(currentorigin2, currentorigin[0], currentorigin[1], currentorigin[2] + 1);
-	VectorSet(neworigin2, currentorigin[0], currentorigin[1], currentorigin[2] - 1);
 	if (cl.movement)
 	{
-		trace = CL_TraceBox(currentorigin2, cl.playercrouchmins, cl.playercrouchmaxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
-		onground = trace.fraction < 1 && trace.plane.normal[2] > 0.7;
-		crouch = false; // this will be updated on first move
-		canjump = true;
 		//Con_Printf("%f: ", cl.mtime[0]);
 
 		// replay the input queue to predict current location
@@ -694,195 +1066,30 @@ void CL_ClientMovement_Replay(void)
 
 		for (i = 0;i < cl.movement_numqueue;i++)
 		{
-			client_movementqueue_t *q = cl.movement_queue + bound(0, i, cl.movement_numqueue - 1);
-			frametime = q->frametime;
-			//Con_Printf(" %f", frametime);
-			//if (frametime > 0)
-			{
-				if (q->crouch)
-				{
-					// wants to crouch, this always works...
-					if (!crouch)
-						crouch = true;
-				}
-				else
-				{
-					// wants to stand, if currently crouching we need to check for a
-					// low ceiling first
-					if (crouch)
-					{
-						trace = CL_TraceBox(currentorigin, cl.playerstandmins, cl.playerstandmaxs, currentorigin, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
-						if (!trace.startsolid)
-							crouch = false;
-					}
-				}
-				if (crouch)
-				{
-					playermins = cl.playercrouchmins;
-					playermaxs = cl.playercrouchmaxs;
-				}
-				else
-				{
-					playermins = cl.playerstandmins;
-					playermaxs = cl.playerstandmaxs;
-				}
-				// change velocity according to q->viewangles and q->move
-				contents = CL_PointSuperContents(currentorigin);
-				if (contents & SUPERCONTENTS_LIQUIDSMASK)
-				{
-					// swim
-					AngleVectors(q->viewangles, forward, right, up);
-					VectorSet(up, 0, 0, 1);
-					VectorMAMAM(q->move[0], forward, q->move[1], right, q->move[2], up, wishvel);
-					wishspeed = VectorLength(wishvel);
-					if (wishspeed)
-						VectorScale(wishvel, 1 / wishspeed, wishdir);
-					else
-						VectorSet( wishdir, 0.0, 0.0, 0.0 );
-					wishspeed = min(wishspeed, movevars_maxspeed) * 0.6;
-					if (crouch)
-						wishspeed *= 0.5;
-					VectorScale(currentvelocity, (1 - frametime * movevars_waterfriction), currentvelocity);
-					f = wishspeed - DotProduct(currentvelocity, wishdir);
-					if (f > 0)
-					{
-						f = min(f, movevars_wateraccelerate * frametime * wishspeed);
-						VectorMA(currentvelocity, f, wishdir, currentvelocity);
-					}
-					if (q->jump)
-					{
-						if (contents & SUPERCONTENTS_LAVA)
-							currentvelocity[2] =  50;
-						else if (contents & SUPERCONTENTS_SLIME)
-							currentvelocity[2] =  80;
-						else
-						{
-							if (gamemode == GAME_NEXUIZ)
-								currentvelocity[2] = 200;
-							else
-								currentvelocity[2] = 100;
-						}
-					}
-				}
-				else
-				{
-					// walk
-					if (onground && q->jump && canjump)
-					{
-						currentvelocity[2] += movevars_jumpvelocity;
-						onground = false;
-						canjump = false;
-					}
-					if (!q->jump)
-						canjump = true;
-					VectorSet(yawangles, 0, q->viewangles[1], 0);
-					AngleVectors(yawangles, forward, right, up);
-					VectorMAM(q->move[0], forward, q->move[1], right, wishvel);
-					wishspeed = VectorLength(wishvel);
-					if (wishspeed)
-						VectorScale(wishvel, 1 / wishspeed, wishdir);
-					else
-						VectorSet( wishdir, 0.0, 0.0, 0.0 );
-					wishspeed = min(wishspeed, movevars_maxspeed);
-					if (crouch)
-						wishspeed *= 0.5;
-					// check if onground
-					if (onground)
-					{
-						// apply ground friction
-						f = sqrt(currentvelocity[0] * currentvelocity[0] + currentvelocity[1] * currentvelocity[1]);
-						edgefriction = 1;
-						if (f > 0)
-						{
-							VectorSet(currentorigin2, currentorigin[0] + currentvelocity[0]*(16/f), currentorigin[1] + currentvelocity[1]*(16/f), currentorigin[2] + playermins[2]);
-							VectorSet(neworigin2, currentorigin2[0], currentorigin2[1], currentorigin2[2] - 34);
-							trace = CL_TraceBox(currentorigin2, vec3_origin, vec3_origin, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
-							if (trace.fraction == 1)
-								edgefriction = movevars_edgefriction;
-						}
-						// apply friction
-						f = 1 - frametime * edgefriction * ((f < movevars_stopspeed) ? (movevars_stopspeed / f) : 1) * movevars_friction;
-						f = max(f, 0);
-						VectorScale(currentvelocity, f, currentvelocity);
-					}
-					else
-					{
-						// apply air speed limit
-						wishspeed = min(wishspeed, movevars_maxairspeed);
-					}
-					if (gamemode == GAME_NEXUIZ)
-						addspeed = wishspeed;
-					else
-						addspeed = wishspeed - DotProduct(currentvelocity, wishdir);
-					if (addspeed > 0)
-					{
-						accelspeed = min(movevars_accelerate * frametime * wishspeed, addspeed);
-						VectorMA(currentvelocity, accelspeed, wishdir, currentvelocity);
-					}
-					currentvelocity[2] -= cl_gravity.value * frametime;
-				}
-			}
-			//if (i < cl.movement_numqueue - 1 || (cl_movement.integer & 4))
+			s.q = cl.movement_queue[i];
+			// if a move is more than 50ms, do it as two moves (matching qwsv)
+			if (s.q.frametime > 0.05)
 			{
-				if (crouch)
-				{
-					playermins = cl.playercrouchmins;
-					playermaxs = cl.playercrouchmaxs;
-				}
-				else
-				{
-					playermins = cl.playerstandmins;
-					playermaxs = cl.playerstandmaxs;
-				}
-				onground = false;
-				for (bump = 0, t = frametime;bump < 8 && VectorLength2(currentvelocity) > 0;bump++)
-				{
-					VectorMA(currentorigin, t, currentvelocity, neworigin);
-					trace = CL_TraceBox(currentorigin, playermins, playermaxs, neworigin, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
-					if (trace.fraction < 1 && trace.plane.normal[2] == 0)
-					{
-						// may be a step or wall, try stepping up
-						// first move forward at a higher level
-						VectorSet(currentorigin2, currentorigin[0], currentorigin[1], currentorigin[2] + movevars_stepheight);
-						VectorSet(neworigin2, neworigin[0], neworigin[1], currentorigin[2] + movevars_stepheight);
-						trace2 = CL_TraceBox(currentorigin2, playermins, playermaxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
-						if (!trace2.startsolid)
-						{
-							// then move down from there
-							VectorCopy(trace2.endpos, currentorigin2);
-							VectorSet(neworigin2, trace2.endpos[0], trace2.endpos[1], currentorigin[2]);
-							trace3 = CL_TraceBox(currentorigin2, playermins, playermaxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
-							//Con_Printf("%f %f %f %f : %f %f %f %f : %f %f %f %f\n", trace.fraction, trace.endpos[0], trace.endpos[1], trace.endpos[2], trace2.fraction, trace2.endpos[0], trace2.endpos[1], trace2.endpos[2], trace3.fraction, trace3.endpos[0], trace3.endpos[1], trace3.endpos[2]);
-							// accept the new trace if it made some progress
-							if (fabs(trace3.endpos[0] - trace.endpos[0]) >= 0.03125 || fabs(trace3.endpos[1] - trace.endpos[1]) >= 0.03125)
-							{
-								trace = trace2;
-								VectorCopy(trace3.endpos, trace.endpos);
-							}
-						}
-					}
-					if (trace.fraction == 1)
-					{
-						VectorCopy(trace.endpos, currentorigin);
-						break;
-					}
-					if (trace.plane.normal[2] > 0.7)
-						onground = true;
-					t *= 1 - trace.fraction;
-					if (trace.fraction >= 0.001)
-						VectorCopy(trace.endpos, currentorigin);
-					f = DotProduct(currentvelocity, trace.plane.normal);
-					VectorMA(currentvelocity, -f, trace.plane.normal, currentvelocity);
-				}
+				s.q.frametime *= 0.5;
+				CL_ClientMovement_PlayerMove(&s);
 			}
+			CL_ClientMovement_PlayerMove(&s);
 		}
-		// store replay location
-		cl.onground = onground;
 	}
+	else
+	{
+		// get the first movement queue entry to know whether to crouch and such
+		s.q = cl.movement_queue[0];
+	}
+	// store replay location
+	CL_ClientMovement_UpdateStatus(&s);
+	cl.onground = s.onground;
+	cl.movement_time[1] = cl.movement_time[0];
+	cl.movement_time[0] = cl.movement_queue[cl.movement_numqueue-1].time;
 	VectorCopy(cl.movement_origin, cl.movement_oldorigin);
-	VectorCopy(currentorigin, cl.movement_origin);
-	VectorCopy(currentvelocity, cl.movement_velocity);
-	//VectorCopy(currentorigin, cl.entities[cl.playerentity].state_current.origin);
+	VectorCopy(s.origin, cl.movement_origin);
+	VectorCopy(s.velocity, cl.movement_velocity);
+	//VectorCopy(s.origin, cl.entities[cl.playerentity].state_current.origin);
 	//VectorSet(cl.entities[cl.playerentity].state_current.angles, 0, cl.viewangles[1], 0);
 }
 
@@ -960,16 +1167,15 @@ void CL_SendMove(void)
 	accumtotal++;
 #endif
 
+	cl.movement = cl_movement.integer && cls.signon == SIGNONS && cl.stats[STAT_HEALTH] > 0 && !cl.intermission;
 	if (cl_movement.integer && cls.signon == SIGNONS && cls.protocol != PROTOCOL_QUAKEWORLD)
 	{
 		if (!cl.movement_needupdate)
 			return;
 		cl.movement_needupdate = false;
-		cl.movement = cl.stats[STAT_HEALTH] > 0 && !cl.intermission;
 	}
 	else
 	{
-		cl.movement = false;
 		if (realtime < lastsendtime + 1.0 / bound(10, cl_netinputpacketspersecond.value, 100))
 			return;
 		// don't let it fall behind if CL_SendMove hasn't been called recently