X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=cl_input.c;h=d0bccf0122d1f0777d7b9b827514a0e61859a3f0;hp=481f843d88bac3f452174e69f33be4927cafd70f;hb=d3cbe906d0eedcff735096a08340d8ca90457fa9;hpb=8468ffaf8162a4fe8361127385c40141c375661d

diff --git a/cl_input.c b/cl_input.c
index 481f843d..d0bccf01 100644
--- a/cl_input.c
+++ b/cl_input.c
@@ -8,7 +8,7 @@ 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.  
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 See the GNU General Public License for more details.
 
@@ -49,18 +49,20 @@ state bit 2 is edge triggered on the down to up transition
 kbutton_t	in_mlook, in_klook;
 kbutton_t	in_left, in_right, in_forward, in_back;
 kbutton_t	in_lookup, in_lookdown, in_moveleft, in_moveright;
-kbutton_t	in_strafe, in_speed, in_use, in_jump, in_attack;
+kbutton_t	in_strafe, in_speed, in_jump, in_attack, in_use;
 kbutton_t	in_up, in_down;
 // LordHavoc: added 6 new buttons
 kbutton_t	in_button3, in_button4, in_button5, in_button6, in_button7, in_button8;
 
 int			in_impulse;
 
+extern cvar_t sys_ticrate;
+
 
 void KeyDown (kbutton_t *b)
 {
-	int		k;
-	char	*c;
+	int k;
+	const char *c;
 
 	c = Cmd_Argv(1);
 	if (c[0])
@@ -77,10 +79,10 @@ void KeyDown (kbutton_t *b)
 		b->down[1] = k;
 	else
 	{
-		Con_Printf ("Three keys down for a button!\n");
+		Con_Print("Three keys down for a button!\n");
 		return;
 	}
-	
+
 	if (b->state & 1)
 		return;		// still down
 	b->state |= 1 + 2;	// down + impulse down
@@ -88,9 +90,9 @@ void KeyDown (kbutton_t *b)
 
 void KeyUp (kbutton_t *b)
 {
-	int		k;
-	char	*c;
-	
+	int k;
+	const char *c;
+
 	c = Cmd_Argv(1);
 	if (c[0])
 		k = atoi(c);
@@ -119,10 +121,11 @@ void KeyUp (kbutton_t *b)
 void IN_KLookDown (void) {KeyDown(&in_klook);}
 void IN_KLookUp (void) {KeyUp(&in_klook);}
 void IN_MLookDown (void) {KeyDown(&in_mlook);}
-void IN_MLookUp (void) {
-KeyUp(&in_mlook);
-if ( !(in_mlook.state&1) &&  lookspring.value)
-	V_StartPitchDrift();
+void IN_MLookUp (void)
+{
+	KeyUp(&in_mlook);
+	if ( !(in_mlook.state&1) && lookspring.value)
+		V_StartPitchDrift();
 }
 void IN_UpDown(void) {KeyDown(&in_up);}
 void IN_UpUp(void) {KeyUp(&in_up);}
@@ -153,16 +156,23 @@ void IN_StrafeUp(void) {KeyUp(&in_strafe);}
 void IN_AttackDown(void) {KeyDown(&in_attack);}
 void IN_AttackUp(void) {KeyUp(&in_attack);}
 
+void IN_UseDown(void) {KeyDown(&in_use);}
+void IN_UseUp(void) {KeyUp(&in_use);}
+
 // LordHavoc: added 6 new buttons
-void IN_Button3Down(void) {KeyDown(&in_button3);} void IN_Button3Up(void) {KeyUp(&in_button3);}
-void IN_Button4Down(void) {KeyDown(&in_button4);} void IN_Button4Up(void) {KeyUp(&in_button4);}
-void IN_Button5Down(void) {KeyDown(&in_button5);} void IN_Button5Up(void) {KeyUp(&in_button5);}
-void IN_Button6Down(void) {KeyDown(&in_button6);} void IN_Button6Up(void) {KeyUp(&in_button6);}
-void IN_Button7Down(void) {KeyDown(&in_button7);} void IN_Button7Up(void) {KeyUp(&in_button7);}
-void IN_Button8Down(void) {KeyDown(&in_button8);} void IN_Button8Up(void) {KeyUp(&in_button8);}
-
-void IN_UseDown (void) {KeyDown(&in_use);}
-void IN_UseUp (void) {KeyUp(&in_use);}
+void IN_Button3Down(void) {KeyDown(&in_button3);}
+void IN_Button3Up(void) {KeyUp(&in_button3);}
+void IN_Button4Down(void) {KeyDown(&in_button4);}
+void IN_Button4Up(void) {KeyUp(&in_button4);}
+void IN_Button5Down(void) {KeyDown(&in_button5);}
+void IN_Button5Up(void) {KeyUp(&in_button5);}
+void IN_Button6Down(void) {KeyDown(&in_button6);}
+void IN_Button6Up(void) {KeyUp(&in_button6);}
+void IN_Button7Down(void) {KeyDown(&in_button7);}
+void IN_Button7Up(void) {KeyUp(&in_button7);}
+void IN_Button8Down(void) {KeyDown(&in_button8);}
+void IN_Button8Up(void) {KeyUp(&in_button8);}
+
 void IN_JumpDown (void) {KeyDown(&in_jump);}
 void IN_JumpUp (void) {KeyUp(&in_jump);}
 
@@ -182,12 +192,12 @@ float CL_KeyState (kbutton_t *key)
 {
 	float		val;
 	qboolean	impulsedown, impulseup, down;
-	
+
 	impulsedown = key->state & 2;
 	impulseup = key->state & 4;
 	down = key->state & 1;
 	val = 0;
-	
+
 	if (impulsedown && !impulseup)
 	{
 		if (down)
@@ -218,7 +228,7 @@ float CL_KeyState (kbutton_t *key)
 	}
 
 	key->state &= 1;		// clear impulses
-	
+
 	return val;
 }
 
@@ -239,6 +249,18 @@ cvar_t cl_pitchspeed = {CVAR_SAVE, "cl_pitchspeed","150"};
 
 cvar_t cl_anglespeedkey = {CVAR_SAVE, "cl_anglespeedkey","1.5"};
 
+cvar_t cl_movement = {CVAR_SAVE, "cl_movement", "0"};
+cvar_t cl_movement_latency = {0, "cl_movement_latency", "0"};
+cvar_t cl_movement_maxspeed = {0, "cl_movement_maxspeed", "320"};
+cvar_t cl_movement_maxairspeed = {0, "cl_movement_maxairspeed", "30"};
+cvar_t cl_movement_stopspeed = {0, "cl_movement_stopspeed", "100"};
+cvar_t cl_movement_friction = {0, "cl_movement_friction", "4"};
+cvar_t cl_movement_edgefriction = {0, "cl_movement_edgefriction", "2"};
+cvar_t cl_movement_stepheight = {0, "cl_movement_stepheight", "18"};
+cvar_t cl_movement_accelerate = {0, "cl_movement_accelerate", "10"};
+cvar_t cl_gravity = {0, "cl_gravity", "800"};
+cvar_t cl_slowmo = {0, "cl_slowmo", "1"};
+
 
 /*
 ================
@@ -253,15 +275,14 @@ void CL_AdjustAngles (void)
 	float	up, down;
 
 	if (in_speed.state & 1)
-		speed = cl.frametime * cl_anglespeedkey.value;
+		speed = host_realframetime * cl_anglespeedkey.value;
 	else
-		speed = cl.frametime;
+		speed = host_realframetime;
 
 	if (!(in_strafe.state & 1))
 	{
 		cl.viewangles[YAW] -= speed*cl_yawspeed.value*CL_KeyState (&in_right);
 		cl.viewangles[YAW] += speed*cl_yawspeed.value*CL_KeyState (&in_left);
-		cl.viewangles[YAW] = ANGLEMOD(cl.viewangles[YAW]);
 	}
 	if (in_klook.state & 1)
 	{
@@ -279,18 +300,18 @@ void CL_AdjustAngles (void)
 	if (up || down)
 		V_StopPitchDrift ();
 
-	// LordHavoc: changed from 80 to 90 (straight up)
-	if (cl.viewangles[PITCH] > 90)
-		cl.viewangles[PITCH] = 90;
-	// LordHavoc: changed from -70 to -90 (straight down)
-	if (cl.viewangles[PITCH] < -90)
-		cl.viewangles[PITCH] = -90;
-
-	if (cl.viewangles[ROLL] > 50)
-		cl.viewangles[ROLL] = 50;
-	if (cl.viewangles[ROLL] < -50)
-		cl.viewangles[ROLL] = -50;
-		
+	cl.viewangles[YAW] = ANGLEMOD(cl.viewangles[YAW]);
+	cl.viewangles[PITCH] = ANGLEMOD(cl.viewangles[PITCH]);
+	cl.viewangles[ROLL] = ANGLEMOD(cl.viewangles[ROLL]);
+	if (cl.viewangles[YAW] >= 180)
+		cl.viewangles[YAW] -= 360;
+	if (cl.viewangles[PITCH] >= 180)
+		cl.viewangles[PITCH] -= 360;
+	if (cl.viewangles[ROLL] >= 180)
+		cl.viewangles[ROLL] -= 360;
+
+	cl.viewangles[PITCH] = bound (in_pitch_min.value, cl.viewangles[PITCH], in_pitch_max.value);
+	cl.viewangles[ROLL] = bound(-50, cl.viewangles[ROLL], 50);
 }
 
 /*
@@ -300,145 +321,486 @@ CL_BaseMove
 Send the intended movement message to the server
 ================
 */
-void CL_BaseMove (usercmd_t *cmd)
-{	
+void CL_BaseMove (void)
+{
+	vec3_t temp;
 	if (cls.signon != SIGNONS)
 		return;
-			
+
 	CL_AdjustAngles ();
-	
-	memset (cmd, 0, sizeof(*cmd));
-	
+
+	// PRYDON_CLIENTCURSOR needs to survive basemove resets
+	VectorCopy (cl.cmd.cursor_screen, temp);
+	memset (&cl.cmd, 0, sizeof(cl.cmd));
+	VectorCopy (temp, cl.cmd.cursor_screen);
+
 	if (in_strafe.state & 1)
 	{
-		cmd->sidemove += cl_sidespeed.value * CL_KeyState (&in_right);
-		cmd->sidemove -= cl_sidespeed.value * CL_KeyState (&in_left);
+		cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_right);
+		cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_left);
 	}
 
-	cmd->sidemove += cl_sidespeed.value * CL_KeyState (&in_moveright);
-	cmd->sidemove -= cl_sidespeed.value * CL_KeyState (&in_moveleft);
+	cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_moveright);
+	cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_moveleft);
 
-	cmd->upmove += cl_upspeed.value * CL_KeyState (&in_up);
-	cmd->upmove -= cl_upspeed.value * CL_KeyState (&in_down);
+	cl.cmd.upmove += cl_upspeed.value * CL_KeyState (&in_up);
+	cl.cmd.upmove -= cl_upspeed.value * CL_KeyState (&in_down);
 
 	if (! (in_klook.state & 1) )
-	{	
-		cmd->forwardmove += cl_forwardspeed.value * CL_KeyState (&in_forward);
-		cmd->forwardmove -= cl_backspeed.value * CL_KeyState (&in_back);
-	}	
+	{
+		cl.cmd.forwardmove += cl_forwardspeed.value * CL_KeyState (&in_forward);
+		cl.cmd.forwardmove -= cl_backspeed.value * CL_KeyState (&in_back);
+	}
 
 //
 // adjust for speed key
 //
 	if (in_speed.state & 1)
 	{
-		cmd->forwardmove *= cl_movespeedkey.value;
-		cmd->sidemove *= cl_movespeedkey.value;
-		cmd->upmove *= cl_movespeedkey.value;
+		cl.cmd.forwardmove *= cl_movespeedkey.value;
+		cl.cmd.sidemove *= cl_movespeedkey.value;
+		cl.cmd.upmove *= cl_movespeedkey.value;
 	}
 }
 
 
