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));}
204 Returns 0.25 if a key was pressed and released during the frame,
205 0.5 if it was pressed and held
206 0 if held then released, and
207 1.0 if held for the entire time
210 float CL_KeyState (kbutton_t *key)
213 qboolean impulsedown, impulseup, down;
215 impulsedown = key->state & 2;
216 impulseup = key->state & 4;
217 down = key->state & 1;
220 if (impulsedown && !impulseup)
223 val = 0.5; // pressed and held this frame
225 val = 0; // I_Error ();
227 if (impulseup && !impulsedown)
230 val = 0; // I_Error ();
232 val = 0; // released this frame
234 if (!impulsedown && !impulseup)
237 val = 1.0; // held the entire frame
239 val = 0; // up the entire frame
241 if (impulsedown && impulseup)
244 val = 0.75; // released and re-pressed this frame
246 val = 0.25; // pressed and released this frame
249 key->state &= 1; // clear impulses
257 //==========================================================================
259 cvar_t cl_upspeed = {CVAR_SAVE, "cl_upspeed","400","vertical movement speed (while swimming or flying)"};
260 cvar_t cl_forwardspeed = {CVAR_SAVE, "cl_forwardspeed","400","forward movement speed"};
261 cvar_t cl_backspeed = {CVAR_SAVE, "cl_backspeed","400","backward movement speed"};
262 cvar_t cl_sidespeed = {CVAR_SAVE, "cl_sidespeed","350","strafe movement speed"};
264 cvar_t cl_movespeedkey = {CVAR_SAVE, "cl_movespeedkey","2.0","how much +speed multiplies keyboard movement speed"};
266 cvar_t cl_yawspeed = {CVAR_SAVE, "cl_yawspeed","140","keyboard yaw turning speed"};
267 cvar_t cl_pitchspeed = {CVAR_SAVE, "cl_pitchspeed","150","keyboard pitch turning speed"};
269 cvar_t cl_anglespeedkey = {CVAR_SAVE, "cl_anglespeedkey","1.5","how much +speed multiplies keyboard turning speed"};
271 cvar_t cl_movement = {CVAR_SAVE, "cl_movement", "0", "enables clientside prediction of your player movement"};
272 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"};
273 cvar_t cl_movement_maxspeed = {0, "cl_movement_maxspeed", "320", "how fast you can move (should match sv_maxspeed)"};
274 cvar_t cl_movement_maxairspeed = {0, "cl_movement_maxairspeed", "30", "how fast you can move while in the air (should match sv_maxairspeed)"};
275 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)"};
276 cvar_t cl_movement_friction = {0, "cl_movement_friction", "4", "how fast you slow down (should match sv_friction)"};
277 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)"};
278 cvar_t cl_movement_stepheight = {0, "cl_movement_stepheight", "18", "how tall a step you can step in one instant (should match sv_stepheight)"};
279 cvar_t cl_movement_accelerate = {0, "cl_movement_accelerate", "10", "how fast you accelerate (should match sv_accelerate)"};
280 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)"};
281 cvar_t cl_gravity = {0, "cl_gravity", "800", "how much gravity to apply in client physics (should match sv_gravity)"};
282 cvar_t cl_slowmo = {0, "cl_slowmo", "1", "speed of game time (should match slowmo)"};
284 cvar_t in_pitch_min = {0, "in_pitch_min", "-90", "how far downward you can aim (quake used -70"}; // quake used -70
285 cvar_t in_pitch_max = {0, "in_pitch_max", "90", "how far upward you can aim (quake used 80"}; // quake used 80
287 cvar_t m_filter = {CVAR_SAVE, "m_filter","0", "smoothes mouse movement, less responsive but smoother aiming"};
289 cvar_t cl_netinputpacketspersecond = {CVAR_SAVE, "cl_netinputpacketspersecond","50", "how many input packets to send to server each second"};
291 cvar_t cl_nodelta = {0, "cl_nodelta", "0", "disables delta compression of non-player entities in QW network protocol"};
298 Moves the local angle positions
301 void CL_AdjustAngles (void)
306 if (in_speed.state & 1)
307 speed = host_realframetime * cl_anglespeedkey.value;
309 speed = host_realframetime;
311 if (!(in_strafe.state & 1))
313 cl.viewangles[YAW] -= speed*cl_yawspeed.value*CL_KeyState (&in_right);
314 cl.viewangles[YAW] += speed*cl_yawspeed.value*CL_KeyState (&in_left);
316 if (in_klook.state & 1)
319 cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * CL_KeyState (&in_forward);
320 cl.viewangles[PITCH] += speed*cl_pitchspeed.value * CL_KeyState (&in_back);
323 up = CL_KeyState (&in_lookup);
324 down = CL_KeyState(&in_lookdown);
326 cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * up;
327 cl.viewangles[PITCH] += speed*cl_pitchspeed.value * down;
332 cl.viewangles[YAW] = ANGLEMOD(cl.viewangles[YAW]);
333 cl.viewangles[PITCH] = ANGLEMOD(cl.viewangles[PITCH]);
334 cl.viewangles[ROLL] = ANGLEMOD(cl.viewangles[ROLL]);
335 if (cl.viewangles[YAW] >= 180)
336 cl.viewangles[YAW] -= 360;
337 if (cl.viewangles[PITCH] >= 180)
338 cl.viewangles[PITCH] -= 360;
339 if (cl.viewangles[ROLL] >= 180)
340 cl.viewangles[ROLL] -= 360;
342 cl.viewangles[PITCH] = bound (in_pitch_min.value, cl.viewangles[PITCH], in_pitch_max.value);
343 cl.viewangles[ROLL] = bound(-50, cl.viewangles[ROLL], 50);
346 qboolean cl_ignoremousemove = false;
352 Send the intended movement message to the server
359 static float old_mouse_x = 0, old_mouse_y = 0;
361 // clamp before the move to prevent starting with bad angles
364 // get basic movement from keyboard
365 // PRYDON_CLIENTCURSOR needs to survive basemove resets
366 VectorCopy (cl.cmd.cursor_screen, temp);
367 memset (&cl.cmd, 0, sizeof(cl.cmd));
368 VectorCopy (temp, cl.cmd.cursor_screen);
370 if (in_strafe.state & 1)
372 cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_right);
373 cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_left);
376 cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_moveright);
377 cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_moveleft);
379 cl.cmd.upmove += cl_upspeed.value * CL_KeyState (&in_up);
380 cl.cmd.upmove -= cl_upspeed.value * CL_KeyState (&in_down);
382 if (! (in_klook.state & 1) )
384 cl.cmd.forwardmove += cl_forwardspeed.value * CL_KeyState (&in_forward);
385 cl.cmd.forwardmove -= cl_backspeed.value * CL_KeyState (&in_back);
388 // adjust for speed key
389 if (in_speed.state & 1)
391 cl.cmd.forwardmove *= cl_movespeedkey.value;
392 cl.cmd.sidemove *= cl_movespeedkey.value;
393 cl.cmd.upmove *= cl_movespeedkey.value;
399 // allow mice or other external controllers to add to the move
402 // ignore a mouse move if mouse was activated/deactivated this frame
403 if (cl_ignoremousemove)
405 cl_ignoremousemove = false;
410 // apply m_filter if it is on
413 if (m_filter.integer)
415 in_mouse_x = (mx + old_mouse_x) * 0.5;
416 in_mouse_y = (my + old_mouse_y) * 0.5;
421 // if not in menu, apply mouse move to viewangles/movement
422 if (!cl.csqc_wantsmousemove && in_client_mouse)
424 if (cl_prydoncursor.integer)
426 // mouse interacting with the scene, mostly stationary view
428 cl.cmd.cursor_screen[0] += in_mouse_x * sensitivity.value / vid.width;
429 cl.cmd.cursor_screen[1] += in_mouse_y * sensitivity.value / vid.height;
431 else if (in_strafe.state & 1)
433 // strafing mode, all looking is movement
435 cl.cmd.sidemove += m_side.value * in_mouse_x * sensitivity.value;
436 if (noclip_anglehack)
437 cl.cmd.upmove -= m_forward.value * in_mouse_y * sensitivity.value;
439 cl.cmd.forwardmove -= m_forward.value * in_mouse_y * sensitivity.value;
441 else if ((in_mlook.state & 1) || freelook.integer)
443 // mouselook, lookstrafe causes turning to become strafing
445 if (lookstrafe.integer)
446 cl.cmd.sidemove += m_side.value * in_mouse_x * sensitivity.value;
448 cl.viewangles[YAW] -= m_yaw.value * in_mouse_x * sensitivity.value * cl.viewzoom;
449 cl.viewangles[PITCH] += m_pitch.value * in_mouse_y * sensitivity.value * cl.viewzoom;
453 // non-mouselook, yaw turning and forward/back movement
454 cl.viewangles[YAW] -= m_yaw.value * in_mouse_x * sensitivity.value * cl.viewzoom;
455 cl.cmd.forwardmove -= m_forward.value * in_mouse_y * sensitivity.value;
459 // clamp after the move to prevent rendering with bad angles
463 #include "cl_collision.h"
465 extern void V_CalcRefdef(void);
466 void CL_UpdatePrydonCursor(void)
470 if (!cl_prydoncursor.integer)
471 VectorClear(cl.cmd.cursor_screen);
474 if (cl.cmd.cursor_screen[0] < -1)
476 cl.viewangles[YAW] -= m_yaw.value * (cl.cmd.cursor_screen[0] - -1) * vid.width * sensitivity.value * cl.viewzoom;
477 cl.cmd.cursor_screen[0] = -1;
479 if (cl.cmd.cursor_screen[0] > 1)
481 cl.viewangles[YAW] -= m_yaw.value * (cl.cmd.cursor_screen[0] - 1) * vid.width * sensitivity.value * cl.viewzoom;
482 cl.cmd.cursor_screen[0] = 1;
484 if (cl.cmd.cursor_screen[1] < -1)
486 cl.viewangles[PITCH] += m_pitch.value * (cl.cmd.cursor_screen[1] - -1) * vid.height * sensitivity.value * cl.viewzoom;
487 cl.cmd.cursor_screen[1] = -1;
489 if (cl.cmd.cursor_screen[1] > 1)
491 cl.viewangles[PITCH] += m_pitch.value * (cl.cmd.cursor_screen[1] - 1) * vid.height * sensitivity.value * cl.viewzoom;
492 cl.cmd.cursor_screen[1] = 1;
495 cl.cmd.cursor_screen[0] = bound(-1, cl.cmd.cursor_screen[0], 1);
496 cl.cmd.cursor_screen[1] = bound(-1, cl.cmd.cursor_screen[1], 1);
497 cl.cmd.cursor_screen[2] = 1;
499 scale[0] = -r_refdef.frustum_x;
500 scale[1] = -r_refdef.frustum_y;
504 VectorScale(scale, 1000000, scale);
506 // calculate current view matrix
509 Matrix4x4_Transform(&r_refdef.viewentitymatrix, temp, cl.cmd.cursor_start);
510 VectorSet(temp, cl.cmd.cursor_screen[2] * scale[2], cl.cmd.cursor_screen[0] * scale[0], cl.cmd.cursor_screen[1] * scale[1]);
511 Matrix4x4_Transform(&r_refdef.viewentitymatrix, temp, cl.cmd.cursor_end);
512 // trace from view origin to the cursor
513 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);
514 // makes sparks where cursor is
515 //CL_SparkShower(cl.cmd.cursor_impact, cl.cmd.cursor_normal, 5, 0);
518 void CL_ClientMovement_InputQW(qw_usercmd_t *cmd)
522 // remove stale queue items
523 n = cl.movement_numqueue;
524 cl.movement_numqueue = 0;
525 for (i = 0;i < n;i++)
526 if (cl.movement_queue[i].sequence > cls.netcon->qw.incoming_sequence)
527 cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
528 // add to input queue if there is room
529 if (cl.movement_numqueue < (int)(sizeof(cl.movement_queue)/sizeof(cl.movement_queue[0])) && cl.mtime[0] > cl.mtime[1])
531 // add to input queue
532 cl.movement_queue[cl.movement_numqueue].sequence = cls.netcon->qw.outgoing_sequence;
533 cl.movement_queue[cl.movement_numqueue].time = cl.mtime[0] + cl_movement_latency.value / 1000.0;
534 cl.movement_queue[cl.movement_numqueue].frametime = cmd->msec * 0.001;
535 VectorCopy(cmd->angles, cl.movement_queue[cl.movement_numqueue].viewangles);
536 cl.movement_queue[cl.movement_numqueue].move[0] = cmd->forwardmove;
537 cl.movement_queue[cl.movement_numqueue].move[1] = cmd->sidemove;
538 cl.movement_queue[cl.movement_numqueue].move[2] = cmd->upmove;
539 cl.movement_queue[cl.movement_numqueue].jump = (cmd->buttons & 2) != 0;
540 cl.movement_queue[cl.movement_numqueue].crouch = false;
541 cl.movement_numqueue++;
543 cl.movement_replay = true;
546 void CL_ClientMovement_Input(qboolean buttonjump, qboolean buttoncrouch)
550 // remove stale queue items
551 n = cl.movement_numqueue;
552 cl.movement_numqueue = 0;
553 if (cl.servermovesequence)
555 for (i = 0;i < n;i++)
556 if (cl.movement_queue[i].sequence > cl.servermovesequence)
557 cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
561 double simulatedtime = cl.mtime[0] + cl_movement_latency.value / 1000.0;
562 for (i = 0;i < n;i++)
563 if (cl.movement_queue[i].time >= cl.mtime[0] && cl.movement_queue[i].time <= simulatedtime)
564 cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
566 // add to input queue if there is room
567 if (cl.movement_numqueue < (int)(sizeof(cl.movement_queue)/sizeof(cl.movement_queue[0])) && cl.mtime[0] > cl.mtime[1])
569 // add to input queue
570 cl.movement_queue[cl.movement_numqueue].sequence = cl.movesequence;
571 cl.movement_queue[cl.movement_numqueue].time = cl.mtime[0] + cl_movement_latency.value / 1000.0;
572 cl.movement_queue[cl.movement_numqueue].frametime = cl.mtime[0] - cl.mtime[1];
573 VectorCopy(cl.viewangles, cl.movement_queue[cl.movement_numqueue].viewangles);
574 cl.movement_queue[cl.movement_numqueue].move[0] = cl.cmd.forwardmove;
575 cl.movement_queue[cl.movement_numqueue].move[1] = cl.cmd.sidemove;
576 cl.movement_queue[cl.movement_numqueue].move[2] = cl.cmd.upmove;
577 cl.movement_queue[cl.movement_numqueue].jump = buttonjump;
578 cl.movement_queue[cl.movement_numqueue].crouch = buttoncrouch;
579 cl.movement_numqueue++;
581 cl.movement_replay = true;
584 void CL_ClientMovement_Replay(void)
591 float movevars_gravity;
592 float movevars_stopspeed;
593 float movevars_maxspeed;
594 float movevars_spectatormaxspeed;
595 float movevars_accelerate;
596 float movevars_airaccelerate;
597 float movevars_wateraccelerate;
598 float movevars_friction;
599 float movevars_waterfriction;
600 float movevars_entgravity;
601 float movevars_jumpvelocity;
602 float movevars_edgefriction;
603 float movevars_maxairspeed;
604 float movevars_stepheight;
614 vec3_t currentorigin;
615 vec3_t currentvelocity;
622 vec3_t currentorigin2;
630 if (!cl.movement_replay)
632 cl.movement_replay = false;
634 if (cls.protocol == PROTOCOL_QUAKEWORLD)
636 movevars_gravity = cl.qw_movevars_gravity;
637 movevars_stopspeed = cl.qw_movevars_stopspeed;
638 movevars_maxspeed = cl.qw_movevars_maxspeed;
639 movevars_spectatormaxspeed = cl.qw_movevars_spectatormaxspeed;
640 movevars_accelerate = cl.qw_movevars_accelerate;
641 movevars_airaccelerate = cl.qw_movevars_airaccelerate;
642 movevars_wateraccelerate = cl.qw_movevars_wateraccelerate;
643 movevars_friction = cl.qw_movevars_friction;
644 movevars_waterfriction = cl.qw_movevars_waterfriction;
645 movevars_entgravity = cl.qw_movevars_entgravity;
646 movevars_jumpvelocity = cl_movement_jumpvelocity.value;
647 movevars_edgefriction = cl_movement_edgefriction.value;
648 movevars_maxairspeed = cl_movement_maxairspeed.value;
649 movevars_stepheight = cl_movement_stepheight.value;
653 movevars_gravity = sv_gravity.value;
654 movevars_stopspeed = cl_movement_stopspeed.value;
655 movevars_maxspeed = cl_movement_maxspeed.value;
656 movevars_spectatormaxspeed = cl_movement_maxspeed.value;
657 movevars_accelerate = cl_movement_accelerate.value;
658 movevars_airaccelerate = cl_movement_accelerate.value;
659 movevars_wateraccelerate = cl_movement_accelerate.value;
660 movevars_friction = cl_movement_friction.value;
661 movevars_waterfriction = cl_movement_friction.value;
662 movevars_entgravity = 1;
663 movevars_jumpvelocity = cl_movement_jumpvelocity.value;
664 movevars_edgefriction = cl_movement_edgefriction.value;
665 movevars_maxairspeed = cl_movement_maxairspeed.value;
666 movevars_stepheight = cl_movement_stepheight.value;
669 // fetch current starting values
670 VectorCopy(cl_entities[cl.playerentity].state_current.origin, currentorigin);
671 VectorCopy(cl.mvelocity[0], currentvelocity);
672 // FIXME: try minor nudges in various directions if startsolid to find a
673 // safe place to start the walk (due to network compression in some
674 // protocols this starts in solid)
675 //currentorigin[2] += (1.0 / 32.0); // slight nudge to get out of the floor
676 crouch = false; // this will be updated on first move
679 VectorSet(currentorigin2, currentorigin[0], currentorigin[1], currentorigin[2] + 1);
680 VectorSet(neworigin2, currentorigin[0], currentorigin[1], currentorigin[2] - 1);
681 trace = CL_TraceBox(currentorigin2, cl_playercrouchmins, cl_playercrouchmaxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
682 onground = trace.fraction < 1 && trace.plane.normal[2] > 0.7;
683 //Con_Printf("%f: ", cl.mtime[0]);
685 // replay the input queue to predict current location
686 // note: this relies on the fact there's always one queue item at the end
688 for (i = 0;cl.movement && i < cl.movement_numqueue;i++)
690 client_movementqueue_t *q = cl.movement_queue + bound(0, i, cl.movement_numqueue - 1);
691 frametime = q->frametime;
692 //Con_Printf(" %f", frametime);
697 // wants to crouch, this always works...
703 // wants to stand, if currently crouching we need to check for a
707 trace = CL_TraceBox(currentorigin, cl_playerstandmins, cl_playerstandmaxs, currentorigin, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
708 if (!trace.startsolid)
714 playermins = cl_playercrouchmins;
715 playermaxs = cl_playercrouchmaxs;
719 playermins = cl_playerstandmins;
720 playermaxs = cl_playerstandmaxs;
722 // change velocity according to q->viewangles and q->move
723 contents = CL_PointSuperContents(currentorigin);
724 if (contents & SUPERCONTENTS_LIQUIDSMASK)
727 AngleVectors(q->viewangles, forward, right, up);
728 VectorSet(up, 0, 0, 1);
729 VectorMAMAM(q->move[0], forward, q->move[1], right, q->move[2], up, wishvel);
730 wishspeed = VectorLength(wishvel);
732 VectorScale(wishvel, 1 / wishspeed, wishdir);
734 VectorSet( wishdir, 0.0, 0.0, 0.0 );
735 wishspeed = min(wishspeed, movevars_maxspeed) * 0.6;
738 VectorScale(currentvelocity, (1 - frametime * movevars_waterfriction), currentvelocity);
739 f = wishspeed - DotProduct(currentvelocity, wishdir);
742 f = min(f, movevars_wateraccelerate * frametime * wishspeed);
743 VectorMA(currentvelocity, f, wishdir, currentvelocity);
747 if (contents & SUPERCONTENTS_LAVA)
748 currentvelocity[2] = 50;
749 else if (contents & SUPERCONTENTS_SLIME)
750 currentvelocity[2] = 80;
753 if (gamemode == GAME_NEXUIZ)
754 currentvelocity[2] = 200;
756 currentvelocity[2] = 100;
763 if (onground && q->jump)
765 currentvelocity[2] += movevars_jumpvelocity;
768 VectorSet(yawangles, 0, q->viewangles[1], 0);
769 AngleVectors(yawangles, forward, right, up);
770 VectorMAM(q->move[0], forward, q->move[1], right, wishvel);
771 wishspeed = VectorLength(wishvel);
773 VectorScale(wishvel, 1 / wishspeed, wishdir);
775 VectorSet( wishdir, 0.0, 0.0, 0.0 );
776 wishspeed = min(wishspeed, movevars_maxspeed);
782 // apply ground friction
783 f = sqrt(currentvelocity[0] * currentvelocity[0] + currentvelocity[1] * currentvelocity[1]);
787 VectorSet(currentorigin2, currentorigin[0] + currentvelocity[0]*(16/f), currentorigin[1] + currentvelocity[1]*(16/f), currentorigin[2] + playermins[2]);
788 VectorSet(neworigin2, currentorigin2[0], currentorigin2[1], currentorigin2[2] - 34);
789 trace = CL_TraceBox(currentorigin2, vec3_origin, vec3_origin, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
790 if (trace.fraction == 1)
791 edgefriction = movevars_edgefriction;
794 f = 1 - frametime * edgefriction * ((f < movevars_stopspeed) ? (movevars_stopspeed / f) : 1) * movevars_friction;
796 VectorScale(currentvelocity, f, currentvelocity);
800 // apply air speed limit
801 wishspeed = min(wishspeed, movevars_maxairspeed);
803 if (gamemode == GAME_NEXUIZ)
804 addspeed = wishspeed;
806 addspeed = wishspeed - DotProduct(currentvelocity, wishdir);
809 accelspeed = min(movevars_accelerate * frametime * wishspeed, addspeed);
810 VectorMA(currentvelocity, accelspeed, wishdir, currentvelocity);
812 currentvelocity[2] -= cl_gravity.value * frametime;
815 //if (i < cl.movement_numqueue - 1 || (cl_movement.integer & 4))
819 playermins = cl_playercrouchmins;
820 playermaxs = cl_playercrouchmaxs;
824 playermins = cl_playerstandmins;
825 playermaxs = cl_playerstandmaxs;
828 for (bump = 0, t = frametime;bump < 8 && VectorLength2(currentvelocity) > 0;bump++)
830 VectorMA(currentorigin, t, currentvelocity, neworigin);
831 trace = CL_TraceBox(currentorigin, playermins, playermaxs, neworigin, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
832 if (trace.fraction < 1 && trace.plane.normal[2] == 0)
834 // may be a step or wall, try stepping up
835 // first move forward at a higher level
836 VectorSet(currentorigin2, currentorigin[0], currentorigin[1], currentorigin[2] + movevars_stepheight);
837 VectorSet(neworigin2, neworigin[0], neworigin[1], currentorigin[2] + movevars_stepheight);
838 trace2 = CL_TraceBox(currentorigin2, playermins, playermaxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
839 // then move down from there
840 VectorCopy(trace2.endpos, currentorigin2);
841 VectorSet(neworigin2, trace2.endpos[0], trace2.endpos[1], currentorigin[2]);
842 trace3 = CL_TraceBox(currentorigin2, playermins, playermaxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
843 //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]);
844 // accept the new trace if it made some progress
845 if (fabs(trace3.endpos[0] - trace.endpos[0]) >= 0.03125 || fabs(trace3.endpos[1] - trace.endpos[1]) >= 0.03125)
848 VectorCopy(trace3.endpos, trace.endpos);
851 if (trace.fraction == 1)
853 VectorCopy(trace.endpos, currentorigin);
856 if (trace.plane.normal[2] > 0.7)
858 t *= 1 - trace.fraction;
859 if (trace.fraction >= 0.001)
860 VectorCopy(trace.endpos, currentorigin);
861 f = DotProduct(currentvelocity, trace.plane.normal);
862 VectorMA(currentvelocity, -f, trace.plane.normal, currentvelocity);
866 // store replay location
867 VectorCopy(cl.movement_origin, cl.movement_oldorigin);
868 VectorCopy(currentorigin, cl.movement_origin);
869 VectorCopy(currentvelocity, cl.movement_velocity);
870 //VectorCopy(currentorigin, cl_entities[cl.playerentity].state_current.origin);
871 //VectorSet(cl_entities[cl.playerentity].state_current.angles, 0, cl.viewangles[1], 0);
874 void QW_MSG_WriteDeltaUsercmd(sizebuf_t *buf, qw_usercmd_t *from, qw_usercmd_t *to)
879 if (to->angles[0] != from->angles[0])
880 bits |= QW_CM_ANGLE1;
881 if (to->angles[1] != from->angles[1])
882 bits |= QW_CM_ANGLE2;
883 if (to->angles[2] != from->angles[2])
884 bits |= QW_CM_ANGLE3;
885 if (to->forwardmove != from->forwardmove)
886 bits |= QW_CM_FORWARD;
887 if (to->sidemove != from->sidemove)
889 if (to->upmove != from->upmove)
891 if (to->buttons != from->buttons)
892 bits |= QW_CM_BUTTONS;
893 if (to->impulse != from->impulse)
894 bits |= QW_CM_IMPULSE;
896 MSG_WriteByte(buf, bits);
897 if (bits & QW_CM_ANGLE1)
898 MSG_WriteAngle16i(buf, to->angles[0]);
899 if (bits & QW_CM_ANGLE2)
900 MSG_WriteAngle16i(buf, to->angles[1]);
901 if (bits & QW_CM_ANGLE3)
902 MSG_WriteAngle16i(buf, to->angles[2]);
903 if (bits & QW_CM_FORWARD)
904 MSG_WriteShort(buf, to->forwardmove);
905 if (bits & QW_CM_SIDE)
906 MSG_WriteShort(buf, to->sidemove);
908 MSG_WriteShort(buf, to->upmove);
909 if (bits & QW_CM_BUTTONS)
910 MSG_WriteByte(buf, to->buttons);
911 if (bits & QW_CM_IMPULSE)
912 MSG_WriteByte(buf, to->impulse);
913 MSG_WriteByte(buf, to->msec);
921 extern cvar_t cl_netinputpacketspersecond;
922 void CL_SendMove(void)
928 unsigned char data[128];
929 static double lastsendtime = 0;
930 #define MOVEAVERAGING 0
932 static float accumforwardmove = 0, accumsidemove = 0, accumupmove = 0, accumtotal = 0; // accumulation
934 float forwardmove, sidemove, upmove;
936 // if playing a demo, do nothing
941 // accumulate changes between messages
942 accumforwardmove += cl.cmd.forwardmove;
943 accumsidemove += cl.cmd.sidemove;
944 accumupmove += cl.cmd.upmove;
948 if (cl_movement.integer && cls.signon == SIGNONS && cls.protocol != PROTOCOL_QUAKEWORLD)
950 if (!cl.movement_needupdate)
952 cl.movement_needupdate = false;
953 cl.movement = cl.stats[STAT_HEALTH] > 0 && !cl.intermission;
958 if (realtime < lastsendtime + 1.0 / bound(10, cl_netinputpacketspersecond.value, 100))
960 // don't let it fall behind if CL_SendMove hasn't been called recently
961 // (such is the case when framerate is too low for instance)
962 lastsendtime = max(lastsendtime + 1.0 / bound(10, cl_netinputpacketspersecond.value, 100), realtime);
965 // average the accumulated changes
966 accumtotal = 1.0f / accumtotal;
967 forwardmove = accumforwardmove * accumtotal;
968 sidemove = accumsidemove * accumtotal;
969 upmove = accumupmove * accumtotal;
970 accumforwardmove = 0;
975 // use the latest values
976 forwardmove = cl.cmd.forwardmove;
977 sidemove = cl.cmd.sidemove;
978 upmove = cl.cmd.upmove;
981 if (cls.signon == SIGNONS)
982 CL_UpdatePrydonCursor();
989 // LordHavoc: added 6 new buttons and use and chat buttons, and prydon cursor active button
991 if (in_attack.state & 3) bits |= 1;in_attack.state &= ~2;
992 if (in_jump.state & 3) bits |= 2;in_jump.state &= ~2;
993 if (in_button3.state & 3) bits |= 4;in_button3.state &= ~2;
994 if (in_button4.state & 3) bits |= 8;in_button4.state &= ~2;
995 if (in_button5.state & 3) bits |= 16;in_button5.state &= ~2;
996 if (in_button6.state & 3) bits |= 32;in_button6.state &= ~2;
997 if (in_button7.state & 3) bits |= 64;in_button7.state &= ~2;
998 if (in_button8.state & 3) bits |= 128;in_button8.state &= ~2;
999 if (in_use.state & 3) bits |= 256;in_use.state &= ~2;
1000 if (key_dest != key_game || key_consoleactive) bits |= 512;
1001 if (cl_prydoncursor.integer) bits |= 1024;
1002 if (in_button9.state & 3) bits |= 2048;in_button9.state &= ~2;
1003 if (in_button10.state & 3) bits |= 4096;in_button10.state &= ~2;
1004 if (in_button11.state & 3) bits |= 8192;in_button11.state &= ~2;
1005 if (in_button12.state & 3) bits |= 16384;in_button12.state &= ~2;
1006 if (in_button13.state & 3) bits |= 32768;in_button13.state &= ~2;
1007 if (in_button14.state & 3) bits |= 65536;in_button14.state &= ~2;
1008 if (in_button15.state & 3) bits |= 131072;in_button15.state &= ~2;
1009 if (in_button16.state & 3) bits |= 262144;in_button16.state &= ~2;
1010 // button bits 19-31 unused currently
1011 // rotate/zoom view serverside if PRYDON_CLIENTCURSOR cursor is at edge of screen
1012 if (cl.cmd.cursor_screen[0] <= -1) bits |= 8;
1013 if (cl.cmd.cursor_screen[0] >= 1) bits |= 16;
1014 if (cl.cmd.cursor_screen[1] <= -1) bits |= 32;
1015 if (cl.cmd.cursor_screen[1] >= 1) bits |= 64;
1017 impulse = in_impulse;
1020 csqc_buttons = bits;
1022 if (cls.signon == SIGNONS)
1024 // always dump the first two messages, because they may contain leftover inputs from the last level
1025 if (++cl.movemessages >= 2)
1027 // send the movement message
1028 // PROTOCOL_QUAKE clc_move = 16 bytes total
1029 // PROTOCOL_QUAKEDP clc_move = 16 bytes total
1030 // PROTOCOL_NEHAHRAMOVIE clc_move = 16 bytes total
1031 // PROTOCOL_DARKPLACES1 clc_move = 19 bytes total
1032 // PROTOCOL_DARKPLACES2 clc_move = 25 bytes total
1033 // PROTOCOL_DARKPLACES3 clc_move = 25 bytes total
1034 // PROTOCOL_DARKPLACES4 clc_move = 19 bytes total
1035 // PROTOCOL_DARKPLACES5 clc_move = 19 bytes total
1036 // PROTOCOL_DARKPLACES6 clc_move = 52 bytes total
1037 // PROTOCOL_DARKPLACES7 clc_move = 56 bytes total
1038 // PROTOCOL_QUAKEWORLD clc_move = 34 bytes total (typically, but can reach 43 bytes, or even 49 bytes with roll)
1039 if (cls.protocol == PROTOCOL_QUAKEWORLD)
1043 static double oldmsectime;
1044 qw_usercmd_t *cmd, *oldcmd;
1045 qw_usercmd_t nullcmd;
1047 //Con_Printf("code qw_clc_move\n");
1049 i = cls.netcon->qw.outgoing_sequence & QW_UPDATE_MASK;
1050 cmd = &cl.qw_moves[i];
1051 memset(&nullcmd, 0, sizeof(nullcmd));
1052 memset(cmd, 0, sizeof(*cmd));
1053 cmd->buttons = bits;
1054 cmd->impulse = impulse;
1055 cmd->forwardmove = (short)bound(-32768, forwardmove, 32767);
1056 cmd->sidemove = (short)bound(-32768, sidemove, 32767);
1057 cmd->upmove = (short)bound(-32768, upmove, 32767);
1058 VectorCopy(cl.viewangles, cmd->angles);
1059 msectime = realtime * 1000;
1060 cmd->msec = (unsigned char)bound(0, msectime - oldmsectime, 255);
1061 // ridiculous value rejection (matches qw)
1062 if (cmd->msec > 250)
1064 oldmsectime = msectime;
1066 CL_ClientMovement_InputQW(cmd);
1068 MSG_WriteByte(&buf, qw_clc_move);
1069 // save the position for a checksum byte
1070 checksumindex = buf.cursize;
1071 MSG_WriteByte(&buf, 0);
1072 // packet loss percentage
1073 // FIXME: netgraph stuff
1074 MSG_WriteByte(&buf, 0);
1075 // write most recent 3 moves
1076 i = (cls.netcon->qw.outgoing_sequence-2) & QW_UPDATE_MASK;
1077 cmd = &cl.qw_moves[i];
1078 QW_MSG_WriteDeltaUsercmd(&buf, &nullcmd, cmd);
1080 i = (cls.netcon->qw.outgoing_sequence-1) & QW_UPDATE_MASK;
1081 cmd = &cl.qw_moves[i];
1082 QW_MSG_WriteDeltaUsercmd(&buf, oldcmd, cmd);
1084 i = cls.netcon->qw.outgoing_sequence & QW_UPDATE_MASK;
1085 cmd = &cl.qw_moves[i];
1086 QW_MSG_WriteDeltaUsercmd(&buf, oldcmd, cmd);
1087 // calculate the checksum
1088 buf.data[checksumindex] = COM_BlockSequenceCRCByteQW(buf.data + checksumindex + 1, buf.cursize - checksumindex - 1, cls.netcon->qw.outgoing_sequence);
1089 // if delta compression history overflows, request no delta
1090 if (cls.netcon->qw.outgoing_sequence - cl.qw_validsequence >= QW_UPDATE_BACKUP-1)
1091 cl.qw_validsequence = 0;
1092 // request delta compression if appropriate
1093 if (cl.qw_validsequence && !cl_nodelta.integer && cls.state == ca_connected && !cls.demorecording)
1095 cl.qw_deltasequence[cls.netcon->qw.outgoing_sequence & QW_UPDATE_MASK] = cl.qw_validsequence;
1096 MSG_WriteByte(&buf, qw_clc_delta);
1097 MSG_WriteByte(&buf, cl.qw_validsequence & 255);
1100 cl.qw_deltasequence[cls.netcon->qw.outgoing_sequence & QW_UPDATE_MASK] = -1;
1102 else if (cls.protocol == PROTOCOL_QUAKE || cls.protocol == PROTOCOL_QUAKEDP || cls.protocol == PROTOCOL_NEHAHRAMOVIE)
1105 MSG_WriteByte (&buf, clc_move);
1106 MSG_WriteFloat (&buf, cl.mtime[0]); // so server can get ping times
1108 for (i = 0;i < 3;i++)
1109 MSG_WriteAngle8i (&buf, cl.viewangles[i]);
1111 MSG_WriteCoord16i (&buf, forwardmove);
1112 MSG_WriteCoord16i (&buf, sidemove);
1113 MSG_WriteCoord16i (&buf, upmove);
1115 MSG_WriteByte (&buf, bits);
1116 MSG_WriteByte (&buf, impulse);
1118 CL_ClientMovement_Input((bits & 2) != 0, false);
1120 else if (cls.protocol == PROTOCOL_DARKPLACES2 || cls.protocol == PROTOCOL_DARKPLACES3)
1123 MSG_WriteByte (&buf, clc_move);
1124 MSG_WriteFloat (&buf, cl.mtime[0]); // so server can get ping times
1126 for (i = 0;i < 3;i++)
1127 MSG_WriteAngle32f (&buf, cl.viewangles[i]);
1129 MSG_WriteCoord16i (&buf, forwardmove);
1130 MSG_WriteCoord16i (&buf, sidemove);
1131 MSG_WriteCoord16i (&buf, upmove);
1133 MSG_WriteByte (&buf, bits);
1134 MSG_WriteByte (&buf, impulse);
1136 CL_ClientMovement_Input((bits & 2) != 0, false);
1138 else if (cls.protocol == PROTOCOL_DARKPLACES1 || cls.protocol == PROTOCOL_DARKPLACES4 || cls.protocol == PROTOCOL_DARKPLACES5)
1141 MSG_WriteByte (&buf, clc_move);
1142 MSG_WriteFloat (&buf, cl.mtime[0]); // so server can get ping times
1144 for (i = 0;i < 3;i++)
1145 MSG_WriteAngle16i (&buf, cl.viewangles[i]);
1147 MSG_WriteCoord16i (&buf, forwardmove);
1148 MSG_WriteCoord16i (&buf, sidemove);
1149 MSG_WriteCoord16i (&buf, upmove);
1151 MSG_WriteByte (&buf, bits);
1152 MSG_WriteByte (&buf, impulse);
1154 CL_ClientMovement_Input((bits & 2) != 0, false);
1159 MSG_WriteByte (&buf, clc_move);
1160 if (cls.protocol != PROTOCOL_DARKPLACES6)
1162 if (cl_movement.integer)
1165 MSG_WriteLong (&buf, cl.movesequence);
1168 MSG_WriteLong (&buf, 0);
1170 MSG_WriteFloat (&buf, cl.mtime[0]); // so server can get ping times
1172 for (i = 0;i < 3;i++)
1173 MSG_WriteAngle16i (&buf, cl.viewangles[i]);
1175 MSG_WriteCoord16i (&buf, forwardmove);
1176 MSG_WriteCoord16i (&buf, sidemove);
1177 MSG_WriteCoord16i (&buf, upmove);
1179 MSG_WriteLong (&buf, bits);
1180 MSG_WriteByte (&buf, impulse);
1181 // PRYDON_CLIENTCURSOR
1183 MSG_WriteShort (&buf, cl.cmd.cursor_screen[0] * 32767.0f);
1184 MSG_WriteShort (&buf, cl.cmd.cursor_screen[1] * 32767.0f);
1185 MSG_WriteFloat (&buf, cl.cmd.cursor_start[0]);
1186 MSG_WriteFloat (&buf, cl.cmd.cursor_start[1]);
1187 MSG_WriteFloat (&buf, cl.cmd.cursor_start[2]);
1188 MSG_WriteFloat (&buf, cl.cmd.cursor_impact[0]);
1189 MSG_WriteFloat (&buf, cl.cmd.cursor_impact[1]);
1190 MSG_WriteFloat (&buf, cl.cmd.cursor_impact[2]);
1191 MSG_WriteShort (&buf, cl.cmd.cursor_entitynumber);
1193 // FIXME: bits & 16 is +button5, Nexuiz specific
1194 CL_ClientMovement_Input((bits & 2) != 0, (bits & 16) != 0);
1198 if (cls.protocol != PROTOCOL_QUAKEWORLD)
1200 // ack the last few frame numbers
1201 // (redundent to improve handling of client->server packet loss)
1202 // for LATESTFRAMENUMS == 3 case this is 15 bytes
1203 for (i = 0;i < LATESTFRAMENUMS;i++)
1205 if (cl.latestframenums[i] > 0)
1207 if (developer_networkentities.integer >= 1)
1208 Con_Printf("send clc_ackframe %i\n", cl.latestframenums[i]);
1209 MSG_WriteByte(&buf, clc_ackframe);
1210 MSG_WriteLong(&buf, cl.latestframenums[i]);
1215 // PROTOCOL_DARKPLACES6 = 67 bytes per packet
1216 // PROTOCOL_DARKPLACES7 = 71 bytes per packet
1219 // send the reliable message (forwarded commands) if there is one
1220 NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol);
1222 if (cls.netcon->message.overflowed)
1224 Con_Print("CL_SendMove: lost server connection\n");
1226 Host_ShutdownServer();
1235 void CL_InitInput (void)
1237 Cmd_AddCommand ("+moveup",IN_UpDown, "swim upward");
1238 Cmd_AddCommand ("-moveup",IN_UpUp, "stop swimming upward");
1239 Cmd_AddCommand ("+movedown",IN_DownDown, "swim downward");
1240 Cmd_AddCommand ("-movedown",IN_DownUp, "stop swimming downward");
1241 Cmd_AddCommand ("+left",IN_LeftDown, "turn left");
1242 Cmd_AddCommand ("-left",IN_LeftUp, "stop turning left");
1243 Cmd_AddCommand ("+right",IN_RightDown, "turn right");
1244 Cmd_AddCommand ("-right",IN_RightUp, "stop turning right");
1245 Cmd_AddCommand ("+forward",IN_ForwardDown, "move forward");
1246 Cmd_AddCommand ("-forward",IN_ForwardUp, "stop moving forward");
1247 Cmd_AddCommand ("+back",IN_BackDown, "move backward");
1248 Cmd_AddCommand ("-back",IN_BackUp, "stop moving backward");
1249 Cmd_AddCommand ("+lookup", IN_LookupDown, "look upward");
1250 Cmd_AddCommand ("-lookup", IN_LookupUp, "stop looking upward");
1251 Cmd_AddCommand ("+lookdown", IN_LookdownDown, "look downward");
1252 Cmd_AddCommand ("-lookdown", IN_LookdownUp, "stop looking downward");
1253 Cmd_AddCommand ("+strafe", IN_StrafeDown, "activate strafing mode (move instead of turn)\n");
1254 Cmd_AddCommand ("-strafe", IN_StrafeUp, "deactivate strafing mode");
1255 Cmd_AddCommand ("+moveleft", IN_MoveleftDown, "strafe left");
1256 Cmd_AddCommand ("-moveleft", IN_MoveleftUp, "stop strafing left");
1257 Cmd_AddCommand ("+moveright", IN_MoverightDown, "strafe right");
1258 Cmd_AddCommand ("-moveright", IN_MoverightUp, "stop strafing right");
1259 Cmd_AddCommand ("+speed", IN_SpeedDown, "activate run mode (faster movement and turning)");
1260 Cmd_AddCommand ("-speed", IN_SpeedUp, "deactivate run mode");
1261 Cmd_AddCommand ("+attack", IN_AttackDown, "begin firing");
1262 Cmd_AddCommand ("-attack", IN_AttackUp, "stop firing");
1263 Cmd_AddCommand ("+jump", IN_JumpDown, "jump");
1264 Cmd_AddCommand ("-jump", IN_JumpUp, "end jump (so you can jump again)");
1265 Cmd_AddCommand ("impulse", IN_Impulse, "send an impulse number to server (select weapon, use item, etc)");
1266 Cmd_AddCommand ("+klook", IN_KLookDown, "activate keyboard looking mode, do not recenter view");
1267 Cmd_AddCommand ("-klook", IN_KLookUp, "deactivate keyboard looking mode");
1268 Cmd_AddCommand ("+mlook", IN_MLookDown, "activate mouse looking mode, do not recenter view");
1269 Cmd_AddCommand ("-mlook", IN_MLookUp, "deactivate mouse looking mode");
1271 // LordHavoc: added use button
1272 Cmd_AddCommand ("+use", IN_UseDown, "use something (may be used by some mods)");
1273 Cmd_AddCommand ("-use", IN_UseUp, "stop using something");
1275 // LordHavoc: added 6 new buttons
1276 Cmd_AddCommand ("+button3", IN_Button3Down, "activate button3 (behavior depends on mod)");
1277 Cmd_AddCommand ("-button3", IN_Button3Up, "deactivate button3");
1278 Cmd_AddCommand ("+button4", IN_Button4Down, "activate button4 (behavior depends on mod)");
1279 Cmd_AddCommand ("-button4", IN_Button4Up, "deactivate button4");
1280 Cmd_AddCommand ("+button5", IN_Button5Down, "activate button5 (behavior depends on mod)");
1281 Cmd_AddCommand ("-button5", IN_Button5Up, "deactivate button5");
1282 Cmd_AddCommand ("+button6", IN_Button6Down, "activate button6 (behavior depends on mod)");
1283 Cmd_AddCommand ("-button6", IN_Button6Up, "deactivate button6");
1284 Cmd_AddCommand ("+button7", IN_Button7Down, "activate button7 (behavior depends on mod)");
1285 Cmd_AddCommand ("-button7", IN_Button7Up, "deactivate button7");
1286 Cmd_AddCommand ("+button8", IN_Button8Down, "activate button8 (behavior depends on mod)");
1287 Cmd_AddCommand ("-button8", IN_Button8Up, "deactivate button8");
1288 Cmd_AddCommand ("+button9", IN_Button9Down, "activate button9 (behavior depends on mod)");
1289 Cmd_AddCommand ("-button9", IN_Button9Up, "deactivate button9");
1290 Cmd_AddCommand ("+button10", IN_Button10Down, "activate button10 (behavior depends on mod)");
1291 Cmd_AddCommand ("-button10", IN_Button10Up, "deactivate button10");
1292 Cmd_AddCommand ("+button11", IN_Button11Down, "activate button11 (behavior depends on mod)");
1293 Cmd_AddCommand ("-button11", IN_Button11Up, "deactivate button11");
1294 Cmd_AddCommand ("+button12", IN_Button12Down, "activate button12 (behavior depends on mod)");
1295 Cmd_AddCommand ("-button12", IN_Button12Up, "deactivate button12");
1296 Cmd_AddCommand ("+button13", IN_Button13Down, "activate button13 (behavior depends on mod)");
1297 Cmd_AddCommand ("-button13", IN_Button13Up, "deactivate button13");
1298 Cmd_AddCommand ("+button14", IN_Button14Down, "activate button14 (behavior depends on mod)");
1299 Cmd_AddCommand ("-button14", IN_Button14Up, "deactivate button14");
1300 Cmd_AddCommand ("+button15", IN_Button15Down, "activate button15 (behavior depends on mod)");
1301 Cmd_AddCommand ("-button15", IN_Button15Up, "deactivate button15");
1302 Cmd_AddCommand ("+button16", IN_Button16Down, "activate button16 (behavior depends on mod)");
1303 Cmd_AddCommand ("-button16", IN_Button16Up, "deactivate button16");
1305 Cvar_RegisterVariable(&cl_movement);
1306 Cvar_RegisterVariable(&cl_movement_latency);
1307 Cvar_RegisterVariable(&cl_movement_maxspeed);
1308 Cvar_RegisterVariable(&cl_movement_maxairspeed);
1309 Cvar_RegisterVariable(&cl_movement_stopspeed);
1310 Cvar_RegisterVariable(&cl_movement_friction);
1311 Cvar_RegisterVariable(&cl_movement_edgefriction);
1312 Cvar_RegisterVariable(&cl_movement_stepheight);
1313 Cvar_RegisterVariable(&cl_movement_accelerate);
1314 Cvar_RegisterVariable(&cl_movement_jumpvelocity);
1315 Cvar_RegisterVariable(&cl_gravity);
1316 Cvar_RegisterVariable(&cl_slowmo);
1318 Cvar_RegisterVariable(&in_pitch_min);
1319 Cvar_RegisterVariable(&in_pitch_max);
1320 Cvar_RegisterVariable(&m_filter);
1322 Cvar_RegisterVariable(&cl_netinputpacketspersecond);
1324 Cvar_RegisterVariable(&cl_nodelta);