2 Copyright (C) 1996-1997 Id Software, Inc.
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13 See the GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 // cl.input.c -- builds an intended movement command to send to the server
22 // Quake is a trademark of Id Software, Inc., (c) 1996 Id Software, Inc. All
29 ===============================================================================
33 Continuous button event tracking is complicated by the fact that two different
34 input sources (say, mouse button 1 and the control key) can both press the
35 same button, but the button should only be released when both of the
36 pressing key have been released.
38 When a key event issues a button command (+forward, +attack, etc), it appends
39 its key number as a parameter to the command so it can be matched up with
42 state bit 0 is the current state of the key
43 state bit 1 is edge triggered on the up to down transition
44 state bit 2 is edge triggered on the down to up transition
46 ===============================================================================
50 kbutton_t in_mlook, in_klook;
51 kbutton_t in_left, in_right, in_forward, in_back;
52 kbutton_t in_lookup, in_lookdown, in_moveleft, in_moveright;
53 kbutton_t in_strafe, in_speed, in_jump, in_attack, in_use;
54 kbutton_t in_up, in_down;
55 // LordHavoc: added 6 new buttons
56 kbutton_t in_button3, in_button4, in_button5, in_button6, in_button7, in_button8;
58 kbutton_t in_button9, in_button10, in_button11, in_button12, in_button13, in_button14, in_button15, in_button16;
64 void KeyDown (kbutton_t *b)
73 k = -1; // typed manually at the console for continuous down
75 if (k == b->down[0] || k == b->down[1])
76 return; // repeating key
84 Con_Print("Three keys down for a button!\n");
90 b->state |= 1 + 2; // down + impulse down
93 void KeyUp (kbutton_t *b)
102 { // typed manually at the console, assume for unsticking, so clear all
103 b->down[0] = b->down[1] = 0;
104 b->state = 4; // impulse up
110 else if (b->down[1] == k)
113 return; // key up without coresponding down (menu pass through)
114 if (b->down[0] || b->down[1])
115 return; // some other key is still holding it down
118 return; // still up (this should not happen)
119 b->state &= ~1; // now up
120 b->state |= 4; // impulse up
123 void IN_KLookDown (void) {KeyDown(&in_klook);}
124 void IN_KLookUp (void) {KeyUp(&in_klook);}
125 void IN_MLookDown (void) {KeyDown(&in_mlook);}
126 void IN_MLookUp (void)
129 if ( !(in_mlook.state&1) && lookspring.value)
132 void IN_UpDown(void) {KeyDown(&in_up);}
133 void IN_UpUp(void) {KeyUp(&in_up);}
134 void IN_DownDown(void) {KeyDown(&in_down);}
135 void IN_DownUp(void) {KeyUp(&in_down);}
136 void IN_LeftDown(void) {KeyDown(&in_left);}
137 void IN_LeftUp(void) {KeyUp(&in_left);}
138 void IN_RightDown(void) {KeyDown(&in_right);}
139 void IN_RightUp(void) {KeyUp(&in_right);}
140 void IN_ForwardDown(void) {KeyDown(&in_forward);}
141 void IN_ForwardUp(void) {KeyUp(&in_forward);}
142 void IN_BackDown(void) {KeyDown(&in_back);}
143 void IN_BackUp(void) {KeyUp(&in_back);}
144 void IN_LookupDown(void) {KeyDown(&in_lookup);}
145 void IN_LookupUp(void) {KeyUp(&in_lookup);}
146 void IN_LookdownDown(void) {KeyDown(&in_lookdown);}
147 void IN_LookdownUp(void) {KeyUp(&in_lookdown);}
148 void IN_MoveleftDown(void) {KeyDown(&in_moveleft);}
149 void IN_MoveleftUp(void) {KeyUp(&in_moveleft);}
150 void IN_MoverightDown(void) {KeyDown(&in_moveright);}
151 void IN_MoverightUp(void) {KeyUp(&in_moveright);}
153 void IN_SpeedDown(void) {KeyDown(&in_speed);}
154 void IN_SpeedUp(void) {KeyUp(&in_speed);}
155 void IN_StrafeDown(void) {KeyDown(&in_strafe);}
156 void IN_StrafeUp(void) {KeyUp(&in_strafe);}
158 void IN_AttackDown(void) {KeyDown(&in_attack);}
159 void IN_AttackUp(void) {KeyUp(&in_attack);}
161 void IN_UseDown(void) {KeyDown(&in_use);}
162 void IN_UseUp(void) {KeyUp(&in_use);}
164 // LordHavoc: added 6 new buttons
165 void IN_Button3Down(void) {KeyDown(&in_button3);}
166 void IN_Button3Up(void) {KeyUp(&in_button3);}
167 void IN_Button4Down(void) {KeyDown(&in_button4);}
168 void IN_Button4Up(void) {KeyUp(&in_button4);}
169 void IN_Button5Down(void) {KeyDown(&in_button5);}
170 void IN_Button5Up(void) {KeyUp(&in_button5);}
171 void IN_Button6Down(void) {KeyDown(&in_button6);}
172 void IN_Button6Up(void) {KeyUp(&in_button6);}
173 void IN_Button7Down(void) {KeyDown(&in_button7);}
174 void IN_Button7Up(void) {KeyUp(&in_button7);}
175 void IN_Button8Down(void) {KeyDown(&in_button8);}
176 void IN_Button8Up(void) {KeyUp(&in_button8);}
178 void IN_Button9Down(void) {KeyDown(&in_button9);}
179 void IN_Button9Up(void) {KeyUp(&in_button9);}
180 void IN_Button10Down(void) {KeyDown(&in_button10);}
181 void IN_Button10Up(void) {KeyUp(&in_button10);}
182 void IN_Button11Down(void) {KeyDown(&in_button11);}
183 void IN_Button11Up(void) {KeyUp(&in_button11);}
184 void IN_Button12Down(void) {KeyDown(&in_button12);}
185 void IN_Button12Up(void) {KeyUp(&in_button12);}
186 void IN_Button13Down(void) {KeyDown(&in_button13);}
187 void IN_Button13Up(void) {KeyUp(&in_button13);}
188 void IN_Button14Down(void) {KeyDown(&in_button14);}
189 void IN_Button14Up(void) {KeyUp(&in_button14);}
190 void IN_Button15Down(void) {KeyDown(&in_button15);}
191 void IN_Button15Up(void) {KeyUp(&in_button15);}
192 void IN_Button16Down(void) {KeyDown(&in_button16);}
193 void IN_Button16Up(void) {KeyUp(&in_button16);}
195 void IN_JumpDown (void) {KeyDown(&in_jump);}
196 void IN_JumpUp (void) {KeyUp(&in_jump);}
198 void IN_Impulse (void) {in_impulse=atoi(Cmd_Argv(1));}
200 int in_bestweapon_info[][5] =
202 {'1', 1, IT_AXE, STAT_SHELLS, 0},
203 {'2', 2, IT_SHOTGUN, STAT_SHELLS, 1},
204 {'3', 3, IT_SUPER_SHOTGUN, STAT_SHELLS, 1},
205 {'4', 4, IT_NAILGUN, STAT_NAILS, 1},
206 {'5', 5, IT_SUPER_NAILGUN, STAT_NAILS, 1},
207 {'6', 6, IT_GRENADE_LAUNCHER, STAT_ROCKETS, 1},
208 {'7', 7, IT_ROCKET_LAUNCHER, STAT_ROCKETS, 1},
209 {'8', 8, IT_LIGHTNING, STAT_CELLS, 1},
210 {'9', 9, 128, STAT_CELLS, 1}, // generic energy weapon for mods
211 {'p', 209, 128, STAT_CELLS, 1}, // dpmod plasma gun
212 {'w', 210, 8388608, STAT_CELLS, 1}, // dpmod plasma wave cannon
213 {'l', 225, HIT_LASER_CANNON, STAT_CELLS, 1}, // hipnotic laser cannon
214 {'h', 226, HIT_MJOLNIR, STAT_CELLS, 0}, // hipnotic mjolnir hammer
217 void IN_BestWeapon (void)
223 Con_Printf("bestweapon requires 1 parameter\n");
229 // figure out which weapon this character refers to
230 for (n = 0;in_bestweapon_info[n][0] >= 0;n++)
232 if (in_bestweapon_info[n][0] == s[i])
234 // we found out what weapon this character refers to
235 // check if the inventory contains the weapon and enough ammo
236 if ((cl.stats[STAT_ITEMS] & in_bestweapon_info[n][2]) && (cl.stats[in_bestweapon_info[n][3]] >= in_bestweapon_info[n][4]))
238 // we found one of the weapons the player wanted
239 // send an impulse to switch to it
240 in_impulse = in_bestweapon_info[n][1];
246 // if we couldn't identify the weapon we just ignore it and continue checking for other weapons
248 // if we couldn't find any of the weapons, there's nothing more we can do...
255 Returns 0.25 if a key was pressed and released during the frame,
256 0.5 if it was pressed and held
257 0 if held then released, and
258 1.0 if held for the entire time
261 float CL_KeyState (kbutton_t *key)
264 qboolean impulsedown, impulseup, down;
266 impulsedown = key->state & 2;
267 impulseup = key->state & 4;
268 down = key->state & 1;
271 if (impulsedown && !impulseup)
274 val = 0.5; // pressed and held this frame
276 val = 0; // I_Error ();
278 if (impulseup && !impulsedown)
281 val = 0; // I_Error ();
283 val = 0; // released this frame
285 if (!impulsedown && !impulseup)
288 val = 1.0; // held the entire frame
290 val = 0; // up the entire frame
292 if (impulsedown && impulseup)
295 val = 0.75; // released and re-pressed this frame
297 val = 0.25; // pressed and released this frame
300 key->state &= 1; // clear impulses
308 //==========================================================================
310 cvar_t cl_upspeed = {CVAR_SAVE, "cl_upspeed","400","vertical movement speed (while swimming or flying)"};
311 cvar_t cl_forwardspeed = {CVAR_SAVE, "cl_forwardspeed","400","forward movement speed"};
312 cvar_t cl_backspeed = {CVAR_SAVE, "cl_backspeed","400","backward movement speed"};
313 cvar_t cl_sidespeed = {CVAR_SAVE, "cl_sidespeed","350","strafe movement speed"};
315 cvar_t cl_movespeedkey = {CVAR_SAVE, "cl_movespeedkey","2.0","how much +speed multiplies keyboard movement speed"};
317 cvar_t cl_yawspeed = {CVAR_SAVE, "cl_yawspeed","140","keyboard yaw turning speed"};
318 cvar_t cl_pitchspeed = {CVAR_SAVE, "cl_pitchspeed","150","keyboard pitch turning speed"};
320 cvar_t cl_anglespeedkey = {CVAR_SAVE, "cl_anglespeedkey","1.5","how much +speed multiplies keyboard turning speed"};
322 cvar_t cl_movement = {CVAR_SAVE, "cl_movement", "0", "enables clientside prediction of your player movement"};
323 cvar_t cl_movement_latency = {0, "cl_movement_latency", "0", "compensates for this much latency (ping time) on quake servers which do not really support prediction, no effect on darkplaces7 protocol servers or quakeworld servers"};
324 cvar_t cl_movement_maxspeed = {0, "cl_movement_maxspeed", "320", "how fast you can move (should match sv_maxspeed)"};
325 cvar_t cl_movement_maxairspeed = {0, "cl_movement_maxairspeed", "30", "how fast you can move while in the air (should match sv_maxairspeed)"};
326 cvar_t cl_movement_stopspeed = {0, "cl_movement_stopspeed", "100", "speed below which you will be slowed rapidly to a stop rather than sliding endlessly (should match sv_stopspeed)"};
327 cvar_t cl_movement_friction = {0, "cl_movement_friction", "4", "how fast you slow down (should match sv_friction)"};
328 cvar_t cl_movement_waterfriction = {0, "cl_movement_waterfriction", "-1", "how fast you slow down (should match sv_friction), if less than 0 the cl_movement_friction variable is used instead"};
329 cvar_t cl_movement_edgefriction = {0, "cl_movement_edgefriction", "2", "how much to slow down when you may be about to fall off a ledge (should match edgefriction)"};
330 cvar_t cl_movement_stepheight = {0, "cl_movement_stepheight", "18", "how tall a step you can step in one instant (should match sv_stepheight)"};
331 cvar_t cl_movement_accelerate = {0, "cl_movement_accelerate", "10", "how fast you accelerate (should match sv_accelerate)"};
332 cvar_t cl_movement_airaccelerate = {0, "cl_movement_airaccelerate", "-1", "how fast you accelerate while in the air (should match sv_airaccelerate), if less than 0 the cl_movement_accelerate variable is used instead"};
333 cvar_t cl_movement_wateraccelerate = {0, "cl_movement_wateraccelerate", "-1", "how fast you accelerate while in the air (should match sv_airaccelerate), if less than 0 the cl_movement_accelerate variable is used instead"};
334 cvar_t cl_movement_jumpvelocity = {0, "cl_movement_jumpvelocity", "270", "how fast you move upward when you begin a jump (should match the quakec code)"};
335 cvar_t cl_movement_airaccel_qw = {0, "cl_movement_airaccel_qw", "1", "ratio of QW-style air control as opposed to simple acceleration (should match sv_airaccel_qw)"};
336 cvar_t cl_movement_airaccel_sideways_friction = {0, "cl_movement_airaccel_sideways_friction", "0", "anti-sideways movement stabilization (should match sv_airaccel_sideways_friction)"};
337 cvar_t cl_gravity = {0, "cl_gravity", "800", "how much gravity to apply in client physics (should match sv_gravity)"};
338 cvar_t cl_slowmo = {0, "cl_slowmo", "1", "speed of game time (should match slowmo)"};
340 cvar_t in_pitch_min = {0, "in_pitch_min", "-90", "how far downward you can aim (quake used -70"};
341 cvar_t in_pitch_max = {0, "in_pitch_max", "90", "how far upward you can aim (quake used 80"};
343 cvar_t m_filter = {CVAR_SAVE, "m_filter","0", "smoothes mouse movement, less responsive but smoother aiming"};
345 cvar_t cl_netinputpacketspersecond = {CVAR_SAVE, "cl_netinputpacketspersecond","50", "how many input packets to send to server each second"};
346 cvar_t cl_netinputpacketlosstolerance = {CVAR_SAVE, "cl_netinputpacketlosstolerance", "4", "how many packets in a row can be lost without movement issues when using cl_movement (technically how many input messages to repeat in each packet that have not yet been acknowledged by the server)"};
348 cvar_t cl_nodelta = {0, "cl_nodelta", "0", "disables delta compression of non-player entities in QW network protocol"};
355 Moves the local angle positions
358 void CL_AdjustAngles (void)
363 if (in_speed.state & 1)
364 speed = cl.realframetime * cl_anglespeedkey.value;
366 speed = cl.realframetime;
368 if (!(in_strafe.state & 1))
370 cl.viewangles[YAW] -= speed*cl_yawspeed.value*CL_KeyState (&in_right);
371 cl.viewangles[YAW] += speed*cl_yawspeed.value*CL_KeyState (&in_left);
373 if (in_klook.state & 1)
376 cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * CL_KeyState (&in_forward);
377 cl.viewangles[PITCH] += speed*cl_pitchspeed.value * CL_KeyState (&in_back);
380 up = CL_KeyState (&in_lookup);
381 down = CL_KeyState(&in_lookdown);
383 cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * up;
384 cl.viewangles[PITCH] += speed*cl_pitchspeed.value * down;
389 cl.viewangles[YAW] = ANGLEMOD(cl.viewangles[YAW]);
390 cl.viewangles[PITCH] = ANGLEMOD(cl.viewangles[PITCH]);
391 cl.viewangles[ROLL] = ANGLEMOD(cl.viewangles[ROLL]);
392 if (cl.viewangles[YAW] >= 180)
393 cl.viewangles[YAW] -= 360;
394 if (cl.viewangles[PITCH] >= 180)
395 cl.viewangles[PITCH] -= 360;
396 if (cl.viewangles[ROLL] >= 180)
397 cl.viewangles[ROLL] -= 360;
399 cl.viewangles[PITCH] = bound (in_pitch_min.value, cl.viewangles[PITCH], in_pitch_max.value);
400 cl.viewangles[ROLL] = bound(-50, cl.viewangles[ROLL], 50);
403 qboolean cl_ignoremousemove = false;
409 Send the intended movement message to the server
415 static float old_mouse_x = 0, old_mouse_y = 0;
417 // clamp before the move to prevent starting with bad angles
420 // reset some of the command fields
421 cl.cmd.forwardmove = 0;
425 // get basic movement from keyboard
426 if (in_strafe.state & 1)
428 cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_right);
429 cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_left);
432 cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_moveright);
433 cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_moveleft);
435 cl.cmd.upmove += cl_upspeed.value * CL_KeyState (&in_up);
436 cl.cmd.upmove -= cl_upspeed.value * CL_KeyState (&in_down);
438 if (! (in_klook.state & 1) )
440 cl.cmd.forwardmove += cl_forwardspeed.value * CL_KeyState (&in_forward);
441 cl.cmd.forwardmove -= cl_backspeed.value * CL_KeyState (&in_back);
444 // adjust for speed key
445 if (in_speed.state & 1)
447 cl.cmd.forwardmove *= cl_movespeedkey.value;
448 cl.cmd.sidemove *= cl_movespeedkey.value;
449 cl.cmd.upmove *= cl_movespeedkey.value;
455 // allow mice or other external controllers to add to the move
458 // ignore a mouse move if mouse was activated/deactivated this frame
459 if (cl_ignoremousemove)
461 cl_ignoremousemove = false;
466 // apply m_filter if it is on
469 if (m_filter.integer)
471 in_mouse_x = (mx + old_mouse_x) * 0.5;
472 in_mouse_y = (my + old_mouse_y) * 0.5;
477 // if not in menu, apply mouse move to viewangles/movement
478 if (!cl.csqc_wantsmousemove && in_client_mouse)
480 if (cl_prydoncursor.integer)
482 // mouse interacting with the scene, mostly stationary view
484 cl.cmd.cursor_screen[0] += in_mouse_x * sensitivity.value / vid.width;
485 cl.cmd.cursor_screen[1] += in_mouse_y * sensitivity.value / vid.height;
487 else if (in_strafe.state & 1)
489 // strafing mode, all looking is movement
491 cl.cmd.sidemove += m_side.value * in_mouse_x * sensitivity.value;
492 if (noclip_anglehack)
493 cl.cmd.upmove -= m_forward.value * in_mouse_y * sensitivity.value;
495 cl.cmd.forwardmove -= m_forward.value * in_mouse_y * sensitivity.value;
497 else if ((in_mlook.state & 1) || freelook.integer)
499 // mouselook, lookstrafe causes turning to become strafing
501 if (lookstrafe.integer)
502 cl.cmd.sidemove += m_side.value * in_mouse_x * sensitivity.value;
504 cl.viewangles[YAW] -= m_yaw.value * in_mouse_x * sensitivity.value * cl.viewzoom;
505 cl.viewangles[PITCH] += m_pitch.value * in_mouse_y * sensitivity.value * cl.viewzoom;
509 // non-mouselook, yaw turning and forward/back movement
510 cl.viewangles[YAW] -= m_yaw.value * in_mouse_x * sensitivity.value * cl.viewzoom;
511 cl.cmd.forwardmove -= m_forward.value * in_mouse_y * sensitivity.value;
515 // clamp after the move to prevent rendering with bad angles
519 #include "cl_collision.h"
521 void CL_UpdatePrydonCursor(void)
525 if (!cl_prydoncursor.integer)
526 VectorClear(cl.cmd.cursor_screen);
529 if (cl.cmd.cursor_screen[0] < -1)
531 cl.viewangles[YAW] -= m_yaw.value * (cl.cmd.cursor_screen[0] - -1) * vid.width * sensitivity.value * cl.viewzoom;
532 cl.cmd.cursor_screen[0] = -1;
534 if (cl.cmd.cursor_screen[0] > 1)
536 cl.viewangles[YAW] -= m_yaw.value * (cl.cmd.cursor_screen[0] - 1) * vid.width * sensitivity.value * cl.viewzoom;
537 cl.cmd.cursor_screen[0] = 1;
539 if (cl.cmd.cursor_screen[1] < -1)
541 cl.viewangles[PITCH] += m_pitch.value * (cl.cmd.cursor_screen[1] - -1) * vid.height * sensitivity.value * cl.viewzoom;
542 cl.cmd.cursor_screen[1] = -1;
544 if (cl.cmd.cursor_screen[1] > 1)
546 cl.viewangles[PITCH] += m_pitch.value * (cl.cmd.cursor_screen[1] - 1) * vid.height * sensitivity.value * cl.viewzoom;
547 cl.cmd.cursor_screen[1] = 1;
550 cl.cmd.cursor_screen[0] = bound(-1, cl.cmd.cursor_screen[0], 1);
551 cl.cmd.cursor_screen[1] = bound(-1, cl.cmd.cursor_screen[1], 1);
552 cl.cmd.cursor_screen[2] = 1;
554 // calculate current view matrix
555 Matrix4x4_OriginFromMatrix(&r_view.matrix, cl.cmd.cursor_start);
556 // calculate direction vector of cursor in viewspace by using frustum slopes
557 VectorSet(temp, cl.cmd.cursor_screen[2] * 1000000, cl.cmd.cursor_screen[0] * -r_view.frustum_x * 1000000, cl.cmd.cursor_screen[1] * -r_view.frustum_y * 1000000);
558 Matrix4x4_Transform(&r_view.matrix, temp, cl.cmd.cursor_end);
559 // trace from view origin to the cursor
560 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);
563 void CL_ClientMovement_InputQW(void)
567 // if time has not advanced, do nothing
568 if (cl.movecmd[0].time <= cl.movecmd[1].time)
570 // remove stale queue items
571 n = cl.movement_numqueue;
572 cl.movement_numqueue = 0;
573 for (i = 0;i < n;i++)
575 if (cl.movement_queue[i].sequence > cls.netcon->qw.incoming_sequence)
576 cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
578 cl.movement_replay_canjump = !cl.movement_queue[i].jump; // FIXME: this logic is quite broken
580 // add to input queue if there is room
581 if (cl.movement_numqueue < (int)(sizeof(cl.movement_queue)/sizeof(cl.movement_queue[0])))
583 // add to input queue
584 cl.movement_queue[cl.movement_numqueue].sequence = cls.netcon->qw.outgoing_sequence;
585 cl.movement_queue[cl.movement_numqueue].time = cl.movecmd[0].time;
586 cl.movement_queue[cl.movement_numqueue].frametime = cl.cmd.msec / 1000.0;
587 VectorCopy(cl.cmd.viewangles, cl.movement_queue[cl.movement_numqueue].viewangles);
588 cl.movement_queue[cl.movement_numqueue].move[0] = cl.cmd.forwardmove;
589 cl.movement_queue[cl.movement_numqueue].move[1] = cl.cmd.sidemove;
590 cl.movement_queue[cl.movement_numqueue].move[2] = cl.cmd.upmove;
591 cl.movement_queue[cl.movement_numqueue].jump = (cl.cmd.buttons & 2) != 0;
592 cl.movement_queue[cl.movement_numqueue].crouch = false;
593 cl.movement_numqueue++;
596 cl.movement_replay = true;
599 void CL_ClientMovement_Input(qboolean buttonjump, qboolean buttoncrouch)
603 // if time has not advanced, do nothing
604 if (cl.movecmd[0].time <= cl.movecmd[1].time)
606 // remove stale queue items
607 n = cl.movement_numqueue;
608 cl.movement_numqueue = 0;
609 if (cls.servermovesequence)
611 for (i = 0;i < n;i++)
613 if (cl.movement_queue[i].sequence > cls.servermovesequence)
614 cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
616 cl.movement_replay_canjump = !cl.movement_queue[i].jump; // FIXME: this logic is quite broken
621 for (i = 0;i < n;i++)
623 if (cl.movement_queue[i].time >= cl.movecmd[0].time - cl_movement_latency.value / 1000.0 && cl.movement_queue[i].time <= cl.movecmd[0].time)
624 cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
626 cl.movement_replay_canjump = !cl.movement_queue[i].jump; // FIXME: this logic is quite broken
629 // add to input queue if there is room
630 if (cl.movement_numqueue < (int)(sizeof(cl.movement_queue)/sizeof(cl.movement_queue[0])))
632 // add to input queue
633 cl.movement_queue[cl.movement_numqueue].sequence = cls.movesequence;
634 cl.movement_queue[cl.movement_numqueue].time = cl.movecmd[0].time;
635 cl.movement_queue[cl.movement_numqueue].frametime = bound(0, cl.movecmd[0].time - cl.movecmd[1].time, 0.1);
636 VectorCopy(cl.viewangles, cl.movement_queue[cl.movement_numqueue].viewangles);
637 cl.movement_queue[cl.movement_numqueue].move[0] = cl.cmd.forwardmove;
638 cl.movement_queue[cl.movement_numqueue].move[1] = cl.cmd.sidemove;
639 cl.movement_queue[cl.movement_numqueue].move[2] = cl.cmd.upmove;
640 cl.movement_queue[cl.movement_numqueue].jump = buttonjump;
641 cl.movement_queue[cl.movement_numqueue].crouch = buttoncrouch;
642 cl.movement_numqueue++;
645 cl.movement_replay = true;
648 typedef enum waterlevel_e
657 typedef struct cl_clientmovement_state_s
662 // current bounding box (different if crouched vs standing)
665 // currently on the ground
667 // currently crouching
669 // whether jump button has been released since last jump
671 // what kind of water (SUPERCONTENTS_LAVA for instance)
674 waterlevel_t waterlevel;
675 // weird hacks when jumping out of water
676 // (this is in seconds and counts down to 0)
679 // movement parameters for physics code
680 float movevars_gravity;
681 float movevars_stopspeed;
682 float movevars_maxspeed;
683 float movevars_spectatormaxspeed;
684 float movevars_accelerate;
685 float movevars_airaccelerate;
686 float movevars_wateraccelerate;
687 float movevars_friction;
688 float movevars_waterfriction;
689 float movevars_entgravity;
690 float movevars_jumpvelocity;
691 float movevars_edgefriction;
692 float movevars_maxairspeed;
693 float movevars_stepheight;
694 float movevars_airaccel_qw;
695 float movevars_airaccel_sideways_friction;
698 client_movementqueue_t q;
700 cl_clientmovement_state_t;
702 #define NUMOFFSETS 27
703 static vec3_t offsets[NUMOFFSETS] =
705 // 1 no nudge (just return the original if this test passes)
706 { 0.000, 0.000, 0.000},
708 { 0.000, 0.000, 0.125}, { 0.000, 0.000, -0.125},
709 {-0.125, 0.000, 0.000}, { 0.125, 0.000, 0.000},
710 { 0.000, -0.125, 0.000}, { 0.000, 0.125, 0.000},
711 // 4 diagonal flat nudges
712 {-0.125, -0.125, 0.000}, { 0.125, -0.125, 0.000},
713 {-0.125, 0.125, 0.000}, { 0.125, 0.125, 0.000},
714 // 8 diagonal upward nudges
715 {-0.125, 0.000, 0.125}, { 0.125, 0.000, 0.125},
716 { 0.000, -0.125, 0.125}, { 0.000, 0.125, 0.125},
717 {-0.125, -0.125, 0.125}, { 0.125, -0.125, 0.125},
718 {-0.125, 0.125, 0.125}, { 0.125, 0.125, 0.125},
719 // 8 diagonal downward nudges
720 {-0.125, 0.000, -0.125}, { 0.125, 0.000, -0.125},
721 { 0.000, -0.125, -0.125}, { 0.000, 0.125, -0.125},
722 {-0.125, -0.125, -0.125}, { 0.125, -0.125, -0.125},
723 {-0.125, 0.125, -0.125}, { 0.125, 0.125, -0.125},
726 qboolean CL_ClientMovement_Unstick(cl_clientmovement_state_t *s)
730 for (i = 0;i < NUMOFFSETS;i++)
732 VectorAdd(offsets[i], s->origin, neworigin);
733 if (!CL_Move(neworigin, cl.playercrouchmins, cl.playercrouchmaxs, neworigin, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true, true, NULL, false).startsolid)
735 VectorCopy(neworigin, s->origin);
739 // if all offsets failed, give up
743 void CL_ClientMovement_UpdateStatus(cl_clientmovement_state_t *s)
745 vec3_t origin1, origin2;
748 // make sure player is not stuck
749 CL_ClientMovement_Unstick(s);
754 // wants to crouch, this always works..
760 // wants to stand, if currently crouching we need to check for a
764 trace = CL_Move(s->origin, cl.playerstandmins, cl.playerstandmaxs, s->origin, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true, true, NULL, false);
765 if (!trace.startsolid)
771 VectorCopy(cl.playercrouchmins, s->mins);
772 VectorCopy(cl.playercrouchmaxs, s->maxs);
776 VectorCopy(cl.playerstandmins, s->mins);
777 VectorCopy(cl.playerstandmaxs, s->maxs);
781 VectorSet(origin1, s->origin[0], s->origin[1], s->origin[2] + 1);
782 VectorSet(origin2, s->origin[0], s->origin[1], s->origin[2] - 2);
783 trace = CL_Move(origin1, s->mins, s->maxs, origin2, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true, true, NULL, false);
784 s->onground = trace.fraction < 1 && trace.plane.normal[2] > 0.7;
786 // set watertype/waterlevel
787 VectorSet(origin1, s->origin[0], s->origin[1], s->origin[2] + s->mins[2] + 1);
788 s->waterlevel = WATERLEVEL_NONE;
789 s->watertype = CL_Move(origin1, vec3_origin, vec3_origin, origin1, MOVE_NOMONSTERS, NULL, 0, true, false, NULL, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK;
792 s->waterlevel = WATERLEVEL_WETFEET;
793 origin1[2] = s->origin[2] + (s->mins[2] + s->maxs[2]) * 0.5f;
794 if (CL_Move(origin1, vec3_origin, vec3_origin, origin1, MOVE_NOMONSTERS, NULL, 0, true, false, NULL, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK)
796 s->waterlevel = WATERLEVEL_SWIMMING;
797 origin1[2] = s->origin[2] + 22;
798 if (CL_Move(origin1, vec3_origin, vec3_origin, origin1, MOVE_NOMONSTERS, NULL, 0, true, false, NULL, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK)
799 s->waterlevel = WATERLEVEL_SUBMERGED;
803 // water jump prediction
804 if (s->onground || s->velocity[2] <= 0 || s->waterjumptime <= 0)
805 s->waterjumptime = 0;
808 void CL_ClientMovement_Move(cl_clientmovement_state_t *s)
814 vec3_t currentorigin2;
816 vec3_t primalvelocity;
820 CL_ClientMovement_UpdateStatus(s);
821 VectorCopy(s->velocity, primalvelocity);
822 for (bump = 0, t = s->q.frametime;bump < 8 && VectorLength2(s->velocity) > 0;bump++)
824 VectorMA(s->origin, t, s->velocity, neworigin);
825 trace = CL_Move(s->origin, s->mins, s->maxs, neworigin, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true, true, NULL, false);
826 if (trace.fraction < 1 && trace.plane.normal[2] == 0)
828 // may be a step or wall, try stepping up
829 // first move forward at a higher level
830 VectorSet(currentorigin2, s->origin[0], s->origin[1], s->origin[2] + s->movevars_stepheight);
831 VectorSet(neworigin2, neworigin[0], neworigin[1], s->origin[2] + s->movevars_stepheight);
832 trace2 = CL_Move(currentorigin2, s->mins, s->maxs, neworigin2, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true, true, NULL, false);
833 if (!trace2.startsolid)
835 // then move down from there
836 VectorCopy(trace2.endpos, currentorigin2);
837 VectorSet(neworigin2, trace2.endpos[0], trace2.endpos[1], s->origin[2]);
838 trace3 = CL_Move(currentorigin2, s->mins, s->maxs, neworigin2, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true, true, NULL, false);
839 //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]);
840 // accept the new trace if it made some progress
841 if (fabs(trace3.endpos[0] - trace.endpos[0]) >= 0.03125 || fabs(trace3.endpos[1] - trace.endpos[1]) >= 0.03125)
844 VectorCopy(trace3.endpos, trace.endpos);
849 // check if it moved at all
850 if (trace.fraction >= 0.001)
851 VectorCopy(trace.endpos, s->origin);
853 // check if it moved all the way
854 if (trace.fraction == 1)
857 //if (trace.plane.normal[2] > 0.7)
858 // s->onground = true;
860 t -= t * trace.fraction;
862 f = DotProduct(s->velocity, trace.plane.normal);
863 VectorMA(s->velocity, -f, trace.plane.normal, s->velocity);
865 if (s->waterjumptime > 0)
866 VectorCopy(primalvelocity, s->velocity);
870 void CL_ClientMovement_Physics_Swim(cl_clientmovement_state_t *s)
877 // water jump only in certain situations
878 // this mimics quakeworld code
879 if (s->q.jump && s->waterlevel == 2 && s->velocity[2] >= -180)
884 VectorSet(yawangles, 0, s->q.viewangles[1], 0);
885 AngleVectors(yawangles, forward, NULL, NULL);
886 VectorMA(s->origin, 24, forward, spot);
888 if (CL_Move(spot, vec3_origin, vec3_origin, spot, MOVE_NOMONSTERS, NULL, 0, true, false, NULL, false).startsolid)
891 if (!CL_Move(spot, vec3_origin, vec3_origin, spot, MOVE_NOMONSTERS, NULL, 0, true, false, NULL, false).startsolid)
893 VectorScale(forward, 50, s->velocity);
894 s->velocity[2] = 310;
895 s->waterjumptime = 2;
902 if (!VectorLength2(s->q.move))
904 // drift towards bottom
905 VectorSet(wishvel, 0, 0, -60);
913 // calculate movement vector
914 AngleVectors(s->q.viewangles, forward, right, up);
915 VectorSet(up, 0, 0, 1);
916 VectorMAMAM(s->q.move[0], forward, s->q.move[1], right, s->q.move[2], up, wishvel);
919 // split wishvel into wishspeed and wishdir
920 wishspeed = VectorLength(wishvel);
922 VectorScale(wishvel, 1 / wishspeed, wishdir);
924 VectorSet( wishdir, 0.0, 0.0, 0.0 );
925 wishspeed = min(wishspeed, s->movevars_maxspeed) * 0.7;
930 if (s->waterjumptime <= 0)
933 f = 1 - s->q.frametime * s->movevars_waterfriction * s->waterlevel;
935 VectorScale(s->velocity, f, s->velocity);
937 // water acceleration
938 f = wishspeed - DotProduct(s->velocity, wishdir);
941 f = min(s->movevars_wateraccelerate * s->q.frametime * wishspeed, f);
942 VectorMA(s->velocity, f, wishdir, s->velocity);
945 // holding jump button swims upward slowly
948 if (s->watertype & SUPERCONTENTS_LAVA)
950 else if (s->watertype & SUPERCONTENTS_SLIME)
954 if (gamemode == GAME_NEXUIZ)
955 s->velocity[2] = 200;
957 s->velocity[2] = 100;
962 CL_ClientMovement_Move(s);
965 void CL_ClientMovement_Physics_Walk(cl_clientmovement_state_t *s)
980 // jump if on ground with jump button pressed but only if it has been
981 // released at least once since the last jump
982 if (s->q.jump && s->onground)// && s->canjump) // FIXME: canjump doesn't work properly
984 s->velocity[2] += s->movevars_jumpvelocity;
989 // calculate movement vector
990 VectorSet(yawangles, 0, s->q.viewangles[1], 0);
991 AngleVectors(yawangles, forward, right, up);
992 VectorMAM(s->q.move[0], forward, s->q.move[1], right, wishvel);
994 // split wishvel into wishspeed and wishdir
995 wishspeed = VectorLength(wishvel);
997 VectorScale(wishvel, 1 / wishspeed, wishdir);
999 VectorSet( wishdir, 0.0, 0.0, 0.0 );
1000 wishspeed = min(wishspeed, s->movevars_maxspeed);
1004 // check if onground
1007 // apply edge friction
1008 f = sqrt(s->velocity[0] * s->velocity[0] + s->velocity[1] * s->velocity[1]);
1009 friction = s->movevars_friction;
1010 if (f > 0 && s->movevars_edgefriction != 1)
1014 // note: QW uses the full player box for the trace, and yet still
1015 // uses s->origin[2] + s->mins[2], which is clearly an bug, but
1016 // this mimics it for compatibility
1017 VectorSet(neworigin2, s->origin[0] + s->velocity[0]*(16/f), s->origin[1] + s->velocity[1]*(16/f), s->origin[2] + s->mins[2]);
1018 VectorSet(neworigin3, neworigin2[0], neworigin2[1], neworigin2[2] - 34);
1019 if (cls.protocol == PROTOCOL_QUAKEWORLD)
1020 trace = CL_Move(neworigin2, s->mins, s->maxs, neworigin3, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true, true, NULL, false);
1022 trace = CL_Move(neworigin2, vec3_origin, vec3_origin, neworigin3, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true, true, NULL, false);
1023 if (trace.fraction == 1 && !trace.startsolid)
1024 friction *= s->movevars_edgefriction;
1026 // apply ground friction
1027 f = 1 - s->q.frametime * friction * ((f < s->movevars_stopspeed) ? (s->movevars_stopspeed / f) : 1);
1029 VectorScale(s->velocity, f, s->velocity);
1030 addspeed = wishspeed - DotProduct(s->velocity, wishdir);
1033 accelspeed = min(s->movevars_accelerate * s->q.frametime * wishspeed, addspeed);
1034 VectorMA(s->velocity, accelspeed, wishdir, s->velocity);
1036 s->velocity[2] -= cl_gravity.value * s->q.frametime;
1037 if (cls.protocol == PROTOCOL_QUAKEWORLD)
1039 if (VectorLength2(s->velocity))
1040 CL_ClientMovement_Move(s);
1044 if (s->waterjumptime <= 0)
1051 // apply air speed limit
1052 wishspeed = min(wishspeed, s->movevars_maxairspeed);
1055 addspeed = wishspeed - DotProduct(s->velocity, wishdir);
1058 accelspeed = min(s->movevars_accelerate * s->q.frametime * wishspeed, addspeed);
1059 VectorMA(s->velocity, accelspeed, wishdir, s->velocity);
1063 vel_straight = DotProduct(s->velocity, wishdir);
1064 vel_z = s->velocity[2];
1065 VectorMA(s->velocity, -vel_straight, wishdir, vel_perpend);
1066 vel_perpend[2] -= vel_z;
1068 f = wishspeed - vel_straight;
1070 vel_straight += min(f, s->movevars_accelerate * s->q.frametime * wishspeed) * s->movevars_airaccel_qw;
1072 vel_straight += min(wishspeed, s->movevars_accelerate * s->q.frametime * wishspeed) * (1 - s->movevars_airaccel_qw);
1074 VectorM(1 - (s->q.frametime * (wishspeed / s->movevars_maxairspeed) * s->movevars_airaccel_sideways_friction), vel_perpend, vel_perpend);
1076 VectorMA(vel_perpend, vel_straight, wishdir, s->velocity);
1077 s->velocity[2] += vel_z;
1079 s->velocity[2] -= cl_gravity.value * s->q.frametime;
1080 CL_ClientMovement_Move(s);
1084 void CL_ClientMovement_PlayerMove(cl_clientmovement_state_t *s)
1086 //Con_Printf(" %f", frametime);
1089 s->waterjumptime -= s->q.frametime;
1090 CL_ClientMovement_UpdateStatus(s);
1091 if (s->waterlevel >= WATERLEVEL_SWIMMING)
1092 CL_ClientMovement_Physics_Swim(s);
1094 CL_ClientMovement_Physics_Walk(s);
1097 void CL_ClientMovement_Replay(void)
1100 cl_clientmovement_state_t s;
1102 // set up starting state for the series of moves
1103 memset(&s, 0, sizeof(s));
1104 VectorCopy(cl.entities[cl.playerentity].state_current.origin, s.origin);
1105 VectorCopy(cl.mvelocity[0], s.velocity);
1106 s.crouched = true; // will be updated on first move
1107 s.canjump = cl.movement_replay_canjump;
1108 //Con_Printf("movement replay starting org %f %f %f vel %f %f %f\n", s.origin[0], s.origin[1], s.origin[2], s.velocity[0], s.velocity[1], s.velocity[2]);
1110 // set up movement variables
1111 if (cls.protocol == PROTOCOL_QUAKEWORLD)
1113 s.movevars_gravity = cl.qw_movevars_gravity;
1114 s.movevars_stopspeed = cl.qw_movevars_stopspeed;
1115 s.movevars_maxspeed = cl.qw_movevars_maxspeed;
1116 s.movevars_spectatormaxspeed = cl.qw_movevars_spectatormaxspeed;
1117 s.movevars_accelerate = cl.qw_movevars_accelerate;
1118 s.movevars_airaccelerate = cl.qw_movevars_airaccelerate;
1119 s.movevars_wateraccelerate = cl.qw_movevars_wateraccelerate;
1120 s.movevars_friction = cl.qw_movevars_friction;
1121 s.movevars_waterfriction = cl.qw_movevars_waterfriction;
1122 s.movevars_entgravity = cl.qw_movevars_entgravity;
1123 s.movevars_jumpvelocity = cl_movement_jumpvelocity.value;
1124 s.movevars_edgefriction = cl_movement_edgefriction.value;
1125 s.movevars_maxairspeed = cl_movement_maxairspeed.value;
1126 s.movevars_stepheight = cl_movement_stepheight.value;
1127 s.movevars_airaccel_qw = 1.0;
1128 s.movevars_airaccel_sideways_friction = 0.0;
1132 s.movevars_gravity = sv_gravity.value;
1133 s.movevars_stopspeed = cl_movement_stopspeed.value;
1134 s.movevars_maxspeed = cl_movement_maxspeed.value;
1135 s.movevars_spectatormaxspeed = cl_movement_maxspeed.value;
1136 s.movevars_accelerate = cl_movement_accelerate.value;
1137 s.movevars_airaccelerate = cl_movement_airaccelerate.value < 0 ? cl_movement_accelerate.value : cl_movement_airaccelerate.value;
1138 s.movevars_wateraccelerate = cl_movement_wateraccelerate.value < 0 ? cl_movement_accelerate.value : cl_movement_wateraccelerate.value;
1139 s.movevars_friction = cl_movement_friction.value;
1140 s.movevars_waterfriction = cl_movement_waterfriction.value < 0 ? cl_movement_friction.value : cl_movement_waterfriction.value;
1141 s.movevars_entgravity = 1;
1142 s.movevars_jumpvelocity = cl_movement_jumpvelocity.value;
1143 s.movevars_edgefriction = cl_movement_edgefriction.value;
1144 s.movevars_maxairspeed = cl_movement_maxairspeed.value;
1145 s.movevars_stepheight = cl_movement_stepheight.value;
1146 s.movevars_airaccel_qw = cl_movement_airaccel_qw.value;
1147 s.movevars_airaccel_sideways_friction = cl_movement_airaccel_sideways_friction.value;
1150 cl.movement_predicted = (cl_movement.integer && !cls.demoplayback && cls.signon == SIGNONS && cl.stats[STAT_HEALTH] > 0 && !cl.intermission) && ((cls.protocol != PROTOCOL_DARKPLACES6 && cls.protocol != PROTOCOL_DARKPLACES7) || cls.servermovesequence);
1151 if (cl.movement_predicted)
1153 //Con_Printf("%f: ", cl.movecmd[0].time);
1155 // replay the input queue to predict current location
1156 // note: this relies on the fact there's always one queue item at the end
1158 for (i = 0;i < cl.movement_numqueue;i++)
1160 s.q = cl.movement_queue[i];
1161 // if a move is more than 50ms, do it as two moves (matching qwsv)
1162 if (s.q.frametime > 0.05)
1164 s.q.frametime *= 0.5;
1165 CL_ClientMovement_PlayerMove(&s);
1167 CL_ClientMovement_PlayerMove(&s);
1172 // get the first movement queue entry to know whether to crouch and such
1173 s.q = cl.movement_queue[0];
1175 CL_ClientMovement_UpdateStatus(&s);
1177 if (cl.movement_replay)
1179 cl.movement_replay = false;
1180 // update interpolation timestamps if time has passed
1181 if (cl.movecmd[0].time != cl.movecmd[1].time)
1183 cl.movement_time[1] = cl.movecmd[1].time;
1184 cl.movement_time[0] = cl.movecmd[0].time;
1185 cl.movement_time[2] = cl.time;
1186 VectorCopy(cl.movement_origin, cl.movement_oldorigin);
1187 //VectorCopy(s.origin, cl.entities[cl.playerentity].state_current.origin);
1188 //VectorSet(cl.entities[cl.playerentity].state_current.angles, 0, cl.viewangles[1], 0);
1191 // update the interpolation target position and velocity
1192 VectorCopy(s.origin, cl.movement_origin);
1193 VectorCopy(s.velocity, cl.movement_velocity);
1196 // update the onground flag if appropriate
1197 if (cl.movement_predicted)
1199 // when predicted we simply set the flag according to the UpdateStatus
1200 cl.onground = s.onground;
1204 // when not predicted, cl.onground is cleared by cl_parse.c each time
1205 // an update packet is received, but can be forced on here to hide
1206 // server inconsistencies in the onground flag
1207 // (which mostly occur when stepping up stairs at very high framerates
1208 // where after the step up the move continues forward and not
1209 // downward so the ground is not detected)
1211 // such onground inconsistencies can cause jittery gun bobbing and
1212 // stair smoothing, so we set onground if UpdateStatus says so
1217 // react to onground state changes (for gun bob)
1220 if (!cl.oldonground)
1221 cl.hitgroundtime = cl.movecmd[0].time;
1222 cl.lastongroundtime = cl.movecmd[0].time;
1224 cl.oldonground = cl.onground;
1227 void QW_MSG_WriteDeltaUsercmd(sizebuf_t *buf, usercmd_t *from, usercmd_t *to)
1232 if (to->viewangles[0] != from->viewangles[0])
1233 bits |= QW_CM_ANGLE1;
1234 if (to->viewangles[1] != from->viewangles[1])
1235 bits |= QW_CM_ANGLE2;
1236 if (to->viewangles[2] != from->viewangles[2])
1237 bits |= QW_CM_ANGLE3;
1238 if (to->forwardmove != from->forwardmove)
1239 bits |= QW_CM_FORWARD;
1240 if (to->sidemove != from->sidemove)
1242 if (to->upmove != from->upmove)
1244 if (to->buttons != from->buttons)
1245 bits |= QW_CM_BUTTONS;
1246 if (to->impulse != from->impulse)
1247 bits |= QW_CM_IMPULSE;
1249 MSG_WriteByte(buf, bits);
1250 if (bits & QW_CM_ANGLE1)
1251 MSG_WriteAngle16i(buf, to->viewangles[0]);
1252 if (bits & QW_CM_ANGLE2)
1253 MSG_WriteAngle16i(buf, to->viewangles[1]);
1254 if (bits & QW_CM_ANGLE3)
1255 MSG_WriteAngle16i(buf, to->viewangles[2]);
1256 if (bits & QW_CM_FORWARD)
1257 MSG_WriteShort(buf, to->forwardmove);
1258 if (bits & QW_CM_SIDE)
1259 MSG_WriteShort(buf, to->sidemove);
1260 if (bits & QW_CM_UP)
1261 MSG_WriteShort(buf, to->upmove);
1262 if (bits & QW_CM_BUTTONS)
1263 MSG_WriteByte(buf, to->buttons);
1264 if (bits & QW_CM_IMPULSE)
1265 MSG_WriteByte(buf, to->impulse);
1266 MSG_WriteByte(buf, to->msec);
1274 usercmd_t nullcmd; // for delta compression of qw moves
1275 void CL_SendMove(void)
1277 int i, j, packetloss, maxusercmds;
1280 unsigned char data[1024];
1281 static double lastsendtime = 0;
1284 static double oldmsectime;
1286 // if playing a demo, do nothing
1290 // don't send too often or else network connections can get clogged by a high renderer framerate
1291 packettime = 1.0 / bound(10, cl_netinputpacketspersecond.value, 100);
1292 // quakeworld servers take only frametimes
1293 // predicted dp7 servers take current interpolation time
1294 // unpredicted servers take an echo of the latest server timestamp
1295 if (cls.protocol == PROTOCOL_QUAKEWORLD)
1297 if (realtime < lastsendtime + packettime)
1299 cl.cmd.time = realtime;
1301 else if (cl.movement_predicted)
1303 if (realtime < lastsendtime + packettime)
1305 cl.cmd.time = cl.time;
1309 // unpredicted movement should be sent immediately whenever a server
1310 // packet is received, to minimize ping times
1311 if (!cl.movement_needupdate && realtime < lastsendtime + packettime)
1313 cl.cmd.time = cl.mtime[0];
1315 // don't let it fall behind if CL_SendMove hasn't been called recently
1316 // (such is the case when framerate is too low for instance)
1317 lastsendtime = bound(realtime, lastsendtime + packettime, realtime + packettime);
1318 // set the flag indicating that we sent a packet recently
1319 cl.movement_needupdate = false;
1322 buf.maxsize = sizeof(data);
1326 // conditions for sending a move:
1327 // if the move advances time or if the game is paused (in which case time
1328 // is not advancing)
1329 if ((cl.cmd.time > cl.movecmd[0].time || cl.mtime[0] <= cl.mtime[1]) && cls.signon == SIGNONS)
1331 // send the movement message
1332 // PROTOCOL_QUAKE clc_move = 16 bytes total
1333 // PROTOCOL_QUAKEDP clc_move = 16 bytes total
1334 // PROTOCOL_NEHAHRAMOVIE clc_move = 16 bytes total
1335 // PROTOCOL_DARKPLACES1 clc_move = 19 bytes total
1336 // PROTOCOL_DARKPLACES2 clc_move = 25 bytes total
1337 // PROTOCOL_DARKPLACES3 clc_move = 25 bytes total
1338 // PROTOCOL_DARKPLACES4 clc_move = 19 bytes total
1339 // PROTOCOL_DARKPLACES5 clc_move = 19 bytes total
1340 // PROTOCOL_DARKPLACES6 clc_move = 52 bytes total
1341 // PROTOCOL_DARKPLACES7 clc_move = 56 bytes total per move (can be up to 16 moves)
1342 // PROTOCOL_QUAKEWORLD clc_move = 34 bytes total (typically, but can reach 43 bytes, or even 49 bytes with roll)
1345 // LordHavoc: added 6 new buttons and use and chat buttons, and prydon cursor active button
1347 if (in_attack.state & 3) bits |= 1;in_attack.state &= ~2;
1348 if (in_jump.state & 3) bits |= 2;in_jump.state &= ~2;
1349 if (in_button3.state & 3) bits |= 4;in_button3.state &= ~2;
1350 if (in_button4.state & 3) bits |= 8;in_button4.state &= ~2;
1351 if (in_button5.state & 3) bits |= 16;in_button5.state &= ~2;
1352 if (in_button6.state & 3) bits |= 32;in_button6.state &= ~2;
1353 if (in_button7.state & 3) bits |= 64;in_button7.state &= ~2;
1354 if (in_button8.state & 3) bits |= 128;in_button8.state &= ~2;
1355 if (in_use.state & 3) bits |= 256;in_use.state &= ~2;
1356 if (key_dest != key_game || key_consoleactive) bits |= 512;
1357 if (cl_prydoncursor.integer) bits |= 1024;
1358 if (in_button9.state & 3) bits |= 2048;in_button9.state &= ~2;
1359 if (in_button10.state & 3) bits |= 4096;in_button10.state &= ~2;
1360 if (in_button11.state & 3) bits |= 8192;in_button11.state &= ~2;
1361 if (in_button12.state & 3) bits |= 16384;in_button12.state &= ~2;
1362 if (in_button13.state & 3) bits |= 32768;in_button13.state &= ~2;
1363 if (in_button14.state & 3) bits |= 65536;in_button14.state &= ~2;
1364 if (in_button15.state & 3) bits |= 131072;in_button15.state &= ~2;
1365 if (in_button16.state & 3) bits |= 262144;in_button16.state &= ~2;
1366 // button bits 19-31 unused currently
1367 // rotate/zoom view serverside if PRYDON_CLIENTCURSOR cursor is at edge of screen
1368 if (cl.cmd.cursor_screen[0] <= -1) bits |= 8;
1369 if (cl.cmd.cursor_screen[0] >= 1) bits |= 16;
1370 if (cl.cmd.cursor_screen[1] <= -1) bits |= 32;
1371 if (cl.cmd.cursor_screen[1] >= 1) bits |= 64;
1372 cl.cmd.buttons = bits;
1375 cl.cmd.impulse = in_impulse;
1378 // movement is set by input code (forwardmove/sidemove/upmove)
1381 VectorCopy(cl.viewangles, cl.cmd.viewangles);
1383 msectime = floor(cl.cmd.time * 1000);
1384 cl.cmd.msec = (unsigned char)bound(0, msectime - oldmsectime, 255);
1385 // ridiculous value rejection (matches qw)
1386 if (cl.cmd.msec > 250)
1388 oldmsectime = msectime;
1391 if (cl_movement.integer)
1392 cl.cmd.sequence = cls.movesequence;
1394 cl.cmd.sequence = 0;
1396 // set prydon cursor info
1397 CL_UpdatePrydonCursor();
1399 // always dump the first two messages, because they may contain leftover inputs from the last level
1400 if (cls.movesequence > 2)
1402 // update the cl.movecmd array which holds the most recent moves
1403 for (i = CL_MAX_USERCMDS - 1;i >= 1;i--)
1404 cl.movecmd[i] = cl.movecmd[i-1];
1405 cl.movecmd[0] = cl.cmd;
1407 // set the maxusercmds variable to limit how many should be sent
1408 if (cls.protocol == PROTOCOL_QUAKEWORLD)
1410 // qw uses exactly 3 moves
1415 // configurable number of unacknowledged moves
1416 maxusercmds = bound(1, cl_netinputpacketlosstolerance.integer + 1, CL_MAX_USERCMDS);
1417 // when movement prediction is off, there's not much point in repeating old input as it will just be ignored
1418 if (!cl.movement_predicted)
1422 if (cls.protocol == PROTOCOL_QUAKEWORLD)
1426 CL_ClientMovement_InputQW();
1428 MSG_WriteByte(&buf, qw_clc_move);
1429 // save the position for a checksum byte
1430 checksumindex = buf.cursize;
1431 MSG_WriteByte(&buf, 0);
1432 // packet loss percentage
1433 for (j = 0, packetloss = 0;j < 100;j++)
1434 packetloss += cls.netcon->packetlost[j];
1435 MSG_WriteByte(&buf, packetloss);
1436 // write most recent 3 moves
1437 QW_MSG_WriteDeltaUsercmd(&buf, &nullcmd, &cl.movecmd[2]);
1438 QW_MSG_WriteDeltaUsercmd(&buf, &cl.movecmd[2], &cl.movecmd[1]);
1439 QW_MSG_WriteDeltaUsercmd(&buf, &cl.movecmd[1], &cl.movecmd[0]);
1440 // calculate the checksum
1441 buf.data[checksumindex] = COM_BlockSequenceCRCByteQW(buf.data + checksumindex + 1, buf.cursize - checksumindex - 1, cls.netcon->qw.outgoing_sequence);
1442 // if delta compression history overflows, request no delta
1443 if (cls.netcon->qw.outgoing_sequence - cl.qw_validsequence >= QW_UPDATE_BACKUP-1)
1444 cl.qw_validsequence = 0;
1445 // request delta compression if appropriate
1446 if (cl.qw_validsequence && !cl_nodelta.integer && cls.state == ca_connected && !cls.demorecording)
1448 cl.qw_deltasequence[cls.netcon->qw.outgoing_sequence & QW_UPDATE_MASK] = cl.qw_validsequence;
1449 MSG_WriteByte(&buf, qw_clc_delta);
1450 MSG_WriteByte(&buf, cl.qw_validsequence & 255);
1453 cl.qw_deltasequence[cls.netcon->qw.outgoing_sequence & QW_UPDATE_MASK] = -1;
1455 else if (cls.protocol == PROTOCOL_QUAKE || cls.protocol == PROTOCOL_QUAKEDP || cls.protocol == PROTOCOL_NEHAHRAMOVIE)
1457 CL_ClientMovement_Input((cl.movecmd[0].buttons & 2) != 0, false);
1460 MSG_WriteByte (&buf, clc_move);
1461 MSG_WriteFloat (&buf, cl.movecmd[0].time); // last server packet time
1463 for (i = 0;i < 3;i++)
1464 MSG_WriteAngle8i (&buf, cl.movecmd[0].viewangles[i]);
1466 MSG_WriteCoord16i (&buf, cl.movecmd[0].forwardmove);
1467 MSG_WriteCoord16i (&buf, cl.movecmd[0].sidemove);
1468 MSG_WriteCoord16i (&buf, cl.movecmd[0].upmove);
1470 MSG_WriteByte (&buf, cl.movecmd[0].buttons);
1471 MSG_WriteByte (&buf, cl.movecmd[0].impulse);
1473 else if (cls.protocol == PROTOCOL_DARKPLACES2 || cls.protocol == PROTOCOL_DARKPLACES3)
1475 CL_ClientMovement_Input((cl.movecmd[0].buttons & 2) != 0, false);
1478 MSG_WriteByte (&buf, clc_move);
1479 MSG_WriteFloat (&buf, cl.movecmd[0].time); // last server packet time
1481 for (i = 0;i < 3;i++)
1482 MSG_WriteAngle32f (&buf, cl.movecmd[0].viewangles[i]);
1484 MSG_WriteCoord16i (&buf, cl.movecmd[0].forwardmove);
1485 MSG_WriteCoord16i (&buf, cl.movecmd[0].sidemove);
1486 MSG_WriteCoord16i (&buf, cl.movecmd[0].upmove);
1488 MSG_WriteByte (&buf, cl.movecmd[0].buttons);
1489 MSG_WriteByte (&buf, cl.movecmd[0].impulse);
1491 else if (cls.protocol == PROTOCOL_DARKPLACES1 || cls.protocol == PROTOCOL_DARKPLACES4 || cls.protocol == PROTOCOL_DARKPLACES5)
1493 CL_ClientMovement_Input((cl.movecmd[0].buttons & 2) != 0, false);
1496 MSG_WriteByte (&buf, clc_move);
1497 MSG_WriteFloat (&buf, cl.movecmd[0].time); // last server packet time
1499 for (i = 0;i < 3;i++)
1500 MSG_WriteAngle16i (&buf, cl.movecmd[0].viewangles[i]);
1502 MSG_WriteCoord16i (&buf, cl.movecmd[0].forwardmove);
1503 MSG_WriteCoord16i (&buf, cl.movecmd[0].sidemove);
1504 MSG_WriteCoord16i (&buf, cl.movecmd[0].upmove);
1506 MSG_WriteByte (&buf, cl.movecmd[0].buttons);
1507 MSG_WriteByte (&buf, cl.movecmd[0].impulse);
1512 // FIXME: cl.movecmd[0].buttons & 16 is +button5, Nexuiz specific
1513 CL_ClientMovement_Input((cl.movecmd[0].buttons & 2) != 0, (cl.movecmd[0].buttons & 16) != 0);
1515 // send the latest moves in order, the old ones will be
1516 // ignored by the server harmlessly, however if the previous
1517 // packets were lost these moves will be used
1519 // this reduces packet loss impact on gameplay.
1520 for (j = 0, cmd = &cl.movecmd[maxusercmds-1];j < maxusercmds;j++, cmd--)
1522 // don't repeat any stale moves
1523 if (cmd->sequence && cmd->sequence < cls.servermovesequence)
1526 MSG_WriteByte (&buf, clc_move);
1527 if (cls.protocol != PROTOCOL_DARKPLACES6)
1528 MSG_WriteLong (&buf, cmd->sequence);
1529 MSG_WriteFloat (&buf, cmd->time); // last server packet time
1531 for (i = 0;i < 3;i++)
1532 MSG_WriteAngle16i (&buf, cmd->viewangles[i]);
1534 MSG_WriteCoord16i (&buf, cmd->forwardmove);
1535 MSG_WriteCoord16i (&buf, cmd->sidemove);
1536 MSG_WriteCoord16i (&buf, cmd->upmove);
1538 MSG_WriteLong (&buf, cmd->buttons);
1539 MSG_WriteByte (&buf, cmd->impulse);
1540 // PRYDON_CLIENTCURSOR
1542 MSG_WriteShort (&buf, (short)(cmd->cursor_screen[0] * 32767.0f));
1543 MSG_WriteShort (&buf, (short)(cmd->cursor_screen[1] * 32767.0f));
1544 MSG_WriteFloat (&buf, cmd->cursor_start[0]);
1545 MSG_WriteFloat (&buf, cmd->cursor_start[1]);
1546 MSG_WriteFloat (&buf, cmd->cursor_start[2]);
1547 MSG_WriteFloat (&buf, cmd->cursor_impact[0]);
1548 MSG_WriteFloat (&buf, cmd->cursor_impact[1]);
1549 MSG_WriteFloat (&buf, cmd->cursor_impact[2]);
1550 MSG_WriteShort (&buf, cmd->cursor_entitynumber);
1556 if (cls.protocol != PROTOCOL_QUAKEWORLD)
1558 // ack the last few frame numbers
1559 // (redundent to improve handling of client->server packet loss)
1560 // for LATESTFRAMENUMS == 3 case this is 15 bytes
1561 for (i = 0;i < LATESTFRAMENUMS;i++)
1563 if (cl.latestframenums[i] > 0)
1565 if (developer_networkentities.integer >= 1)
1566 Con_Printf("send clc_ackframe %i\n", cl.latestframenums[i]);
1567 MSG_WriteByte(&buf, clc_ackframe);
1568 MSG_WriteLong(&buf, cl.latestframenums[i]);
1573 // PROTOCOL_DARKPLACES6 = 67 bytes per packet
1574 // PROTOCOL_DARKPLACES7 = 71 bytes per packet
1576 if (cls.protocol != PROTOCOL_QUAKEWORLD)
1578 // acknowledge any recently received data blocks
1579 for (i = 0;i < CL_MAX_DOWNLOADACKS && (cls.dp_downloadack[i].start || cls.dp_downloadack[i].size);i++)
1581 MSG_WriteByte(&buf, clc_ackdownloaddata);
1582 MSG_WriteLong(&buf, cls.dp_downloadack[i].start);
1583 MSG_WriteShort(&buf, cls.dp_downloadack[i].size);
1584 cls.dp_downloadack[i].start = 0;
1585 cls.dp_downloadack[i].size = 0;
1589 // send the reliable message (forwarded commands) if there is one
1590 NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol);
1592 if (cls.netcon->message.overflowed)
1594 Con_Print("CL_SendMove: lost server connection\n");
1596 Host_ShutdownServer();
1605 void CL_InitInput (void)
1607 Cmd_AddCommand ("+moveup",IN_UpDown, "swim upward");
1608 Cmd_AddCommand ("-moveup",IN_UpUp, "stop swimming upward");
1609 Cmd_AddCommand ("+movedown",IN_DownDown, "swim downward");
1610 Cmd_AddCommand ("-movedown",IN_DownUp, "stop swimming downward");
1611 Cmd_AddCommand ("+left",IN_LeftDown, "turn left");
1612 Cmd_AddCommand ("-left",IN_LeftUp, "stop turning left");
1613 Cmd_AddCommand ("+right",IN_RightDown, "turn right");
1614 Cmd_AddCommand ("-right",IN_RightUp, "stop turning right");
1615 Cmd_AddCommand ("+forward",IN_ForwardDown, "move forward");
1616 Cmd_AddCommand ("-forward",IN_ForwardUp, "stop moving forward");
1617 Cmd_AddCommand ("+back",IN_BackDown, "move backward");
1618 Cmd_AddCommand ("-back",IN_BackUp, "stop moving backward");
1619 Cmd_AddCommand ("+lookup", IN_LookupDown, "look upward");
1620 Cmd_AddCommand ("-lookup", IN_LookupUp, "stop looking upward");
1621 Cmd_AddCommand ("+lookdown", IN_LookdownDown, "look downward");
1622 Cmd_AddCommand ("-lookdown", IN_LookdownUp, "stop looking downward");
1623 Cmd_AddCommand ("+strafe", IN_StrafeDown, "activate strafing mode (move instead of turn)");
1624 Cmd_AddCommand ("-strafe", IN_StrafeUp, "deactivate strafing mode");
1625 Cmd_AddCommand ("+moveleft", IN_MoveleftDown, "strafe left");
1626 Cmd_AddCommand ("-moveleft", IN_MoveleftUp, "stop strafing left");
1627 Cmd_AddCommand ("+moveright", IN_MoverightDown, "strafe right");
1628 Cmd_AddCommand ("-moveright", IN_MoverightUp, "stop strafing right");
1629 Cmd_AddCommand ("+speed", IN_SpeedDown, "activate run mode (faster movement and turning)");
1630 Cmd_AddCommand ("-speed", IN_SpeedUp, "deactivate run mode");
1631 Cmd_AddCommand ("+attack", IN_AttackDown, "begin firing");
1632 Cmd_AddCommand ("-attack", IN_AttackUp, "stop firing");
1633 Cmd_AddCommand ("+jump", IN_JumpDown, "jump");
1634 Cmd_AddCommand ("-jump", IN_JumpUp, "end jump (so you can jump again)");
1635 Cmd_AddCommand ("impulse", IN_Impulse, "send an impulse number to server (select weapon, use item, etc)");
1636 Cmd_AddCommand ("+klook", IN_KLookDown, "activate keyboard looking mode, do not recenter view");
1637 Cmd_AddCommand ("-klook", IN_KLookUp, "deactivate keyboard looking mode");
1638 Cmd_AddCommand ("+mlook", IN_MLookDown, "activate mouse looking mode, do not recenter view");
1639 Cmd_AddCommand ("-mlook", IN_MLookUp, "deactivate mouse looking mode");
1641 // LordHavoc: added use button
1642 Cmd_AddCommand ("+use", IN_UseDown, "use something (may be used by some mods)");
1643 Cmd_AddCommand ("-use", IN_UseUp, "stop using something");
1645 // LordHavoc: added 6 new buttons
1646 Cmd_AddCommand ("+button3", IN_Button3Down, "activate button3 (behavior depends on mod)");
1647 Cmd_AddCommand ("-button3", IN_Button3Up, "deactivate button3");
1648 Cmd_AddCommand ("+button4", IN_Button4Down, "activate button4 (behavior depends on mod)");
1649 Cmd_AddCommand ("-button4", IN_Button4Up, "deactivate button4");
1650 Cmd_AddCommand ("+button5", IN_Button5Down, "activate button5 (behavior depends on mod)");
1651 Cmd_AddCommand ("-button5", IN_Button5Up, "deactivate button5");
1652 Cmd_AddCommand ("+button6", IN_Button6Down, "activate button6 (behavior depends on mod)");
1653 Cmd_AddCommand ("-button6", IN_Button6Up, "deactivate button6");
1654 Cmd_AddCommand ("+button7", IN_Button7Down, "activate button7 (behavior depends on mod)");
1655 Cmd_AddCommand ("-button7", IN_Button7Up, "deactivate button7");
1656 Cmd_AddCommand ("+button8", IN_Button8Down, "activate button8 (behavior depends on mod)");
1657 Cmd_AddCommand ("-button8", IN_Button8Up, "deactivate button8");
1658 Cmd_AddCommand ("+button9", IN_Button9Down, "activate button9 (behavior depends on mod)");
1659 Cmd_AddCommand ("-button9", IN_Button9Up, "deactivate button9");
1660 Cmd_AddCommand ("+button10", IN_Button10Down, "activate button10 (behavior depends on mod)");
1661 Cmd_AddCommand ("-button10", IN_Button10Up, "deactivate button10");
1662 Cmd_AddCommand ("+button11", IN_Button11Down, "activate button11 (behavior depends on mod)");
1663 Cmd_AddCommand ("-button11", IN_Button11Up, "deactivate button11");
1664 Cmd_AddCommand ("+button12", IN_Button12Down, "activate button12 (behavior depends on mod)");
1665 Cmd_AddCommand ("-button12", IN_Button12Up, "deactivate button12");
1666 Cmd_AddCommand ("+button13", IN_Button13Down, "activate button13 (behavior depends on mod)");
1667 Cmd_AddCommand ("-button13", IN_Button13Up, "deactivate button13");
1668 Cmd_AddCommand ("+button14", IN_Button14Down, "activate button14 (behavior depends on mod)");
1669 Cmd_AddCommand ("-button14", IN_Button14Up, "deactivate button14");
1670 Cmd_AddCommand ("+button15", IN_Button15Down, "activate button15 (behavior depends on mod)");
1671 Cmd_AddCommand ("-button15", IN_Button15Up, "deactivate button15");
1672 Cmd_AddCommand ("+button16", IN_Button16Down, "activate button16 (behavior depends on mod)");
1673 Cmd_AddCommand ("-button16", IN_Button16Up, "deactivate button16");
1675 // LordHavoc: added bestweapon command
1676 Cmd_AddCommand ("bestweapon", IN_BestWeapon, "send an impulse number to server to select the first usable weapon out of several (example: 87654321)");
1678 Cvar_RegisterVariable(&cl_movement);
1679 Cvar_RegisterVariable(&cl_movement_latency);
1680 Cvar_RegisterVariable(&cl_movement_maxspeed);
1681 Cvar_RegisterVariable(&cl_movement_maxairspeed);
1682 Cvar_RegisterVariable(&cl_movement_stopspeed);
1683 Cvar_RegisterVariable(&cl_movement_friction);
1684 Cvar_RegisterVariable(&cl_movement_edgefriction);
1685 Cvar_RegisterVariable(&cl_movement_stepheight);
1686 Cvar_RegisterVariable(&cl_movement_airaccelerate);
1687 Cvar_RegisterVariable(&cl_movement_accelerate);
1688 Cvar_RegisterVariable(&cl_movement_jumpvelocity);
1689 Cvar_RegisterVariable(&cl_movement_airaccel_qw);
1690 Cvar_RegisterVariable(&cl_movement_airaccel_sideways_friction);
1691 Cvar_RegisterVariable(&cl_gravity);
1692 Cvar_RegisterVariable(&cl_slowmo);
1694 Cvar_RegisterVariable(&in_pitch_min);
1695 Cvar_RegisterVariable(&in_pitch_max);
1696 Cvar_RegisterVariable(&m_filter);
1698 Cvar_RegisterVariable(&cl_netinputpacketspersecond);
1699 Cvar_RegisterVariable(&cl_netinputpacketlosstolerance);
1701 Cvar_RegisterVariable(&cl_nodelta);