+#include "cl_collision.h"
+
+void CL_UpdatePrydonCursor(void)
+{
+	vec3_t temp, scale;
+
+	if (!cl_prydoncursor.integer)
+		VectorClear(cl.cmd.cursor_screen);
+
+	/*
+	if (cl.cmd.cursor_screen[0] < -1)
+	{
+		cl.viewangles[YAW] -= m_yaw.value * (cl.cmd.cursor_screen[0] - -1) * vid.realwidth * sensitivity.value * cl.viewzoom;
+		cl.cmd.cursor_screen[0] = -1;
+	}
+	if (cl.cmd.cursor_screen[0] > 1)
+	{
+		cl.viewangles[YAW] -= m_yaw.value * (cl.cmd.cursor_screen[0] - 1) * vid.realwidth * sensitivity.value * cl.viewzoom;
+		cl.cmd.cursor_screen[0] = 1;
+	}
+	if (cl.cmd.cursor_screen[1] < -1)
+	{
+		cl.viewangles[PITCH] += m_pitch.value * (cl.cmd.cursor_screen[1] - -1) * vid.realheight * sensitivity.value * cl.viewzoom;
+		cl.cmd.cursor_screen[1] = -1;
+	}
+	if (cl.cmd.cursor_screen[1] > 1)
+	{
+		cl.viewangles[PITCH] += m_pitch.value * (cl.cmd.cursor_screen[1] - 1) * vid.realheight * sensitivity.value * cl.viewzoom;
+		cl.cmd.cursor_screen[1] = 1;
+	}
+	*/
+	cl.cmd.cursor_screen[0] = bound(-1, cl.cmd.cursor_screen[0], 1);
+	cl.cmd.cursor_screen[1] = bound(-1, cl.cmd.cursor_screen[1], 1);
+	cl.cmd.cursor_screen[2] = 1;
+
+	scale[0] = -tan(r_refdef.fov_x * M_PI / 360.0);
+	scale[1] = -tan(r_refdef.fov_y * M_PI / 360.0);
+	scale[2] = 1;
+
+	// trace distance
+	VectorScale(scale, 1000000, scale);
+
+	// FIXME: use something other than renderer variables here
+	// (but they need to match)
+	VectorCopy(r_vieworigin, 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_view_matrix, temp, cl.cmd.cursor_end);
+	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);
+	// makes sparks where cursor is
+	//CL_SparkShower(cl.cmd.cursor_impact, cl.cmd.cursor_normal, 5, 0);
+}
+
+void CL_ClientMovement(qboolean buttonjump, qboolean buttoncrouch)
+{
+	int i, n, bump, contents, crouch;
+	//double simulatedtime;
+	double currenttime;
+	double newtime;
+	double frametime;
+	double t;
+	vec_t wishspeed, addspeed, accelspeed, f, *playermins, *playermaxs;
+	client_movementqueue_t *q;
+	vec3_t currentorigin, currentvelocity, forward, right, up, wishvel, wishdir, neworigin, currentorigin2, neworigin2, yawangles;
+	trace_t trace, trace2, trace3;
+	// remove stale queue items
+	n = cl.movement_numqueue;
+	cl.movement_numqueue = 0;
+	for (i = 0;i < n;i++)
+		if (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 < sizeof(cl.movement_queue)/sizeof(cl.movement_queue[0]))
+	{
+		// add to input queue
+		cl.movement_queue[cl.movement_numqueue].time = cl.mtime[0] + cl_movement_latency.value;
+		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 = false;
+	// abort if client movement is disabled
+	if (!cl_movement.integer || cl.stats[STAT_HEALTH] <= 0)
+		return;
+	// fetch current starting values
+	currenttime = cl.mtime[0];
+	VectorCopy(cl_entities[cl.playerentity].state_current.origin, currentorigin);
+	VectorCopy(cl.mvelocity[0], currentvelocity);
+	// calculate time to execute for
+	//simulatedtime = currenttime + cl_movement_latency.value;
+	// 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
+	crouch = false; // this will be updated on first move
+	//Con_Printf("%f: ", currenttime);
+	// replay input queue, and remove any stale queue items
+	// note: this relies on the fact there's always one queue item at the end
+	for (i = 0, q = cl.movement_queue;i < cl.movement_numqueue;i++, q++)
+	{
+		//newtime = (i == cl.movement_numqueue) ? simulatedtime : q->time;
+		newtime = q->time;
+		frametime = newtime - currenttime;
+		if (frametime < 0)
+			continue;
+		//Con_Printf(" %f", frametime);
+		currenttime = newtime;
+		if (crouch)
+		{
+			playermins = cl_playercrouchmins;
+			playermaxs = cl_playercrouchmaxs;
+		}
+		else
+		{
+			playermins = cl_playerstandmins;
+			playermaxs = cl_playerstandmaxs;
+		}
+		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_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] + cl_movement_stepheight.value);
+				VectorSet(neworigin2, neworigin[0], neworigin[1], currentorigin[2] + cl_movement_stepheight.value);
+				trace2 = CL_TraceBox(currentorigin2, playermins, playermaxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
+				// 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_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;
+			}
+			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);
+		}
+		if (i < cl.movement_numqueue)
+		{
+			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_PLAYERCLIP, true);
+					if (!trace.startsolid)
+						crouch = false;
+				}
+			}
+			// 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);
+				wishspeed = min(wishspeed, cl_movement_maxspeed.value);
+				if (crouch)
+					wishspeed *= 0.5;
+				wishspeed *= 0.6;
+				VectorScale(currentvelocity, (1 - frametime * cl_movement_friction.value), currentvelocity);
+				f = wishspeed - DotProduct(currentvelocity, wishdir);
+				if (f > 0)
+				{
+					f = min(f, cl_movement_accelerate.value * 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
+				VectorSet(yawangles, 0, cl.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);
+				wishspeed = min(wishspeed, cl_movement_maxspeed.value);
+				if (crouch)
+					wishspeed *= 0.5;
+				// check if onground
+				VectorSet(currentorigin2, currentorigin[0], currentorigin[1], currentorigin[2] + 1);
+				VectorSet(neworigin2, currentorigin[0], currentorigin[1], currentorigin[2] - 1);
+				trace = CL_TraceBox(currentorigin2, playermins, playermaxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
+				if (trace.fraction < 1 && trace.plane.normal[2] > 0.7)
+				{
+					// apply ground friction
+					f = sqrt(currentvelocity[0] * currentvelocity[0] + currentvelocity[1] * currentvelocity[1]);
+					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_PLAYERCLIP, true);
+					// apply friction
+					f = 1 - frametime * (trace.fraction == 1 ? cl_movement_edgefriction.value : 1) * ((f < cl_movement_stopspeed.value) ? (cl_movement_stopspeed.value / f) : 1) * cl_movement_friction.value;
+					f = max(f, 0);
+					VectorScale(currentvelocity, f, currentvelocity);
+				}
+				else
+				{
+					// apply air speed limit
+					wishspeed = min(wishspeed, cl_movement_maxairspeed.value);
+				}
+				if (gamemode == GAME_NEXUIZ)
+					addspeed = wishspeed;
+				else
+					addspeed = wishspeed - DotProduct(currentvelocity, wishdir);
+				if (addspeed > 0)
+				{
+					accelspeed = min(cl_movement_accelerate.value * frametime * wishspeed, addspeed);
+					VectorMA(currentvelocity, accelspeed, wishdir, currentvelocity);
+				}
+				currentvelocity[2] -= cl_gravity.value * frametime;
+			}
+		}
+	}
+	//Con_Printf(" :%f\n", currenttime);
+	// store replay location
+	cl.movement = true;
+	VectorCopy(cl.movement_origin, cl.movement_oldorigin);
+	VectorCopy(currentorigin, cl.movement_origin);
+	//VectorCopy(currentorigin, cl_entities[cl.playerentity].state_current.origin);
+	//VectorSet(cl_entities[cl.playerentity].state_current.angles, 0, cl.viewangles[1], 0);
+}
 
 /*
 ==============
 CL_SendMove
 ==============
 */
-void CL_SendMove (usercmd_t *cmd)
+void CL_SendMove(void)
 {
-	int		i;
-	int		bits;
-	sizebuf_t	buf;
-	byte	data[128];
-	static double lastmovetime;
+	int i;
+	int bits;
+	sizebuf_t buf;
+	qbyte data[128];
+#define MOVEAVERAGING 0
+#if MOVEAVERAGING
 	static float forwardmove, sidemove, upmove, total; // accumulation
-
-	forwardmove += cmd->forwardmove;
-	sidemove += cmd->sidemove;
-	upmove += cmd->upmove;
+#else
+	float forwardmove, sidemove, upmove;
+#endif
+
+#if MOVEAVERAGING
+	// accumulate changes between messages
+	forwardmove += cl.cmd.forwardmove;
+	sidemove += cl.cmd.sidemove;
+	upmove += cl.cmd.upmove;
 	total++;
-	// LordHavoc: cap outgoing movement messages to sys_ticrate
-	if ((cl.maxclients > 1) && (realtime - lastmovetime < sys_ticrate.value))
+#endif
+	if (cls.signon != SIGNONS)
 		return;
-	lastmovetime = realtime;
-	// average what has happened during this time
+#if MOVEAVERAGING
+	// average the accumulated changes
 	total = 1.0f / total;
 	forwardmove *= total;
 	sidemove *= total;
 	upmove *= total;
 	total = 0;
+#else
+	// use the latest values
+	forwardmove = cl.cmd.forwardmove;
+	sidemove = cl.cmd.sidemove;
+	upmove = cl.cmd.upmove;
+#endif
 
 	buf.maxsize = 128;
 	buf.cursize = 0;
 	buf.data = data;
-	
-	cl.cmd = *cmd;
-
-//
-// send the movement message
-//
-    MSG_WriteByte (&buf, clc_move);
-
-	MSG_WriteFloat (&buf, cl.mtime[0]);	// so server can get ping times
 
-	if (dpprotocol)
-	{
-		for (i=0 ; i<3 ; i++)
-			MSG_WritePreciseAngle (&buf, cl.viewangles[i]);
-	}
-	else
+	// set button bits
+	// LordHavoc: added 6 new buttons and use and chat buttons, and prydon cursor active button
+	bits = 0;
+	if (in_attack.state   & 3) bits |=   1;in_attack.state  &= ~2;
+	if (in_jump.state     & 3) bits |=   2;in_jump.state    &= ~2;
+	if (in_button3.state  & 3) bits |=   4;in_button3.state &= ~2;
+	if (in_button4.state  & 3) bits |=   8;in_button4.state &= ~2;
+	if (in_button5.state  & 3) bits |=  16;in_button5.state &= ~2;
+	if (in_button6.state  & 3) bits |=  32;in_button6.state &= ~2;
+	if (in_button7.state  & 3) bits |=  64;in_button7.state &= ~2;
+	if (in_button8.state  & 3) bits |= 128;in_button8.state &= ~2;
+	if (in_use.state      & 3) bits |= 256;in_use.state     &= ~2;
+	if (key_dest != key_game || key_consoleactive) bits |= 512;
+	if (cl_prydoncursor.integer) bits |= 1024;
+	// button bits 11-31 unused currently
+	// rotate/zoom view serverside if PRYDON_CLIENTCURSOR cursor is at edge of screen
+	if (cl.cmd.cursor_screen[0] <= -1) bits |= 8;
+	if (cl.cmd.cursor_screen[0] >=  1) bits |= 16;
+	if (cl.cmd.cursor_screen[1] <= -1) bits |= 32;
+	if (cl.cmd.cursor_screen[1] >=  1) bits |= 64;
+
+	// always dump the first two messages, because they may contain leftover inputs from the last level
+	if (++cl.movemessages >= 2)
 	{
-		for (i=0 ; i<3 ; i++)
-			MSG_WriteAngle (&buf, cl.viewangles[i]);
+		// send the movement message
+		// PROTOCOL_QUAKE       clc_move = 16 bytes total
+		// PROTOCOL_DARKPLACES1 clc_move = 19 bytes total
+		// PROTOCOL_DARKPLACES2 clc_move = 25 bytes total
+		// PROTOCOL_DARKPLACES3 clc_move = 25 bytes total
+		// PROTOCOL_DARKPLACES4 clc_move = 19 bytes total
+		// PROTOCOL_DARKPLACES5 clc_move = 19 bytes total
+		// PROTOCOL_DARKPLACES6 clc_move = 52 bytes total
+		// 5 bytes
+		MSG_WriteByte (&buf, clc_move);
+		MSG_WriteFloat (&buf, cl.mtime[0]);	// so server can get ping times
+		if (cl.protocol == PROTOCOL_DARKPLACES6)
+		{
+			// 6 bytes
+			for (i = 0;i < 3;i++)
+				MSG_WriteAngle16i (&buf, cl.viewangles[i]);
+			// 6 bytes
+			MSG_WriteCoord16i (&buf, forwardmove);
+			MSG_WriteCoord16i (&buf, sidemove);
+			MSG_WriteCoord16i (&buf, upmove);
+			// 5 bytes
+			MSG_WriteLong (&buf, bits);
+			MSG_WriteByte (&buf, in_impulse);
+			// PRYDON_CLIENTCURSOR
+			// 30 bytes
+			MSG_WriteShort (&buf, cl.cmd.cursor_screen[0] * 32767.0f);
+			MSG_WriteShort (&buf, cl.cmd.cursor_screen[1] * 32767.0f);
+			MSG_WriteFloat (&buf, cl.cmd.cursor_start[0]);
+			MSG_WriteFloat (&buf, cl.cmd.cursor_start[1]);
+			MSG_WriteFloat (&buf, cl.cmd.cursor_start[2]);
+			MSG_WriteFloat (&buf, cl.cmd.cursor_impact[0]);
+			MSG_WriteFloat (&buf, cl.cmd.cursor_impact[1]);
+			MSG_WriteFloat (&buf, cl.cmd.cursor_impact[2]);
+			MSG_WriteShort (&buf, cl.cmd.cursor_entitynumber);
+		}
+		else
+		{
+			if (cl.protocol == PROTOCOL_QUAKE || cl.protocol == PROTOCOL_NEHAHRAMOVIE)
+			{
+				// 3 bytes
+				for (i = 0;i < 3;i++)
+					MSG_WriteAngle8i (&buf, cl.viewangles[i]);
+			}
+			else if (cl.protocol == PROTOCOL_DARKPLACES2 || cl.protocol == PROTOCOL_DARKPLACES3)
+			{
+				// 12 bytes
+				for (i = 0;i < 3;i++)
+					MSG_WriteAngle32f (&buf, cl.viewangles[i]);
+			}
+			else if (cl.protocol == PROTOCOL_DARKPLACES1 || cl.protocol == PROTOCOL_DARKPLACES4 || cl.protocol == PROTOCOL_DARKPLACES5)
+			{
+				// 6 bytes
+				for (i = 0;i < 3;i++)
+					MSG_WriteAngle16i (&buf, cl.viewangles[i]);
+			}
+			else
+				Host_Error("CL_SendMove: unknown cl.protocol %i\n", cl.protocol);
+			// 6 bytes
+			MSG_WriteCoord16i (&buf, forwardmove);
+			MSG_WriteCoord16i (&buf, sidemove);
+			MSG_WriteCoord16i (&buf, upmove);
+			// 2 bytes
+			MSG_WriteByte (&buf, bits);
+			MSG_WriteByte (&buf, in_impulse);
+		}
 	}
-	
-    MSG_WriteShort (&buf, forwardmove);
-    MSG_WriteShort (&buf, sidemove);
-    MSG_WriteShort (&buf, upmove);
 
+#if MOVEAVERAGING
 	forwardmove = sidemove = upmove = 0;
-//
-// send button bits
-//
-	bits = 0;
-	
-	if ( in_attack.state & 3 )
-		bits |= 1;
-	in_attack.state &= ~2;
-	
-	if (in_jump.state & 3)
-		bits |= 2;
-	in_jump.state &= ~2;
-	// LordHavoc: added 6 new buttons
-	if (in_button3.state & 3) bits |=   4;in_button3.state &= ~2;
-	if (in_button4.state & 3) bits |=   8;in_button4.state &= ~2;
-	if (in_button5.state & 3) bits |=  16;in_button5.state &= ~2;
-	if (in_button6.state & 3) bits |=  32;in_button6.state &= ~2;
-	if (in_button7.state & 3) bits |=  64;in_button7.state &= ~2;
-	if (in_button8.state & 3) bits |= 128;in_button8.state &= ~2;
-	
-    MSG_WriteByte (&buf, bits);
-
-    MSG_WriteByte (&buf, in_impulse);
+#endif
 	in_impulse = 0;
 
-//
-// deliver the message
-//
+	// ack the last few frame numbers
+	// (redundent to improve handling of client->server packet loss)
+	// for LATESTFRAMENUMS == 3 case this is 15 bytes
+	for (i = 0;i < LATESTFRAMENUMS;i++)
+	{
+		if (cl.latestframenums[i] > 0)
+		{
+			if (developer_networkentities.integer >= 1)
+				Con_Printf("send clc_ackframe %i\n", cl.latestframenums[i]);
+			MSG_WriteByte(&buf, clc_ackframe);
+			MSG_WriteLong(&buf, cl.latestframenums[i]);
+		}
+	}
+
+	// PROTOCOL_DARKPLACES6 = 67 bytes per packet
+
+	// deliver the message
 	if (cls.demoplayback)
 		return;
-
-//
-// always dump the first two messages, because they may contain leftover inputs from the last level
-//
-	if (++cl.movemessages <= 2)
+	// nothing to send
+	if (!buf.cursize)
 		return;
 
-	if (NET_SendUnreliableMessage (cls.netcon, &buf) == -1)
+	// FIXME: bits & 64 is +button5, Nexuiz specific
+	CL_ClientMovement((bits & 2) != 0, (bits & 64) != 0);
+
+	if (NetConn_SendUnreliableMessage(cls.netcon, &buf) == -1)
 	{
-		Con_Printf ("CL_SendMove: lost server connection\n");
-		CL_Disconnect ();
+		Con_Print("CL_SendMove: lost server connection\n");
+		CL_Disconnect();
+		Host_ShutdownServer(false);
 	}
 }
 
@@ -475,8 +837,6 @@ void CL_InitInput (void)
 	Cmd_AddCommand ("-speed", IN_SpeedUp);
 	Cmd_AddCommand ("+attack", IN_AttackDown);
 	Cmd_AddCommand ("-attack", IN_AttackUp);
-	Cmd_AddCommand ("+use", IN_UseDown);
-	Cmd_AddCommand ("-use", IN_UseUp);
 	Cmd_AddCommand ("+jump", IN_JumpDown);
 	Cmd_AddCommand ("-jump", IN_JumpUp);
 	Cmd_AddCommand ("impulse", IN_Impulse);
@@ -485,6 +845,10 @@ void CL_InitInput (void)
 	Cmd_AddCommand ("+mlook", IN_MLookDown);
 	Cmd_AddCommand ("-mlook", IN_MLookUp);
 
+	// LordHavoc: added use button
+	Cmd_AddCommand ("+use", IN_UseDown);
+	Cmd_AddCommand ("-use", IN_UseUp);
+
 	// LordHavoc: added 6 new buttons
 	Cmd_AddCommand ("+button3", IN_Button3Down);
 	Cmd_AddCommand ("-button3", IN_Button3Up);
@@ -498,4 +862,17 @@ void CL_InitInput (void)
 	Cmd_AddCommand ("-button7", IN_Button7Up);
 	Cmd_AddCommand ("+button8", IN_Button8Down);
 	Cmd_AddCommand ("-button8", IN_Button8Up);
+
+	Cvar_RegisterVariable(&cl_movement);
+	Cvar_RegisterVariable(&cl_movement_latency);
+	Cvar_RegisterVariable(&cl_movement_maxspeed);
+	Cvar_RegisterVariable(&cl_movement_maxairspeed);
+	Cvar_RegisterVariable(&cl_movement_stopspeed);
+	Cvar_RegisterVariable(&cl_movement_friction);
+	Cvar_RegisterVariable(&cl_movement_edgefriction);
+	Cvar_RegisterVariable(&cl_movement_stepheight);
+	Cvar_RegisterVariable(&cl_movement_accelerate);
+	Cvar_RegisterVariable(&cl_gravity);
+	Cvar_RegisterVariable(&cl_slowmo);
 }
+