simplifying Warsow-style physics code even more, as it now can use a common code...
[divverent/darkplaces.git] / cl_input.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
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.
8
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.
12
13 See the GNU General Public License for more details.
14
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.
18
19 */
20 // cl.input.c  -- builds an intended movement command to send to the server
21
22 // Quake is a trademark of Id Software, Inc., (c) 1996 Id Software, Inc. All
23 // rights reserved.
24
25 #include "quakedef.h"
26 #include "csprogs.h"
27
28 /*
29 ===============================================================================
30
31 KEY BUTTONS
32
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.
37
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
40 the release.
41
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
45
46 ===============================================================================
47 */
48
49
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;
57 //even more
58 kbutton_t       in_button9, in_button10, in_button11, in_button12, in_button13, in_button14, in_button15, in_button16;
59
60 int                     in_impulse;
61
62
63
64 void KeyDown (kbutton_t *b)
65 {
66         int k;
67         const char *c;
68
69         c = Cmd_Argv(1);
70         if (c[0])
71                 k = atoi(c);
72         else
73                 k = -1;         // typed manually at the console for continuous down
74
75         if (k == b->down[0] || k == b->down[1])
76                 return;         // repeating key
77
78         if (!b->down[0])
79                 b->down[0] = k;
80         else if (!b->down[1])
81                 b->down[1] = k;
82         else
83         {
84                 Con_Print("Three keys down for a button!\n");
85                 return;
86         }
87
88         if (b->state & 1)
89                 return;         // still down
90         b->state |= 1 + 2;      // down + impulse down
91 }
92
93 void KeyUp (kbutton_t *b)
94 {
95         int k;
96         const char *c;
97
98         c = Cmd_Argv(1);
99         if (c[0])
100                 k = atoi(c);
101         else
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
105                 return;
106         }
107
108         if (b->down[0] == k)
109                 b->down[0] = 0;
110         else if (b->down[1] == k)
111                 b->down[1] = 0;
112         else
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
116
117         if (!(b->state & 1))
118                 return;         // still up (this should not happen)
119         b->state &= ~1;         // now up
120         b->state |= 4;          // impulse up
121 }
122
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)
127 {
128         KeyUp(&in_mlook);
129         if ( !(in_mlook.state&1) && lookspring.value)
130                 V_StartPitchDrift();
131 }
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);}
152
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);}
157
158 void IN_AttackDown(void) {KeyDown(&in_attack);}
159 void IN_AttackUp(void) {KeyUp(&in_attack);}
160
161 void IN_UseDown(void) {KeyDown(&in_use);}
162 void IN_UseUp(void) {KeyUp(&in_use);}
163
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);}
177
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);}
194
195 void IN_JumpDown (void) {KeyDown(&in_jump);}
196 void IN_JumpUp (void) {KeyUp(&in_jump);}
197
198 void IN_Impulse (void) {in_impulse=atoi(Cmd_Argv(1));}
199
200 in_bestweapon_info_t in_bestweapon_info[IN_BESTWEAPON_MAX];
201
202 void IN_BestWeapon_Register(const char *name, int impulse, int weaponbit, int activeweaponcode, int ammostat, int ammomin)
203 {
204         int i;
205         for(i = 0; i < IN_BESTWEAPON_MAX && in_bestweapon_info[i].impulse; ++i)
206                 if(in_bestweapon_info[i].impulse == impulse)
207                         break;
208         if(i >= IN_BESTWEAPON_MAX)
209         {
210                 Con_Printf("no slot left for weapon definition; increase IN_BESTWEAPON_MAX\n");
211                 return; // sorry
212         }
213         strlcpy(in_bestweapon_info[i].name, name, sizeof(in_bestweapon_info[i].name));
214         in_bestweapon_info[i].impulse = impulse;
215         if(weaponbit != -1)
216                 in_bestweapon_info[i].weaponbit = weaponbit;
217         if(activeweaponcode != -1)
218                 in_bestweapon_info[i].activeweaponcode = activeweaponcode;
219         if(ammostat != -1)
220                 in_bestweapon_info[i].ammostat = ammostat;
221         if(ammomin != -1)
222                 in_bestweapon_info[i].ammomin = ammomin;
223 }
224
225 void IN_BestWeapon_ResetData (void)
226 {
227         memset(in_bestweapon_info, 0, sizeof(in_bestweapon_info));
228         IN_BestWeapon_Register("1", 1, IT_AXE, IT_AXE, STAT_SHELLS, 0);
229         IN_BestWeapon_Register("2", 2, IT_SHOTGUN, IT_SHOTGUN, STAT_SHELLS, 1);
230         IN_BestWeapon_Register("3", 3, IT_SUPER_SHOTGUN, IT_SUPER_SHOTGUN, STAT_SHELLS, 1);
231         IN_BestWeapon_Register("4", 4, IT_NAILGUN, IT_NAILGUN, STAT_NAILS, 1);
232         IN_BestWeapon_Register("5", 5, IT_SUPER_NAILGUN, IT_SUPER_NAILGUN, STAT_NAILS, 1);
233         IN_BestWeapon_Register("6", 6, IT_GRENADE_LAUNCHER, IT_GRENADE_LAUNCHER, STAT_ROCKETS, 1);
234         IN_BestWeapon_Register("7", 7, IT_ROCKET_LAUNCHER, IT_ROCKET_LAUNCHER, STAT_ROCKETS, 1);
235         IN_BestWeapon_Register("8", 8, IT_LIGHTNING, IT_LIGHTNING, STAT_CELLS, 1);
236         IN_BestWeapon_Register("9", 9, 128, 128, STAT_CELLS, 1); // generic energy weapon for mods
237         IN_BestWeapon_Register("p", 209, 128, 128, STAT_CELLS, 1); // dpmod plasma gun
238         IN_BestWeapon_Register("w", 210, 8388608, 8388608, STAT_CELLS, 1); // dpmod plasma wave cannon
239         IN_BestWeapon_Register("l", 225, HIT_LASER_CANNON, HIT_LASER_CANNON, STAT_CELLS, 1); // hipnotic laser cannon
240         IN_BestWeapon_Register("h", 226, HIT_MJOLNIR, HIT_MJOLNIR, STAT_CELLS, 0); // hipnotic mjolnir hammer
241 }
242
243 void IN_BestWeapon_Register_f (void)
244 {
245         if(Cmd_Argc() == 7)
246         {
247                 IN_BestWeapon_Register(
248                         Cmd_Argv(1),
249                         atoi(Cmd_Argv(2)),
250                         atoi(Cmd_Argv(3)),
251                         atoi(Cmd_Argv(4)),
252                         atoi(Cmd_Argv(5)),
253                         atoi(Cmd_Argv(6))
254                 );
255         }
256         else if(Cmd_Argc() == 2 && !strcmp(Cmd_Argv(1), "clear"))
257         {
258                 memset(in_bestweapon_info, 0, sizeof(in_bestweapon_info));
259         }
260         else if(Cmd_Argc() == 2 && !strcmp(Cmd_Argv(1), "quake"))
261         {
262                 IN_BestWeapon_ResetData();
263         }
264         else
265         {
266                 Con_Printf("Usage: %s weaponshortname impulse itemcode activeweaponcode ammostat ammomin; %s clear; %s quake\n", Cmd_Argv(0), Cmd_Argv(0), Cmd_Argv(0));
267         }
268 }
269
270 void IN_BestWeapon (void)
271 {
272         int i, n;
273         const char *t;
274         if (Cmd_Argc() < 2)
275         {
276                 Con_Printf("bestweapon requires 1 or more parameters\n");
277                 return;
278         }
279         for (i = 1;i < Cmd_Argc();i++)
280         {
281                 t = Cmd_Argv(i);
282                 // figure out which weapon this character refers to
283                 for (n = 0;n < IN_BESTWEAPON_MAX && in_bestweapon_info[n].impulse;n++)
284                 {
285                         if (!strcmp(in_bestweapon_info[n].name, t))
286                         {
287                                 // we found out what weapon this character refers to
288                                 // check if the inventory contains the weapon and enough ammo
289                                 if ((cl.stats[STAT_ITEMS] & in_bestweapon_info[n].weaponbit) && (cl.stats[in_bestweapon_info[n].ammostat] >= in_bestweapon_info[n].ammomin))
290                                 {
291                                         // we found one of the weapons the player wanted
292                                         // send an impulse to switch to it
293                                         in_impulse = in_bestweapon_info[n].impulse;
294                                         return;
295                                 }
296                                 break;
297                         }
298                 }
299                 // if we couldn't identify the weapon we just ignore it and continue checking for other weapons
300         }
301         // if we couldn't find any of the weapons, there's nothing more we can do...
302 }
303
304 void IN_CycleWeapon (void)
305 {
306         int i, n;
307         int first = -1;
308         qboolean found = false;
309         const char *t;
310         if (Cmd_Argc() < 2)
311         {
312                 Con_Printf("bestweapon requires 1 or more parameters\n");
313                 return;
314         }
315         for (i = 1;i < Cmd_Argc();i++)
316         {
317                 t = Cmd_Argv(i);
318                 // figure out which weapon this character refers to
319                 for (n = 0;n < IN_BESTWEAPON_MAX && in_bestweapon_info[n].impulse;n++)
320                 {
321                         if (!strcmp(in_bestweapon_info[n].name, t))
322                         {
323                                 // we found out what weapon this character refers to
324                                 // check if the inventory contains the weapon and enough ammo
325                                 if ((cl.stats[STAT_ITEMS] & in_bestweapon_info[n].weaponbit) && (cl.stats[in_bestweapon_info[n].ammostat] >= in_bestweapon_info[n].ammomin))
326                                 {
327                                         // we found one of the weapons the player wanted
328                                         if(first == -1)
329                                                 first = n;
330                                         if(found)
331                                         {
332                                                 in_impulse = in_bestweapon_info[n].impulse;
333                                                 return;
334                                         }
335                                         if(cl.stats[STAT_ACTIVEWEAPON] == in_bestweapon_info[n].activeweaponcode)
336                                                 found = true;
337                                 }
338                                 break;
339                         }
340                 }
341                 // if we couldn't identify the weapon we just ignore it and continue checking for other weapons
342         }
343         if(first != -1)
344         {
345                 in_impulse = in_bestweapon_info[first].impulse;
346                 return;
347         }
348         // if we couldn't find any of the weapons, there's nothing more we can do...
349 }
350
351 /*
352 ===============
353 CL_KeyState
354
355 Returns 0.25 if a key was pressed and released during the frame,
356 0.5 if it was pressed and held
357 0 if held then released, and
358 1.0 if held for the entire time
359 ===============
360 */
361 float CL_KeyState (kbutton_t *key)
362 {
363         float           val;
364         qboolean        impulsedown, impulseup, down;
365
366         impulsedown = key->state & 2;
367         impulseup = key->state & 4;
368         down = key->state & 1;
369         val = 0;
370
371         if (impulsedown && !impulseup)
372         {
373                 if (down)
374                         val = 0.5;      // pressed and held this frame
375                 else
376                         val = 0;        //      I_Error ();
377         }
378         if (impulseup && !impulsedown)
379         {
380                 if (down)
381                         val = 0;        //      I_Error ();
382                 else
383                         val = 0;        // released this frame
384         }
385         if (!impulsedown && !impulseup)
386         {
387                 if (down)
388                         val = 1.0;      // held the entire frame
389                 else
390                         val = 0;        // up the entire frame
391         }
392         if (impulsedown && impulseup)
393         {
394                 if (down)
395                         val = 0.75;     // released and re-pressed this frame
396                 else
397                         val = 0.25;     // pressed and released this frame
398         }
399
400         key->state &= 1;                // clear impulses
401
402         return val;
403 }
404
405
406
407
408 //==========================================================================
409
410 cvar_t cl_upspeed = {CVAR_SAVE, "cl_upspeed","400","vertical movement speed (while swimming or flying)"};
411 cvar_t cl_forwardspeed = {CVAR_SAVE, "cl_forwardspeed","400","forward movement speed"};
412 cvar_t cl_backspeed = {CVAR_SAVE, "cl_backspeed","400","backward movement speed"};
413 cvar_t cl_sidespeed = {CVAR_SAVE, "cl_sidespeed","350","strafe movement speed"};
414
415 cvar_t cl_movespeedkey = {CVAR_SAVE, "cl_movespeedkey","2.0","how much +speed multiplies keyboard movement speed"};
416
417 cvar_t cl_yawspeed = {CVAR_SAVE, "cl_yawspeed","140","keyboard yaw turning speed"};
418 cvar_t cl_pitchspeed = {CVAR_SAVE, "cl_pitchspeed","150","keyboard pitch turning speed"};
419
420 cvar_t cl_anglespeedkey = {CVAR_SAVE, "cl_anglespeedkey","1.5","how much +speed multiplies keyboard turning speed"};
421
422 cvar_t cl_movement = {CVAR_SAVE, "cl_movement", "0", "enables clientside prediction of your player movement"};
423 cvar_t cl_movement_minping = {CVAR_SAVE, "cl_movement_minping", "0", "whether to use prediction when ping is lower than this value in milliseconds"};
424 cvar_t cl_movement_track_canjump = {CVAR_SAVE, "cl_movement_track_canjump", "1", "track if the player released the jump key between two jumps to decide if he is able to jump or not; when off, this causes some \"sliding\" slightly above the floor when the jump key is held too long; if the mod allows repeated jumping by holding space all the time, this has to be set to zero too"};
425 cvar_t cl_movement_maxspeed = {0, "cl_movement_maxspeed", "320", "how fast you can move (should match sv_maxspeed)"};
426 cvar_t cl_movement_maxairspeed = {0, "cl_movement_maxairspeed", "30", "how fast you can move while in the air (should match sv_maxairspeed)"};
427 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)"};
428 cvar_t cl_movement_friction = {0, "cl_movement_friction", "4", "how fast you slow down (should match sv_friction)"};
429 cvar_t cl_movement_wallfriction = {0, "cl_movement_wallfriction", "1", "how fast you slow down while sliding along a wall (should match sv_wallfriction)"};
430 cvar_t cl_movement_waterfriction = {0, "cl_movement_waterfriction", "-1", "how fast you slow down (should match sv_waterfriction), if less than 0 the cl_movement_friction variable is used instead"};
431 cvar_t cl_movement_edgefriction = {0, "cl_movement_edgefriction", "1", "how much to slow down when you may be about to fall off a ledge (should match edgefriction)"};
432 cvar_t cl_movement_stepheight = {0, "cl_movement_stepheight", "18", "how tall a step you can step in one instant (should match sv_stepheight)"};
433 cvar_t cl_movement_accelerate = {0, "cl_movement_accelerate", "10", "how fast you accelerate (should match sv_accelerate)"};
434 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"};
435 cvar_t cl_movement_wateraccelerate = {0, "cl_movement_wateraccelerate", "-1", "how fast you accelerate while in water (should match sv_wateraccelerate), if less than 0 the cl_movement_accelerate variable is used instead"};
436 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)"};
437 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)"};
438 cvar_t cl_movement_airaccel_sideways_friction = {0, "cl_movement_airaccel_sideways_friction", "0", "anti-sideways movement stabilization (should match sv_airaccel_sideways_friction)"};
439
440 cvar_t in_pitch_min = {0, "in_pitch_min", "-90", "how far downward you can aim (quake used -70"};
441 cvar_t in_pitch_max = {0, "in_pitch_max", "90", "how far upward you can aim (quake used 80"};
442
443 cvar_t m_filter = {CVAR_SAVE, "m_filter","0", "smoothes mouse movement, less responsive but smoother aiming"};
444
445 cvar_t cl_netfps = {CVAR_SAVE, "cl_netfps","20", "how many input packets to send to server each second"};
446 cvar_t cl_netrepeatinput = {CVAR_SAVE, "cl_netrepeatinput", "1", "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), only affects DP7 and later servers (Quake uses 0, QuakeWorld uses 2, and just for comparison Quake3 uses 1)"};
447 cvar_t cl_netimmediatebuttons = {CVAR_SAVE, "cl_netimmediatebuttons", "1", "sends extra packets whenever your buttons change or an impulse is used (basically: whenever you click fire or change weapon)"};
448
449 cvar_t cl_nodelta = {0, "cl_nodelta", "0", "disables delta compression of non-player entities in QW network protocol"};
450
451 extern cvar_t v_flipped;
452
453 /*
454 ================
455 CL_AdjustAngles
456
457 Moves the local angle positions
458 ================
459 */
460 void CL_AdjustAngles (void)
461 {
462         float   speed;
463         float   up, down;
464
465         if (in_speed.state & 1)
466                 speed = cl.realframetime * cl_anglespeedkey.value;
467         else
468                 speed = cl.realframetime;
469
470         if (!(in_strafe.state & 1))
471         {
472                 cl.viewangles[YAW] -= speed*cl_yawspeed.value*CL_KeyState (&in_right);
473                 cl.viewangles[YAW] += speed*cl_yawspeed.value*CL_KeyState (&in_left);
474         }
475         if (in_klook.state & 1)
476         {
477                 V_StopPitchDrift ();
478                 cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * CL_KeyState (&in_forward);
479                 cl.viewangles[PITCH] += speed*cl_pitchspeed.value * CL_KeyState (&in_back);
480         }
481
482         up = CL_KeyState (&in_lookup);
483         down = CL_KeyState(&in_lookdown);
484
485         cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * up;
486         cl.viewangles[PITCH] += speed*cl_pitchspeed.value * down;
487
488         if (up || down)
489                 V_StopPitchDrift ();
490
491         cl.viewangles[YAW] = ANGLEMOD(cl.viewangles[YAW]);
492         cl.viewangles[PITCH] = ANGLEMOD(cl.viewangles[PITCH]);
493         if (cl.viewangles[YAW] >= 180)
494                 cl.viewangles[YAW] -= 360;
495         if (cl.viewangles[PITCH] >= 180)
496                 cl.viewangles[PITCH] -= 360;
497         cl.viewangles[PITCH] = bound(in_pitch_min.value, cl.viewangles[PITCH], in_pitch_max.value);
498         cl.viewangles[ROLL] = bound(-180, cl.viewangles[ROLL], 180);
499 }
500
501 int cl_ignoremousemoves = 2;
502
503 /*
504 ================
505 CL_Input
506
507 Send the intended movement message to the server
508 ================
509 */
510 void CL_Input (void)
511 {
512         float mx, my;
513         static float old_mouse_x = 0, old_mouse_y = 0;
514
515         // clamp before the move to prevent starting with bad angles
516         CL_AdjustAngles ();
517
518         if(v_flipped.integer)
519                 cl.viewangles[YAW] = -cl.viewangles[YAW];
520
521         // reset some of the command fields
522         cl.cmd.forwardmove = 0;
523         cl.cmd.sidemove = 0;
524         cl.cmd.upmove = 0;
525
526         // get basic movement from keyboard
527         if (in_strafe.state & 1)
528         {
529                 cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_right);
530                 cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_left);
531         }
532
533         cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_moveright);
534         cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_moveleft);
535
536         cl.cmd.upmove += cl_upspeed.value * CL_KeyState (&in_up);
537         cl.cmd.upmove -= cl_upspeed.value * CL_KeyState (&in_down);
538
539         if (! (in_klook.state & 1) )
540         {
541                 cl.cmd.forwardmove += cl_forwardspeed.value * CL_KeyState (&in_forward);
542                 cl.cmd.forwardmove -= cl_backspeed.value * CL_KeyState (&in_back);
543         }
544
545         // adjust for speed key
546         if (in_speed.state & 1)
547         {
548                 cl.cmd.forwardmove *= cl_movespeedkey.value;
549                 cl.cmd.sidemove *= cl_movespeedkey.value;
550                 cl.cmd.upmove *= cl_movespeedkey.value;
551         }
552
553         // allow mice or other external controllers to add to the move
554         IN_Move ();
555
556         // apply m_filter if it is on
557         mx = in_mouse_x;
558         my = in_mouse_y;
559         if (m_filter.integer)
560         {
561                 in_mouse_x = (mx + old_mouse_x) * 0.5;
562                 in_mouse_y = (my + old_mouse_y) * 0.5;
563         }
564         old_mouse_x = mx;
565         old_mouse_y = my;
566
567         // ignore a mouse move if mouse was activated/deactivated this frame
568         if (cl_ignoremousemoves)
569         {
570                 cl_ignoremousemoves--;
571                 in_mouse_x = old_mouse_x = 0;
572                 in_mouse_y = old_mouse_y = 0;
573         }
574
575         // if not in menu, apply mouse move to viewangles/movement
576         if (!key_consoleactive && key_dest == key_game && !cl.csqc_wantsmousemove)
577         {
578                 float modulatedsensitivity = sensitivity.value * cl.sensitivityscale;
579                 if (cl_prydoncursor.integer)
580                 {
581                         // mouse interacting with the scene, mostly stationary view
582                         V_StopPitchDrift();
583                         cl.cmd.cursor_screen[0] += in_mouse_x * modulatedsensitivity / vid.width;
584                         cl.cmd.cursor_screen[1] += in_mouse_y * modulatedsensitivity / vid.height;
585                 }
586                 else if (in_strafe.state & 1)
587                 {
588                         // strafing mode, all looking is movement
589                         V_StopPitchDrift();
590                         cl.cmd.sidemove += m_side.value * in_mouse_x * modulatedsensitivity;
591                         if (noclip_anglehack)
592                                 cl.cmd.upmove -= m_forward.value * in_mouse_y * modulatedsensitivity;
593                         else
594                                 cl.cmd.forwardmove -= m_forward.value * in_mouse_y * modulatedsensitivity;
595                 }
596                 else if ((in_mlook.state & 1) || freelook.integer)
597                 {
598                         // mouselook, lookstrafe causes turning to become strafing
599                         V_StopPitchDrift();
600                         if (lookstrafe.integer)
601                                 cl.cmd.sidemove += m_side.value * in_mouse_x * modulatedsensitivity;
602                         else
603                                 cl.viewangles[YAW] -= m_yaw.value * in_mouse_x * modulatedsensitivity * cl.viewzoom;
604                         cl.viewangles[PITCH] += m_pitch.value * in_mouse_y * modulatedsensitivity * cl.viewzoom;
605                 }
606                 else
607                 {
608                         // non-mouselook, yaw turning and forward/back movement
609                         cl.viewangles[YAW] -= m_yaw.value * in_mouse_x * modulatedsensitivity * cl.viewzoom;
610                         cl.cmd.forwardmove -= m_forward.value * in_mouse_y * modulatedsensitivity;
611                 }
612         }
613         else // don't pitch drift when csqc is controlling the mouse
614                 V_StopPitchDrift();
615
616         if(v_flipped.integer)
617         {
618                 cl.viewangles[YAW] = -cl.viewangles[YAW];
619                 cl.cmd.sidemove = -cl.cmd.sidemove;
620         }
621
622         // clamp after the move to prevent rendering with bad angles
623         CL_AdjustAngles ();
624 }
625
626 #include "cl_collision.h"
627
628 void CL_UpdatePrydonCursor(void)
629 {
630         vec3_t temp;
631
632         if (!cl_prydoncursor.integer)
633                 VectorClear(cl.cmd.cursor_screen);
634
635         /*
636         if (cl.cmd.cursor_screen[0] < -1)
637         {
638                 cl.viewangles[YAW] -= m_yaw.value * (cl.cmd.cursor_screen[0] - -1) * vid.width * sensitivity.value * cl.viewzoom;
639                 cl.cmd.cursor_screen[0] = -1;
640         }
641         if (cl.cmd.cursor_screen[0] > 1)
642         {
643                 cl.viewangles[YAW] -= m_yaw.value * (cl.cmd.cursor_screen[0] - 1) * vid.width * sensitivity.value * cl.viewzoom;
644                 cl.cmd.cursor_screen[0] = 1;
645         }
646         if (cl.cmd.cursor_screen[1] < -1)
647         {
648                 cl.viewangles[PITCH] += m_pitch.value * (cl.cmd.cursor_screen[1] - -1) * vid.height * sensitivity.value * cl.viewzoom;
649                 cl.cmd.cursor_screen[1] = -1;
650         }
651         if (cl.cmd.cursor_screen[1] > 1)
652         {
653                 cl.viewangles[PITCH] += m_pitch.value * (cl.cmd.cursor_screen[1] - 1) * vid.height * sensitivity.value * cl.viewzoom;
654                 cl.cmd.cursor_screen[1] = 1;
655         }
656         */
657         cl.cmd.cursor_screen[0] = bound(-1, cl.cmd.cursor_screen[0], 1);
658         cl.cmd.cursor_screen[1] = bound(-1, cl.cmd.cursor_screen[1], 1);
659         cl.cmd.cursor_screen[2] = 1;
660
661         // calculate current view matrix
662         Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, cl.cmd.cursor_start);
663         // calculate direction vector of cursor in viewspace by using frustum slopes
664         VectorSet(temp, cl.cmd.cursor_screen[2] * 1000000, (v_flipped.integer ? -1 : 1) * cl.cmd.cursor_screen[0] * -r_refdef.view.frustum_x * 1000000, cl.cmd.cursor_screen[1] * -r_refdef.view.frustum_y * 1000000);
665         Matrix4x4_Transform(&r_refdef.view.matrix, temp, cl.cmd.cursor_end);
666         // trace from view origin to the cursor
667         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);
668 }
669
670 typedef enum waterlevel_e
671 {
672         WATERLEVEL_NONE,
673         WATERLEVEL_WETFEET,
674         WATERLEVEL_SWIMMING,
675         WATERLEVEL_SUBMERGED
676 }
677 waterlevel_t;
678
679 typedef struct cl_clientmovement_state_s
680 {
681         // position
682         vec3_t origin;
683         vec3_t velocity;
684         // current bounding box (different if crouched vs standing)
685         vec3_t mins;
686         vec3_t maxs;
687         // currently on the ground
688         qboolean onground;
689         // currently crouching
690         qboolean crouched;
691         // what kind of water (SUPERCONTENTS_LAVA for instance)
692         int watertype;
693         // how deep
694         waterlevel_t waterlevel;
695         // weird hacks when jumping out of water
696         // (this is in seconds and counts down to 0)
697         float waterjumptime;
698
699         // user command
700         usercmd_t cmd;
701 }
702 cl_clientmovement_state_t;
703
704 #define NUMOFFSETS 27
705 static vec3_t offsets[NUMOFFSETS] =
706 {
707 // 1 no nudge (just return the original if this test passes)
708         { 0.000,  0.000,  0.000},
709 // 6 simple nudges
710         { 0.000,  0.000,  0.125}, { 0.000,  0.000, -0.125},
711         {-0.125,  0.000,  0.000}, { 0.125,  0.000,  0.000},
712         { 0.000, -0.125,  0.000}, { 0.000,  0.125,  0.000},
713 // 4 diagonal flat nudges
714         {-0.125, -0.125,  0.000}, { 0.125, -0.125,  0.000},
715         {-0.125,  0.125,  0.000}, { 0.125,  0.125,  0.000},
716 // 8 diagonal upward nudges
717         {-0.125,  0.000,  0.125}, { 0.125,  0.000,  0.125},
718         { 0.000, -0.125,  0.125}, { 0.000,  0.125,  0.125},
719         {-0.125, -0.125,  0.125}, { 0.125, -0.125,  0.125},
720         {-0.125,  0.125,  0.125}, { 0.125,  0.125,  0.125},
721 // 8 diagonal downward nudges
722         {-0.125,  0.000, -0.125}, { 0.125,  0.000, -0.125},
723         { 0.000, -0.125, -0.125}, { 0.000,  0.125, -0.125},
724         {-0.125, -0.125, -0.125}, { 0.125, -0.125, -0.125},
725         {-0.125,  0.125, -0.125}, { 0.125,  0.125, -0.125},
726 };
727
728 qboolean CL_ClientMovement_Unstick(cl_clientmovement_state_t *s)
729 {
730         int i;
731         vec3_t neworigin;
732         for (i = 0;i < NUMOFFSETS;i++)
733         {
734                 VectorAdd(offsets[i], s->origin, neworigin);
735                 if (!CL_Move(neworigin, cl.playercrouchmins, cl.playercrouchmaxs, neworigin, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true, true, NULL, false).startsolid)
736                 {
737                         VectorCopy(neworigin, s->origin);
738                         return true;
739                 }
740         }
741         // if all offsets failed, give up
742         return false;
743 }
744
745 void CL_ClientMovement_UpdateStatus(cl_clientmovement_state_t *s)
746 {
747         vec3_t origin1, origin2;
748         trace_t trace;
749
750         // make sure player is not stuck
751         CL_ClientMovement_Unstick(s);
752
753         // set crouched
754         if (s->cmd.crouch)
755         {
756                 // wants to crouch, this always works..
757                 if (!s->crouched)
758                         s->crouched = true;
759         }
760         else
761         {
762                 // wants to stand, if currently crouching we need to check for a
763                 // low ceiling first
764                 if (s->crouched)
765                 {
766                         trace = CL_Move(s->origin, cl.playerstandmins, cl.playerstandmaxs, s->origin, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true, true, NULL, false);
767                         if (!trace.startsolid)
768                                 s->crouched = false;
769                 }
770         }
771         if (s->crouched)
772         {
773                 VectorCopy(cl.playercrouchmins, s->mins);
774                 VectorCopy(cl.playercrouchmaxs, s->maxs);
775         }
776         else
777         {
778                 VectorCopy(cl.playerstandmins, s->mins);
779                 VectorCopy(cl.playerstandmaxs, s->maxs);
780         }
781
782         // set onground
783         VectorSet(origin1, s->origin[0], s->origin[1], s->origin[2] + 1);
784         VectorSet(origin2, s->origin[0], s->origin[1], s->origin[2] - 2);
785         trace = CL_Move(origin1, s->mins, s->maxs, origin2, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true, true, NULL, false);
786         s->onground = trace.fraction < 1 && trace.plane.normal[2] > 0.7;
787
788         // set watertype/waterlevel
789         VectorSet(origin1, s->origin[0], s->origin[1], s->origin[2] + s->mins[2] + 1);
790         s->waterlevel = WATERLEVEL_NONE;
791         s->watertype = CL_Move(origin1, vec3_origin, vec3_origin, origin1, MOVE_NOMONSTERS, NULL, 0, true, false, NULL, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK;
792         if (s->watertype)
793         {
794                 s->waterlevel = WATERLEVEL_WETFEET;
795                 origin1[2] = s->origin[2] + (s->mins[2] + s->maxs[2]) * 0.5f;
796                 if (CL_Move(origin1, vec3_origin, vec3_origin, origin1, MOVE_NOMONSTERS, NULL, 0, true, false, NULL, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK)
797                 {
798                         s->waterlevel = WATERLEVEL_SWIMMING;
799                         origin1[2] = s->origin[2] + 22;
800                         if (CL_Move(origin1, vec3_origin, vec3_origin, origin1, MOVE_NOMONSTERS, NULL, 0, true, false, NULL, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK)
801                                 s->waterlevel = WATERLEVEL_SUBMERGED;
802                 }
803         }
804
805         // water jump prediction
806         if (s->onground || s->velocity[2] <= 0 || s->waterjumptime <= 0)
807                 s->waterjumptime = 0;
808 }
809
810 void CL_ClientMovement_Move(cl_clientmovement_state_t *s)
811 {
812         int bump;
813         double t;
814         vec_t f;
815         vec3_t neworigin;
816         vec3_t currentorigin2;
817         vec3_t neworigin2;
818         vec3_t primalvelocity;
819         trace_t trace;
820         trace_t trace2;
821         trace_t trace3;
822         CL_ClientMovement_UpdateStatus(s);
823         VectorCopy(s->velocity, primalvelocity);
824         for (bump = 0, t = s->cmd.frametime;bump < 8 && VectorLength2(s->velocity) > 0;bump++)
825         {
826                 VectorMA(s->origin, t, s->velocity, neworigin);
827                 trace = CL_Move(s->origin, s->mins, s->maxs, neworigin, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true, true, NULL, false);
828                 if (trace.fraction < 1 && trace.plane.normal[2] == 0)
829                 {
830                         // may be a step or wall, try stepping up
831                         // first move forward at a higher level
832                         VectorSet(currentorigin2, s->origin[0], s->origin[1], s->origin[2] + cl.movevars_stepheight);
833                         VectorSet(neworigin2, neworigin[0], neworigin[1], s->origin[2] + cl.movevars_stepheight);
834                         trace2 = CL_Move(currentorigin2, s->mins, s->maxs, neworigin2, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true, true, NULL, false);
835                         if (!trace2.startsolid)
836                         {
837                                 // then move down from there
838                                 VectorCopy(trace2.endpos, currentorigin2);
839                                 VectorSet(neworigin2, trace2.endpos[0], trace2.endpos[1], s->origin[2]);
840                                 trace3 = CL_Move(currentorigin2, s->mins, s->maxs, neworigin2, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true, true, NULL, false);
841                                 //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]);
842                                 // accept the new trace if it made some progress
843                                 if (fabs(trace3.endpos[0] - trace.endpos[0]) >= 0.03125 || fabs(trace3.endpos[1] - trace.endpos[1]) >= 0.03125)
844                                 {
845                                         trace = trace2;
846                                         VectorCopy(trace3.endpos, trace.endpos);
847                                 }
848                         }
849                 }
850
851                 // check if it moved at all
852                 if (trace.fraction >= 0.001)
853                         VectorCopy(trace.endpos, s->origin);
854
855                 // check if it moved all the way
856                 if (trace.fraction == 1)
857                         break;
858
859                 //if (trace.plane.normal[2] > 0.7)
860                 //      s->onground = true;
861
862                 t -= t * trace.fraction;
863
864                 f = DotProduct(s->velocity, trace.plane.normal);
865                 VectorMA(s->velocity, -f, trace.plane.normal, s->velocity);
866         }
867         if (s->waterjumptime > 0)
868                 VectorCopy(primalvelocity, s->velocity);
869 }
870
871
872 void CL_ClientMovement_Physics_Swim(cl_clientmovement_state_t *s)
873 {
874         vec_t wishspeed;
875         vec_t f;
876         vec3_t wishvel;
877         vec3_t wishdir;
878
879         // water jump only in certain situations
880         // this mimics quakeworld code
881         if (s->cmd.jump && s->waterlevel == 2 && s->velocity[2] >= -180)
882         {
883                 vec3_t forward;
884                 vec3_t yawangles;
885                 vec3_t spot;
886                 VectorSet(yawangles, 0, s->cmd.viewangles[1], 0);
887                 AngleVectors(yawangles, forward, NULL, NULL);
888                 VectorMA(s->origin, 24, forward, spot);
889                 spot[2] += 8;
890                 if (CL_Move(spot, vec3_origin, vec3_origin, spot, MOVE_NOMONSTERS, NULL, 0, true, false, NULL, false).startsolid)
891                 {
892                         spot[2] += 24;
893                         if (!CL_Move(spot, vec3_origin, vec3_origin, spot, MOVE_NOMONSTERS, NULL, 0, true, false, NULL, false).startsolid)
894                         {
895                                 VectorScale(forward, 50, s->velocity);
896                                 s->velocity[2] = 310;
897                                 s->waterjumptime = 2;
898                                 s->onground = false;
899                                 s->cmd.canjump = false;
900                         }
901                 }
902         }
903
904         if (!(s->cmd.forwardmove*s->cmd.forwardmove + s->cmd.sidemove*s->cmd.sidemove + s->cmd.upmove*s->cmd.upmove))
905         {
906                 // drift towards bottom
907                 VectorSet(wishvel, 0, 0, -60);
908         }
909         else
910         {
911                 // swim
912                 vec3_t forward;
913                 vec3_t right;
914                 vec3_t up;
915                 // calculate movement vector
916                 AngleVectors(s->cmd.viewangles, forward, right, up);
917                 VectorSet(up, 0, 0, 1);
918                 VectorMAMAM(s->cmd.forwardmove, forward, s->cmd.sidemove, right, s->cmd.upmove, up, wishvel);
919         }
920
921         // split wishvel into wishspeed and wishdir
922         wishspeed = VectorLength(wishvel);
923         if (wishspeed)
924                 VectorScale(wishvel, 1 / wishspeed, wishdir);
925         else
926                 VectorSet( wishdir, 0.0, 0.0, 0.0 );
927         wishspeed = min(wishspeed, cl.movevars_maxspeed) * 0.7;
928
929         if (s->crouched)
930                 wishspeed *= 0.5;
931
932         if (s->waterjumptime <= 0)
933         {
934                 // water friction
935                 f = 1 - s->cmd.frametime * cl.movevars_waterfriction * (cls.protocol == PROTOCOL_QUAKEWORLD ? s->waterlevel : 1);
936                 f = bound(0, f, 1);
937                 VectorScale(s->velocity, f, s->velocity);
938
939                 // water acceleration
940                 f = wishspeed - DotProduct(s->velocity, wishdir);
941                 if (f > 0)
942                 {
943                         f = min(cl.movevars_wateraccelerate * s->cmd.frametime * wishspeed, f);
944                         VectorMA(s->velocity, f, wishdir, s->velocity);
945                 }
946
947                 // holding jump button swims upward slowly
948                 if (s->cmd.jump)
949                 {
950                         if (s->watertype & SUPERCONTENTS_LAVA)
951                                 s->velocity[2] =  50;
952                         else if (s->watertype & SUPERCONTENTS_SLIME)
953                                 s->velocity[2] =  80;
954                         else
955                         {
956                                 if (gamemode == GAME_NEXUIZ)
957                                         s->velocity[2] = 200;
958                                 else
959                                         s->velocity[2] = 100;
960                         }
961                 }
962         }
963
964         CL_ClientMovement_Move(s);
965 }
966
967 void CL_ClientMovement_Physics_CPM_PM_Aircontrol(cl_clientmovement_state_t *s, vec3_t wishdir, vec_t wishspeed)
968 {
969         vec_t zspeed, speed, dot, k;
970
971         if(s->cmd.forwardmove == 0 || s->cmd.sidemove != 0)
972                 return;
973         
974         zspeed = s->velocity[2];
975         s->velocity[2] = 0;
976         speed = VectorNormalizeLength(s->velocity);
977
978         dot = DotProduct(s->velocity, wishdir);
979         k = 32;
980         k *= cl.movevars_aircontrol*dot*dot*s->cmd.frametime;
981
982         if(dot > 0) { // we can't change direction while slowing down
983                 VectorMAM(speed, s->velocity, k, wishdir, s->velocity);
984                 VectorNormalize(s->velocity);
985         }
986
987         VectorScale(s->velocity, speed, s->velocity);
988         s->velocity[2] = zspeed;
989 }
990
991 void CL_ClientMovement_Physics_PM_Accelerate(cl_clientmovement_state_t *s, vec3_t wishdir, vec_t wishspeed, vec_t accel, vec_t accelqw, vec_t sidefric)
992 {
993         vec_t vel_straight, vel_z;
994         vec3_t vel_perpend;
995         vec_t addspeed;
996
997         vel_straight = DotProduct(s->velocity, wishdir);
998         vel_z = s->velocity[2];
999         VectorMA(s->velocity, -vel_straight, wishdir, vel_perpend); vel_perpend[2] -= vel_z;
1000
1001         addspeed = wishspeed - vel_straight;
1002         if(addspeed > 0)
1003                 vel_straight = vel_straight + min(addspeed, accel * s->cmd.frametime * wishspeed) * accelqw;
1004         if(wishspeed > 0)
1005                 vel_straight = vel_straight + min(wishspeed, accel * s->cmd.frametime * wishspeed) * (1 - accelqw);
1006         
1007         VectorScale(vel_perpend, 1 - s->cmd.frametime * wishspeed * sidefric, vel_perpend);
1008
1009         VectorMA(vel_perpend, vel_straight, wishdir, s->velocity);
1010         s->velocity[2] += vel_z;
1011 }
1012
1013 void CL_ClientMovement_Physics_PM_AirAccelerate(cl_clientmovement_state_t *s, vec3_t wishdir, vec_t wishspeed)
1014 {
1015     vec3_t curvel, wishvel, acceldir, curdir;
1016     float addspeed, accelspeed, curspeed;
1017     float dot;
1018
1019     float airforwardaccel = cl.movevars_warsowbunny_airforwardaccel;
1020     float bunnyaccel = cl.movevars_warsowbunny_accel;
1021     float bunnytopspeed = cl.movevars_warsowbunny_topspeed;
1022     float turnaccel = cl.movevars_warsowbunny_turnaccel;
1023     float backtosideratio = cl.movevars_warsowbunny_backtosideratio;
1024
1025     if( !wishspeed )
1026         return;
1027
1028     VectorCopy( s->velocity, curvel );
1029     curvel[2] = 0;
1030     curspeed = VectorLength( curvel );
1031
1032     if( wishspeed > curspeed * 1.01f )
1033     {
1034         float accelspeed = curspeed + airforwardaccel * cl.movevars_maxairspeed * s->cmd.frametime;
1035         if( accelspeed < wishspeed )
1036             wishspeed = accelspeed;
1037     }
1038     else
1039     {
1040         float f = ( bunnytopspeed - curspeed ) / ( bunnytopspeed - cl.movevars_maxairspeed );
1041         if( f < 0 )
1042             f = 0;
1043         wishspeed = max( curspeed, cl.movevars_maxairspeed ) + bunnyaccel * f * cl.movevars_maxairspeed * s->cmd.frametime;
1044     }
1045     VectorScale( wishdir, wishspeed, wishvel );
1046     VectorSubtract( wishvel, curvel, acceldir );
1047     addspeed = VectorNormalizeLength( acceldir );
1048
1049     accelspeed = turnaccel * cl.movevars_maxairspeed /* wishspeed */ * s->cmd.frametime;
1050     if( accelspeed > addspeed )
1051         accelspeed = addspeed;
1052
1053     if( backtosideratio < 1.0f )
1054     {
1055         VectorNormalize2( curvel, curdir );
1056         dot = DotProduct( acceldir, curdir );
1057         if( dot < 0 )
1058             VectorMA( acceldir, -( 1.0f - backtosideratio ) * dot, curdir, acceldir );
1059     }
1060
1061     VectorMA( s->velocity, accelspeed, acceldir, s->velocity );
1062 }
1063
1064 void CL_ClientMovement_Physics_Walk(cl_clientmovement_state_t *s)
1065 {
1066         vec_t friction;
1067         vec_t wishspeed;
1068         vec_t addspeed;
1069         vec_t accelspeed;
1070         vec_t f;
1071         vec3_t forward;
1072         vec3_t right;
1073         vec3_t up;
1074         vec3_t wishvel;
1075         vec3_t wishdir;
1076         vec3_t yawangles;
1077         trace_t trace;
1078
1079         // jump if on ground with jump button pressed but only if it has been
1080         // released at least once since the last jump
1081         if (s->cmd.jump)
1082         {
1083                 if (s->onground && (s->cmd.canjump || !cl_movement_track_canjump.integer)) // FIXME remove this cvar again when canjump logic actually works, or maybe keep it for mods that allow "pogo-ing"
1084                 {
1085                         s->velocity[2] += cl.movevars_jumpvelocity;
1086                         s->onground = false;
1087                         s->cmd.canjump = false;
1088                 }
1089         }
1090         else
1091                 s->cmd.canjump = true;
1092
1093         // calculate movement vector
1094         VectorSet(yawangles, 0, s->cmd.viewangles[1], 0);
1095         AngleVectors(yawangles, forward, right, up);
1096         VectorMAM(s->cmd.forwardmove, forward, s->cmd.sidemove, right, wishvel);
1097
1098         // split wishvel into wishspeed and wishdir
1099         wishspeed = VectorLength(wishvel);
1100         if (wishspeed)
1101                 VectorScale(wishvel, 1 / wishspeed, wishdir);
1102         else
1103                 VectorSet( wishdir, 0.0, 0.0, 0.0 );
1104         // check if onground
1105         if (s->onground)
1106         {
1107                 wishspeed = min(wishspeed, cl.movevars_maxspeed);
1108                 if (s->crouched)
1109                         wishspeed *= 0.5;
1110
1111                 // apply edge friction
1112                 f = sqrt(s->velocity[0] * s->velocity[0] + s->velocity[1] * s->velocity[1]);
1113                 if (f > 0)
1114                 {
1115                         friction = cl.movevars_friction;
1116                         if (cl.movevars_edgefriction != 1)
1117                         {
1118                                 vec3_t neworigin2;
1119                                 vec3_t neworigin3;
1120                                 // note: QW uses the full player box for the trace, and yet still
1121                                 // uses s->origin[2] + s->mins[2], which is clearly an bug, but
1122                                 // this mimics it for compatibility
1123                                 VectorSet(neworigin2, s->origin[0] + s->velocity[0]*(16/f), s->origin[1] + s->velocity[1]*(16/f), s->origin[2] + s->mins[2]);
1124                                 VectorSet(neworigin3, neworigin2[0], neworigin2[1], neworigin2[2] - 34);
1125                                 if (cls.protocol == PROTOCOL_QUAKEWORLD)
1126                                         trace = CL_Move(neworigin2, s->mins, s->maxs, neworigin3, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true, true, NULL, false);
1127                                 else
1128                                         trace = CL_Move(neworigin2, vec3_origin, vec3_origin, neworigin3, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true, true, NULL, false);
1129                                 if (trace.fraction == 1 && !trace.startsolid)
1130                                         friction *= cl.movevars_edgefriction;
1131                         }
1132                         // apply ground friction
1133                         f = 1 - s->cmd.frametime * friction * ((f < cl.movevars_stopspeed) ? (cl.movevars_stopspeed / f) : 1);
1134                         f = max(f, 0);
1135                         VectorScale(s->velocity, f, s->velocity);
1136                 }
1137                 addspeed = wishspeed - DotProduct(s->velocity, wishdir);
1138                 if (addspeed > 0)
1139                 {
1140                         accelspeed = min(cl.movevars_accelerate * s->cmd.frametime * wishspeed, addspeed);
1141                         VectorMA(s->velocity, accelspeed, wishdir, s->velocity);
1142                 }
1143                 s->velocity[2] -= cl.movevars_gravity * cl.movevars_entgravity * s->cmd.frametime;
1144                 if (cls.protocol == PROTOCOL_QUAKEWORLD)
1145                         s->velocity[2] = 0;
1146                 if (VectorLength2(s->velocity))
1147                         CL_ClientMovement_Move(s);
1148         }
1149         else
1150         {
1151                 if (s->waterjumptime <= 0)
1152                 {
1153                         // apply air speed limit
1154                         vec_t accel, wishspeed2;
1155                         qboolean accelerating;
1156
1157                         wishspeed = min(wishspeed, cl.movevars_maxairspeed);
1158                         if (s->crouched)
1159                                 wishspeed *= 0.5;
1160                         accel = cl.movevars_airaccelerate;
1161
1162                         accelerating = (DotProduct(s->velocity, wishdir) > 0);
1163                         wishspeed2 = wishspeed;
1164
1165                         // CPM: air control
1166                         if(cl.movevars_airstopaccelerate != 0)
1167                                 if(DotProduct(s->velocity, wishdir) < 0)
1168                                         accel = cl.movevars_airstopaccelerate;
1169                         if(s->cmd.forwardmove == 0 && s->cmd.sidemove != 0)
1170                         {
1171                                 if(cl.movevars_maxairstrafespeed)
1172                                         if(wishspeed > cl.movevars_maxairstrafespeed)
1173                                                 wishspeed = cl.movevars_maxairstrafespeed;
1174                                 if(cl.movevars_airstrafeaccelerate)
1175                                         accel = cl.movevars_airstrafeaccelerate;
1176                         }
1177                         // !CPM
1178
1179                         if(cl.movevars_warsowbunny_turnaccel && accelerating && s->cmd.sidemove == 0 && s->cmd.forwardmove != 0)
1180                                 CL_ClientMovement_Physics_PM_AirAccelerate(s, wishdir, wishspeed2);
1181                         else
1182                                 CL_ClientMovement_Physics_PM_Accelerate(s, wishdir, wishspeed, accel, cl.movevars_airaccel_qw, cl.movevars_airaccel_sideways_friction / cl.movevars_maxairspeed);
1183
1184                         if(cl.movevars_aircontrol)
1185                                 CL_ClientMovement_Physics_CPM_PM_Aircontrol(s, wishdir, wishspeed2);
1186                 }
1187                 s->velocity[2] -= cl.movevars_gravity * cl.movevars_entgravity * s->cmd.frametime;
1188                 CL_ClientMovement_Move(s);
1189         }
1190 }
1191
1192 void CL_ClientMovement_PlayerMove(cl_clientmovement_state_t *s)
1193 {
1194         //Con_Printf(" %f", frametime);
1195         if (!s->cmd.jump)
1196                 s->cmd.canjump = true;
1197         s->waterjumptime -= s->cmd.frametime;
1198         CL_ClientMovement_UpdateStatus(s);
1199         if (s->waterlevel >= WATERLEVEL_SWIMMING)
1200                 CL_ClientMovement_Physics_Swim(s);
1201         else
1202                 CL_ClientMovement_Physics_Walk(s);
1203 }
1204
1205 extern cvar_t slowmo;
1206 void CL_UpdateMoveVars(void)
1207 {
1208         if (cls.protocol == PROTOCOL_QUAKEWORLD)
1209         {
1210         }
1211         else if (cl.stats[STAT_MOVEVARS_TICRATE])
1212         {
1213                 cl.movevars_timescale = cl.statsf[STAT_MOVEVARS_TIMESCALE];
1214                 cl.movevars_gravity = cl.statsf[STAT_MOVEVARS_GRAVITY];
1215                 cl.movevars_stopspeed = cl.statsf[STAT_MOVEVARS_STOPSPEED] ;
1216                 cl.movevars_maxspeed = cl.statsf[STAT_MOVEVARS_MAXSPEED];
1217                 cl.movevars_spectatormaxspeed = cl.statsf[STAT_MOVEVARS_SPECTATORMAXSPEED];
1218                 cl.movevars_accelerate = cl.statsf[STAT_MOVEVARS_ACCELERATE];
1219                 cl.movevars_airaccelerate = cl.statsf[STAT_MOVEVARS_AIRACCELERATE];
1220                 cl.movevars_wateraccelerate = cl.statsf[STAT_MOVEVARS_WATERACCELERATE];
1221                 cl.movevars_entgravity = cl.statsf[STAT_MOVEVARS_ENTGRAVITY];
1222                 cl.movevars_jumpvelocity = cl.statsf[STAT_MOVEVARS_JUMPVELOCITY];
1223                 cl.movevars_edgefriction = cl.statsf[STAT_MOVEVARS_EDGEFRICTION];
1224                 cl.movevars_maxairspeed = cl.statsf[STAT_MOVEVARS_MAXAIRSPEED];
1225                 cl.movevars_stepheight = cl.statsf[STAT_MOVEVARS_STEPHEIGHT];
1226                 cl.movevars_airaccel_qw = cl.statsf[STAT_MOVEVARS_AIRACCEL_QW];
1227                 cl.movevars_airaccel_sideways_friction = cl.statsf[STAT_MOVEVARS_AIRACCEL_SIDEWAYS_FRICTION];
1228                 cl.movevars_friction = cl.statsf[STAT_MOVEVARS_FRICTION];
1229                 cl.movevars_wallfriction = cl.statsf[STAT_MOVEVARS_WALLFRICTION];
1230                 cl.movevars_waterfriction = cl.statsf[STAT_MOVEVARS_WATERFRICTION];
1231                 cl.movevars_airstopaccelerate = cl.statsf[STAT_MOVEVARS_AIRSTOPACCELERATE];
1232                 cl.movevars_airstrafeaccelerate = cl.statsf[STAT_MOVEVARS_AIRSTRAFEACCELERATE];
1233                 cl.movevars_maxairstrafespeed = cl.statsf[STAT_MOVEVARS_MAXAIRSTRAFESPEED];
1234                 cl.movevars_aircontrol = cl.statsf[STAT_MOVEVARS_AIRCONTROL];
1235                 cl.movevars_warsowbunny_airforwardaccel = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_AIRFORWARDACCEL];
1236                 cl.movevars_warsowbunny_accel = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_ACCEL];
1237                 cl.movevars_warsowbunny_topspeed = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_TOPSPEED];
1238                 cl.movevars_warsowbunny_turnaccel = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_TURNACCEL];
1239                 cl.movevars_warsowbunny_backtosideratio = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_BACKTOSIDERATIO];
1240         }
1241         else
1242         {
1243                 cl.movevars_timescale = slowmo.value;
1244                 cl.movevars_gravity = sv_gravity.value;
1245                 cl.movevars_stopspeed = cl_movement_stopspeed.value;
1246                 cl.movevars_maxspeed = cl_movement_maxspeed.value;
1247                 cl.movevars_spectatormaxspeed = cl_movement_maxspeed.value;
1248                 cl.movevars_accelerate = cl_movement_accelerate.value;
1249                 cl.movevars_airaccelerate = cl_movement_airaccelerate.value < 0 ? cl_movement_accelerate.value : cl_movement_airaccelerate.value;
1250                 cl.movevars_wateraccelerate = cl_movement_wateraccelerate.value < 0 ? cl_movement_accelerate.value : cl_movement_wateraccelerate.value;
1251                 cl.movevars_friction = cl_movement_friction.value;
1252                 cl.movevars_wallfriction = cl_movement_wallfriction.value;
1253                 cl.movevars_waterfriction = cl_movement_waterfriction.value < 0 ? cl_movement_friction.value : cl_movement_waterfriction.value;
1254                 cl.movevars_entgravity = 1;
1255                 cl.movevars_jumpvelocity = cl_movement_jumpvelocity.value;
1256                 cl.movevars_edgefriction = cl_movement_edgefriction.value;
1257                 cl.movevars_maxairspeed = cl_movement_maxairspeed.value;
1258                 cl.movevars_stepheight = cl_movement_stepheight.value;
1259                 cl.movevars_airaccel_qw = cl_movement_airaccel_qw.value;
1260                 cl.movevars_airaccel_sideways_friction = cl_movement_airaccel_sideways_friction.value;
1261                 cl.movevars_airstopaccelerate = 0;
1262                 cl.movevars_airstrafeaccelerate = 0;
1263                 cl.movevars_maxairstrafespeed = 0;
1264                 cl.movevars_aircontrol = 0;
1265                 cl.movevars_warsowbunny_airforwardaccel = 0;
1266                 cl.movevars_warsowbunny_accel = 0;
1267                 cl.movevars_warsowbunny_topspeed = 0;
1268                 cl.movevars_warsowbunny_turnaccel = 0;
1269                 cl.movevars_warsowbunny_backtosideratio = 0;
1270         }
1271 }
1272
1273 void CL_ClientMovement_Replay(void)
1274 {
1275         int i;
1276         double totalmovemsec;
1277         cl_clientmovement_state_t s;
1278
1279         if (cl.movement_predicted && !cl.movement_replay)
1280                 return;
1281
1282         // set up starting state for the series of moves
1283         memset(&s, 0, sizeof(s));
1284         VectorCopy(cl.entities[cl.playerentity].state_current.origin, s.origin);
1285         VectorCopy(cl.mvelocity[0], s.velocity);
1286         s.crouched = true; // will be updated on first move
1287         //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]);
1288
1289         totalmovemsec = 0;
1290         for (i = 0;i < CL_MAX_USERCMDS;i++)
1291                 if (cl.movecmd[i].sequence > cls.servermovesequence)
1292                         totalmovemsec += cl.movecmd[i].msec;
1293         cl.movement_predicted = totalmovemsec >= cl_movement_minping.value && cls.servermovesequence && (cl_movement.integer && !cls.demoplayback && cls.signon == SIGNONS && cl.stats[STAT_HEALTH] > 0 && !cl.intermission);
1294         //Con_Printf("%i = %.0f >= %.0f && %i && (%i && %i && %i == %i && %i > 0 && %i\n", cl.movement_predicted, totalmovemsec, cl_movement_minping.value, cls.servermovesequence, cl_movement.integer, !cls.demoplayback, cls.signon, SIGNONS, cl.stats[STAT_HEALTH], !cl.intermission);
1295         if (cl.movement_predicted)
1296         {
1297                 //Con_Printf("%ims\n", cl.movecmd[0].msec);
1298
1299                 // replay the input queue to predict current location
1300                 // note: this relies on the fact there's always one queue item at the end
1301
1302                 // find how many are still valid
1303                 for (i = 0;i < CL_MAX_USERCMDS;i++)
1304                         if (cl.movecmd[i].sequence <= cls.servermovesequence)
1305                                 break;
1306                 // now walk them in oldest to newest order
1307                 for (i--;i >= 0;i--)
1308                 {
1309                         s.cmd = cl.movecmd[i];
1310                         if (i < CL_MAX_USERCMDS - 1)
1311                                 s.cmd.canjump = cl.movecmd[i+1].canjump;
1312                         // if a move is more than 50ms, do it as two moves (matching qwsv)
1313                         //Con_Printf("%i ", s.cmd.msec);
1314                         if (s.cmd.frametime > 0.05)
1315                         {
1316                                 s.cmd.frametime /= 2;
1317                                 CL_ClientMovement_PlayerMove(&s);
1318                         }
1319                         CL_ClientMovement_PlayerMove(&s);
1320                         cl.movecmd[i].canjump = s.cmd.canjump;
1321                 }
1322                 //Con_Printf("\n");
1323         }
1324         else
1325         {
1326                 // get the first movement queue entry to know whether to crouch and such
1327                 s.cmd = cl.movecmd[0];
1328         }
1329         CL_ClientMovement_UpdateStatus(&s);
1330
1331         if (cls.demoplayback) // for bob, speedometer
1332                 VectorCopy(cl.mvelocity[0], cl.movement_velocity);
1333         else
1334         {
1335                 cl.movement_replay = false;
1336                 // update the interpolation target position and velocity
1337                 VectorCopy(s.origin, cl.movement_origin);
1338                 VectorCopy(s.velocity, cl.movement_velocity);
1339         }
1340
1341         // update the onground flag if appropriate
1342         if (cl.movement_predicted)
1343         {
1344                 // when predicted we simply set the flag according to the UpdateStatus
1345                 cl.onground = s.onground;
1346         }
1347         else
1348         {
1349                 // when not predicted, cl.onground is cleared by cl_parse.c each time
1350                 // an update packet is received, but can be forced on here to hide
1351                 // server inconsistencies in the onground flag
1352                 // (which mostly occur when stepping up stairs at very high framerates
1353                 //  where after the step up the move continues forward and not
1354                 //  downward so the ground is not detected)
1355                 //
1356                 // such onground inconsistencies can cause jittery gun bobbing and
1357                 // stair smoothing, so we set onground if UpdateStatus says so
1358                 if (s.onground)
1359                         cl.onground = true;
1360         }
1361
1362         // react to onground state changes (for gun bob)
1363         if (cl.onground)
1364         {
1365                 if (!cl.oldonground)
1366                         cl.hitgroundtime = cl.movecmd[0].time;
1367                 cl.lastongroundtime = cl.movecmd[0].time;
1368         }
1369         cl.oldonground = cl.onground;
1370 }
1371
1372 void QW_MSG_WriteDeltaUsercmd(sizebuf_t *buf, usercmd_t *from, usercmd_t *to)
1373 {
1374         int bits;
1375
1376         bits = 0;
1377         if (to->viewangles[0] != from->viewangles[0])
1378                 bits |= QW_CM_ANGLE1;
1379         if (to->viewangles[1] != from->viewangles[1])
1380                 bits |= QW_CM_ANGLE2;
1381         if (to->viewangles[2] != from->viewangles[2])
1382                 bits |= QW_CM_ANGLE3;
1383         if (to->forwardmove != from->forwardmove)
1384                 bits |= QW_CM_FORWARD;
1385         if (to->sidemove != from->sidemove)
1386                 bits |= QW_CM_SIDE;
1387         if (to->upmove != from->upmove)
1388                 bits |= QW_CM_UP;
1389         if (to->buttons != from->buttons)
1390                 bits |= QW_CM_BUTTONS;
1391         if (to->impulse != from->impulse)
1392                 bits |= QW_CM_IMPULSE;
1393
1394         MSG_WriteByte(buf, bits);
1395         if (bits & QW_CM_ANGLE1)
1396                 MSG_WriteAngle16i(buf, to->viewangles[0]);
1397         if (bits & QW_CM_ANGLE2)
1398                 MSG_WriteAngle16i(buf, to->viewangles[1]);
1399         if (bits & QW_CM_ANGLE3)
1400                 MSG_WriteAngle16i(buf, to->viewangles[2]);
1401         if (bits & QW_CM_FORWARD)
1402                 MSG_WriteShort(buf, (short) to->forwardmove);
1403         if (bits & QW_CM_SIDE)
1404                 MSG_WriteShort(buf, (short) to->sidemove);
1405         if (bits & QW_CM_UP)
1406                 MSG_WriteShort(buf, (short) to->upmove);
1407         if (bits & QW_CM_BUTTONS)
1408                 MSG_WriteByte(buf, to->buttons);
1409         if (bits & QW_CM_IMPULSE)
1410                 MSG_WriteByte(buf, to->impulse);
1411         MSG_WriteByte(buf, to->msec);
1412 }
1413
1414 /*
1415 ==============
1416 CL_SendMove
1417 ==============
1418 */
1419 usercmd_t nullcmd; // for delta compression of qw moves
1420 void CL_SendMove(void)
1421 {
1422         int i, j, packetloss;
1423         int checksumindex;
1424         int bits;
1425         int maxusercmds;
1426         usercmd_t *cmd;
1427         sizebuf_t buf;
1428         unsigned char data[1024];
1429         double packettime;
1430         int msecdelta;
1431
1432         // if playing a demo, do nothing
1433         if (!cls.netcon)
1434                 return;
1435
1436         // we build up cl.movecmd[0] and then decide whether to send or not
1437         // the prediction code will use this command even though it has not been
1438         // sent yet
1439         cl.cmd.time = cl.time;
1440         cl.cmd.sequence = cls.netcon->outgoing_unreliable_sequence;
1441
1442         // set button bits
1443         // LordHavoc: added 6 new buttons and use and chat buttons, and prydon cursor active button
1444         bits = 0;
1445         if (in_attack.state   & 3) bits |=   1;
1446         if (in_jump.state     & 3) bits |=   2;
1447         if (in_button3.state  & 3) bits |=   4;
1448         if (in_button4.state  & 3) bits |=   8;
1449         if (in_button5.state  & 3) bits |=  16;
1450         if (in_button6.state  & 3) bits |=  32;
1451         if (in_button7.state  & 3) bits |=  64;
1452         if (in_button8.state  & 3) bits |= 128;
1453         if (in_use.state      & 3) bits |= 256;
1454         if (key_dest != key_game || key_consoleactive) bits |= 512;
1455         if (cl_prydoncursor.integer) bits |= 1024;
1456         if (in_button9.state  & 3)  bits |=   2048;
1457         if (in_button10.state  & 3) bits |=   4096;
1458         if (in_button11.state  & 3) bits |=   8192;
1459         if (in_button12.state  & 3) bits |=  16384;
1460         if (in_button13.state  & 3) bits |=  32768;
1461         if (in_button14.state  & 3) bits |=  65536;
1462         if (in_button15.state  & 3) bits |= 131072;
1463         if (in_button16.state  & 3) bits |= 262144;
1464         // button bits 19-31 unused currently
1465         // rotate/zoom view serverside if PRYDON_CLIENTCURSOR cursor is at edge of screen
1466         if (cl.cmd.cursor_screen[0] <= -1) bits |= 8;
1467         if (cl.cmd.cursor_screen[0] >=  1) bits |= 16;
1468         if (cl.cmd.cursor_screen[1] <= -1) bits |= 32;
1469         if (cl.cmd.cursor_screen[1] >=  1) bits |= 64;
1470
1471         // set buttons and impulse
1472         cl.cmd.buttons = bits;
1473         cl.cmd.impulse = in_impulse;
1474
1475         // set viewangles
1476         VectorCopy(cl.viewangles, cl.cmd.viewangles);
1477
1478         msecdelta = (int)(floor(cl.cmd.time * 1000) - floor(cl.movecmd[1].time * 1000));
1479         cl.cmd.msec = (unsigned char)bound(0, msecdelta, 255);
1480         // ridiculous value rejection (matches qw)
1481         if (cl.cmd.msec > 250)
1482                 cl.cmd.msec = 100;
1483         cl.cmd.frametime = cl.cmd.msec * (1.0 / 1000.0);
1484
1485         cl.cmd.predicted = cl_movement.integer;
1486
1487         // movement is set by input code (forwardmove/sidemove/upmove)
1488         // always dump the first two moves, because they may contain leftover inputs from the last level
1489         if (cl.cmd.sequence <= 2)
1490                 cl.cmd.forwardmove = cl.cmd.sidemove = cl.cmd.upmove = cl.cmd.impulse = cl.cmd.buttons = 0;
1491
1492         cl.cmd.jump = (cl.cmd.buttons & 2) != 0;
1493         cl.cmd.crouch = 0;
1494         switch (cls.protocol)
1495         {
1496         case PROTOCOL_QUAKEWORLD:
1497         case PROTOCOL_QUAKE:
1498         case PROTOCOL_QUAKEDP:
1499         case PROTOCOL_NEHAHRAMOVIE:
1500         case PROTOCOL_NEHAHRABJP:
1501         case PROTOCOL_NEHAHRABJP2:
1502         case PROTOCOL_NEHAHRABJP3:
1503         case PROTOCOL_DARKPLACES1:
1504         case PROTOCOL_DARKPLACES2:
1505         case PROTOCOL_DARKPLACES3:
1506         case PROTOCOL_DARKPLACES4:
1507         case PROTOCOL_DARKPLACES5:
1508                 break;
1509         case PROTOCOL_DARKPLACES6:
1510         case PROTOCOL_DARKPLACES7:
1511                 // FIXME: cl.movecmd[0].buttons & 16 is +button5, Nexuiz specific
1512                 cl.cmd.crouch = (cl.cmd.buttons & 16) != 0;
1513                 break;
1514         case PROTOCOL_UNKNOWN:
1515                 break;
1516         }
1517
1518         cl.movecmd[0] = cl.cmd;
1519
1520         // don't predict more than 200fps
1521         if (realtime >= cl.lastpackettime + 0.005)
1522                 cl.movement_replay = true; // redo the prediction
1523
1524         // now decide whether to actually send this move
1525         // (otherwise it is only for prediction)
1526
1527         // don't send too often or else network connections can get clogged by a
1528         // high renderer framerate
1529         packettime = 1.0 / bound(1, cl_netfps.value, 1000);
1530         // send input every frame in singleplayer
1531         if (cl.islocalgame)
1532                 packettime = 0;
1533         // always send if buttons changed or an impulse is pending
1534         // even if it violates the rate limit!
1535         if (!cl.movecmd[0].impulse && (!cl_netimmediatebuttons.integer || cl.movecmd[0].buttons == cl.movecmd[1].buttons))
1536         {
1537                 // don't choke the connection with packets (obey rate limit)
1538                 if ((cls.protocol == PROTOCOL_QUAKEWORLD || cls.signon == SIGNONS) && !NetConn_CanSend(cls.netcon) && !cl.islocalgame)
1539                         return;
1540                 // don't send too often (cl_netfps)
1541                 if (realtime < cl.lastpackettime + packettime)
1542                         return;
1543         }
1544         // try to round off the lastpackettime to a multiple of the packet interval
1545         // (this causes it to emit packets at a steady beat)
1546         if (packettime > 0)
1547                 cl.lastpackettime = floor(realtime / packettime) * packettime;
1548         else
1549                 cl.lastpackettime = realtime;
1550
1551         buf.maxsize = sizeof(data);
1552         buf.cursize = 0;
1553         buf.data = data;
1554
1555         // send the movement message
1556         // PROTOCOL_QUAKE        clc_move = 16 bytes total
1557         // PROTOCOL_QUAKEDP      clc_move = 16 bytes total
1558         // PROTOCOL_NEHAHRAMOVIE clc_move = 16 bytes total
1559         // PROTOCOL_DARKPLACES1  clc_move = 19 bytes total
1560         // PROTOCOL_DARKPLACES2  clc_move = 25 bytes total
1561         // PROTOCOL_DARKPLACES3  clc_move = 25 bytes total
1562         // PROTOCOL_DARKPLACES4  clc_move = 19 bytes total
1563         // PROTOCOL_DARKPLACES5  clc_move = 19 bytes total
1564         // PROTOCOL_DARKPLACES6  clc_move = 52 bytes total
1565         // PROTOCOL_DARKPLACES7  clc_move = 56 bytes total per move (can be up to 16 moves)
1566         // PROTOCOL_QUAKEWORLD   clc_move = 34 bytes total (typically, but can reach 43 bytes, or even 49 bytes with roll)
1567
1568         // set prydon cursor info
1569         CL_UpdatePrydonCursor();
1570
1571         if (cls.protocol == PROTOCOL_QUAKEWORLD || cls.signon == SIGNONS)
1572         {
1573                 switch (cls.protocol)
1574                 {
1575                 case PROTOCOL_QUAKEWORLD:
1576                         MSG_WriteByte(&buf, qw_clc_move);
1577                         // save the position for a checksum byte
1578                         checksumindex = buf.cursize;
1579                         MSG_WriteByte(&buf, 0);
1580                         // packet loss percentage
1581                         for (j = 0, packetloss = 0;j < NETGRAPH_PACKETS;j++)
1582                                 if (cls.netcon->incoming_unreliablesize[j] == NETGRAPH_LOSTPACKET)
1583                                         packetloss++;
1584                         packetloss = packetloss * 100 / NETGRAPH_PACKETS;
1585                         MSG_WriteByte(&buf, packetloss);
1586                         // write most recent 3 moves
1587                         QW_MSG_WriteDeltaUsercmd(&buf, &nullcmd, &cl.movecmd[2]);
1588                         QW_MSG_WriteDeltaUsercmd(&buf, &cl.movecmd[2], &cl.movecmd[1]);
1589                         QW_MSG_WriteDeltaUsercmd(&buf, &cl.movecmd[1], &cl.movecmd[0]);
1590                         // calculate the checksum
1591                         buf.data[checksumindex] = COM_BlockSequenceCRCByteQW(buf.data + checksumindex + 1, buf.cursize - checksumindex - 1, cls.netcon->outgoing_unreliable_sequence);
1592                         // if delta compression history overflows, request no delta
1593                         if (cls.netcon->outgoing_unreliable_sequence - cl.qw_validsequence >= QW_UPDATE_BACKUP-1)
1594                                 cl.qw_validsequence = 0;
1595                         // request delta compression if appropriate
1596                         if (cl.qw_validsequence && !cl_nodelta.integer && cls.state == ca_connected && !cls.demorecording)
1597                         {
1598                                 cl.qw_deltasequence[cls.netcon->outgoing_unreliable_sequence & QW_UPDATE_MASK] = cl.qw_validsequence;
1599                                 MSG_WriteByte(&buf, qw_clc_delta);
1600                                 MSG_WriteByte(&buf, cl.qw_validsequence & 255);
1601                         }
1602                         else
1603                                 cl.qw_deltasequence[cls.netcon->outgoing_unreliable_sequence & QW_UPDATE_MASK] = -1;
1604                         break;
1605                 case PROTOCOL_QUAKE:
1606                 case PROTOCOL_QUAKEDP:
1607                 case PROTOCOL_NEHAHRAMOVIE:
1608                 case PROTOCOL_NEHAHRABJP:
1609                 case PROTOCOL_NEHAHRABJP2:
1610                 case PROTOCOL_NEHAHRABJP3:
1611                         // 5 bytes
1612                         MSG_WriteByte (&buf, clc_move);
1613                         MSG_WriteFloat (&buf, cl.movecmd[0].time); // last server packet time
1614                         // 3 bytes
1615                         for (i = 0;i < 3;i++)
1616                                 MSG_WriteAngle8i (&buf, cl.movecmd[0].viewangles[i]);
1617                         // 6 bytes
1618                         MSG_WriteCoord16i (&buf, cl.movecmd[0].forwardmove);
1619                         MSG_WriteCoord16i (&buf, cl.movecmd[0].sidemove);
1620                         MSG_WriteCoord16i (&buf, cl.movecmd[0].upmove);
1621                         // 2 bytes
1622                         MSG_WriteByte (&buf, cl.movecmd[0].buttons);
1623                         MSG_WriteByte (&buf, cl.movecmd[0].impulse);
1624                         break;
1625                 case PROTOCOL_DARKPLACES2:
1626                 case PROTOCOL_DARKPLACES3:
1627                         // 5 bytes
1628                         MSG_WriteByte (&buf, clc_move);
1629                         MSG_WriteFloat (&buf, cl.movecmd[0].time); // last server packet time
1630                         // 12 bytes
1631                         for (i = 0;i < 3;i++)
1632                                 MSG_WriteAngle32f (&buf, cl.movecmd[0].viewangles[i]);
1633                         // 6 bytes
1634                         MSG_WriteCoord16i (&buf, cl.movecmd[0].forwardmove);
1635                         MSG_WriteCoord16i (&buf, cl.movecmd[0].sidemove);
1636                         MSG_WriteCoord16i (&buf, cl.movecmd[0].upmove);
1637                         // 2 bytes
1638                         MSG_WriteByte (&buf, cl.movecmd[0].buttons);
1639                         MSG_WriteByte (&buf, cl.movecmd[0].impulse);
1640                         break;
1641                 case PROTOCOL_DARKPLACES1:
1642                 case PROTOCOL_DARKPLACES4:
1643                 case PROTOCOL_DARKPLACES5:
1644                         // 5 bytes
1645                         MSG_WriteByte (&buf, clc_move);
1646                         MSG_WriteFloat (&buf, cl.movecmd[0].time); // last server packet time
1647                         // 6 bytes
1648                         for (i = 0;i < 3;i++)
1649                                 MSG_WriteAngle16i (&buf, cl.movecmd[0].viewangles[i]);
1650                         // 6 bytes
1651                         MSG_WriteCoord16i (&buf, cl.movecmd[0].forwardmove);
1652                         MSG_WriteCoord16i (&buf, cl.movecmd[0].sidemove);
1653                         MSG_WriteCoord16i (&buf, cl.movecmd[0].upmove);
1654                         // 2 bytes
1655                         MSG_WriteByte (&buf, cl.movecmd[0].buttons);
1656                         MSG_WriteByte (&buf, cl.movecmd[0].impulse);
1657                 case PROTOCOL_DARKPLACES6:
1658                 case PROTOCOL_DARKPLACES7:
1659                         // set the maxusercmds variable to limit how many should be sent
1660                         maxusercmds = bound(1, cl_netrepeatinput.integer + 1, CL_MAX_USERCMDS);
1661                         // when movement prediction is off, there's not much point in repeating old input as it will just be ignored
1662                         if (!cl.cmd.predicted)
1663                                 maxusercmds = 1;
1664
1665                         // send the latest moves in order, the old ones will be
1666                         // ignored by the server harmlessly, however if the previous
1667                         // packets were lost these moves will be used
1668                         //
1669                         // this reduces packet loss impact on gameplay.
1670                         for (j = 0, cmd = &cl.movecmd[maxusercmds-1];j < maxusercmds;j++, cmd--)
1671                         {
1672                                 // don't repeat any stale moves
1673                                 if (cmd->sequence && cmd->sequence < cls.servermovesequence)
1674                                         continue;
1675                                 // 5/9 bytes
1676                                 MSG_WriteByte (&buf, clc_move);
1677                                 if (cls.protocol != PROTOCOL_DARKPLACES6)
1678                                         MSG_WriteLong (&buf, cmd->predicted ? cmd->sequence : 0);
1679                                 MSG_WriteFloat (&buf, cmd->time); // last server packet time
1680                                 // 6 bytes
1681                                 for (i = 0;i < 3;i++)
1682                                         MSG_WriteAngle16i (&buf, cmd->viewangles[i]);
1683                                 // 6 bytes
1684                                 MSG_WriteCoord16i (&buf, cmd->forwardmove);
1685                                 MSG_WriteCoord16i (&buf, cmd->sidemove);
1686                                 MSG_WriteCoord16i (&buf, cmd->upmove);
1687                                 // 5 bytes
1688                                 MSG_WriteLong (&buf, cmd->buttons);
1689                                 MSG_WriteByte (&buf, cmd->impulse);
1690                                 // PRYDON_CLIENTCURSOR
1691                                 // 30 bytes
1692                                 MSG_WriteShort (&buf, (short)(cmd->cursor_screen[0] * 32767.0f));
1693                                 MSG_WriteShort (&buf, (short)(cmd->cursor_screen[1] * 32767.0f));
1694                                 MSG_WriteFloat (&buf, cmd->cursor_start[0]);
1695                                 MSG_WriteFloat (&buf, cmd->cursor_start[1]);
1696                                 MSG_WriteFloat (&buf, cmd->cursor_start[2]);
1697                                 MSG_WriteFloat (&buf, cmd->cursor_impact[0]);
1698                                 MSG_WriteFloat (&buf, cmd->cursor_impact[1]);
1699                                 MSG_WriteFloat (&buf, cmd->cursor_impact[2]);
1700                                 MSG_WriteShort (&buf, cmd->cursor_entitynumber);
1701                         }
1702                         break;
1703                 case PROTOCOL_UNKNOWN:
1704                         break;
1705                 }
1706         }
1707
1708         if (cls.protocol != PROTOCOL_QUAKEWORLD && buf.cursize)
1709         {
1710                 // ack the last few frame numbers
1711                 // (redundent to improve handling of client->server packet loss)
1712                 // for LATESTFRAMENUMS == 3 case this is 15 bytes
1713                 for (i = 0;i < LATESTFRAMENUMS;i++)
1714                 {
1715                         if (cl.latestframenums[i] > 0)
1716                         {
1717                                 if (developer_networkentities.integer >= 10)
1718                                         Con_Printf("send clc_ackframe %i\n", cl.latestframenums[i]);
1719                                 MSG_WriteByte(&buf, clc_ackframe);
1720                                 MSG_WriteLong(&buf, cl.latestframenums[i]);
1721                         }
1722                 }
1723         }
1724
1725         // PROTOCOL_DARKPLACES6 = 67 bytes per packet
1726         // PROTOCOL_DARKPLACES7 = 71 bytes per packet
1727
1728         // acknowledge any recently received data blocks
1729         for (i = 0;i < CL_MAX_DOWNLOADACKS && (cls.dp_downloadack[i].start || cls.dp_downloadack[i].size);i++)
1730         {
1731                 MSG_WriteByte(&buf, clc_ackdownloaddata);
1732                 MSG_WriteLong(&buf, cls.dp_downloadack[i].start);
1733                 MSG_WriteShort(&buf, cls.dp_downloadack[i].size);
1734                 cls.dp_downloadack[i].start = 0;
1735                 cls.dp_downloadack[i].size = 0;
1736         }
1737
1738         // send the reliable message (forwarded commands) if there is one
1739         if (buf.cursize || cls.netcon->message.cursize)
1740                 NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol, max(20*(buf.cursize+40), cl_rate.integer), false);
1741
1742         // update the cl.movecmd array which holds the most recent moves,
1743         // because we now need a new slot for the next input
1744         for (i = CL_MAX_USERCMDS - 1;i >= 1;i--)
1745                 cl.movecmd[i] = cl.movecmd[i-1];
1746         cl.movecmd[0].msec = 0;
1747         cl.movecmd[0].frametime = 0;
1748
1749         // clear button 'click' states
1750         in_attack.state  &= ~2;
1751         in_jump.state    &= ~2;
1752         in_button3.state &= ~2;
1753         in_button4.state &= ~2;
1754         in_button5.state &= ~2;
1755         in_button6.state &= ~2;
1756         in_button7.state &= ~2;
1757         in_button8.state &= ~2;
1758         in_use.state     &= ~2;
1759         in_button9.state  &= ~2;
1760         in_button10.state &= ~2;
1761         in_button11.state &= ~2;
1762         in_button12.state &= ~2;
1763         in_button13.state &= ~2;
1764         in_button14.state &= ~2;
1765         in_button15.state &= ~2;
1766         in_button16.state &= ~2;
1767         // clear impulse
1768         in_impulse = 0;
1769
1770         if (cls.netcon->message.overflowed)
1771         {
1772                 Con_Print("CL_SendMove: lost server connection\n");
1773                 CL_Disconnect();
1774                 Host_ShutdownServer();
1775         }
1776 }
1777
1778 /*
1779 ============
1780 CL_InitInput
1781 ============
1782 */
1783 void CL_InitInput (void)
1784 {
1785         Cmd_AddCommand ("+moveup",IN_UpDown, "swim upward");
1786         Cmd_AddCommand ("-moveup",IN_UpUp, "stop swimming upward");
1787         Cmd_AddCommand ("+movedown",IN_DownDown, "swim downward");
1788         Cmd_AddCommand ("-movedown",IN_DownUp, "stop swimming downward");
1789         Cmd_AddCommand ("+left",IN_LeftDown, "turn left");
1790         Cmd_AddCommand ("-left",IN_LeftUp, "stop turning left");
1791         Cmd_AddCommand ("+right",IN_RightDown, "turn right");
1792         Cmd_AddCommand ("-right",IN_RightUp, "stop turning right");
1793         Cmd_AddCommand ("+forward",IN_ForwardDown, "move forward");
1794         Cmd_AddCommand ("-forward",IN_ForwardUp, "stop moving forward");
1795         Cmd_AddCommand ("+back",IN_BackDown, "move backward");
1796         Cmd_AddCommand ("-back",IN_BackUp, "stop moving backward");
1797         Cmd_AddCommand ("+lookup", IN_LookupDown, "look upward");
1798         Cmd_AddCommand ("-lookup", IN_LookupUp, "stop looking upward");
1799         Cmd_AddCommand ("+lookdown", IN_LookdownDown, "look downward");
1800         Cmd_AddCommand ("-lookdown", IN_LookdownUp, "stop looking downward");
1801         Cmd_AddCommand ("+strafe", IN_StrafeDown, "activate strafing mode (move instead of turn)");
1802         Cmd_AddCommand ("-strafe", IN_StrafeUp, "deactivate strafing mode");
1803         Cmd_AddCommand ("+moveleft", IN_MoveleftDown, "strafe left");
1804         Cmd_AddCommand ("-moveleft", IN_MoveleftUp, "stop strafing left");
1805         Cmd_AddCommand ("+moveright", IN_MoverightDown, "strafe right");
1806         Cmd_AddCommand ("-moveright", IN_MoverightUp, "stop strafing right");
1807         Cmd_AddCommand ("+speed", IN_SpeedDown, "activate run mode (faster movement and turning)");
1808         Cmd_AddCommand ("-speed", IN_SpeedUp, "deactivate run mode");
1809         Cmd_AddCommand ("+attack", IN_AttackDown, "begin firing");
1810         Cmd_AddCommand ("-attack", IN_AttackUp, "stop firing");
1811         Cmd_AddCommand ("+jump", IN_JumpDown, "jump");
1812         Cmd_AddCommand ("-jump", IN_JumpUp, "end jump (so you can jump again)");
1813         Cmd_AddCommand ("impulse", IN_Impulse, "send an impulse number to server (select weapon, use item, etc)");
1814         Cmd_AddCommand ("+klook", IN_KLookDown, "activate keyboard looking mode, do not recenter view");
1815         Cmd_AddCommand ("-klook", IN_KLookUp, "deactivate keyboard looking mode");
1816         Cmd_AddCommand ("+mlook", IN_MLookDown, "activate mouse looking mode, do not recenter view");
1817         Cmd_AddCommand ("-mlook", IN_MLookUp, "deactivate mouse looking mode");
1818
1819         // LordHavoc: added use button
1820         Cmd_AddCommand ("+use", IN_UseDown, "use something (may be used by some mods)");
1821         Cmd_AddCommand ("-use", IN_UseUp, "stop using something");
1822
1823         // LordHavoc: added 6 new buttons
1824         Cmd_AddCommand ("+button3", IN_Button3Down, "activate button3 (behavior depends on mod)");
1825         Cmd_AddCommand ("-button3", IN_Button3Up, "deactivate button3");
1826         Cmd_AddCommand ("+button4", IN_Button4Down, "activate button4 (behavior depends on mod)");
1827         Cmd_AddCommand ("-button4", IN_Button4Up, "deactivate button4");
1828         Cmd_AddCommand ("+button5", IN_Button5Down, "activate button5 (behavior depends on mod)");
1829         Cmd_AddCommand ("-button5", IN_Button5Up, "deactivate button5");
1830         Cmd_AddCommand ("+button6", IN_Button6Down, "activate button6 (behavior depends on mod)");
1831         Cmd_AddCommand ("-button6", IN_Button6Up, "deactivate button6");
1832         Cmd_AddCommand ("+button7", IN_Button7Down, "activate button7 (behavior depends on mod)");
1833         Cmd_AddCommand ("-button7", IN_Button7Up, "deactivate button7");
1834         Cmd_AddCommand ("+button8", IN_Button8Down, "activate button8 (behavior depends on mod)");
1835         Cmd_AddCommand ("-button8", IN_Button8Up, "deactivate button8");
1836         Cmd_AddCommand ("+button9", IN_Button9Down, "activate button9 (behavior depends on mod)");
1837         Cmd_AddCommand ("-button9", IN_Button9Up, "deactivate button9");
1838         Cmd_AddCommand ("+button10", IN_Button10Down, "activate button10 (behavior depends on mod)");
1839         Cmd_AddCommand ("-button10", IN_Button10Up, "deactivate button10");
1840         Cmd_AddCommand ("+button11", IN_Button11Down, "activate button11 (behavior depends on mod)");
1841         Cmd_AddCommand ("-button11", IN_Button11Up, "deactivate button11");
1842         Cmd_AddCommand ("+button12", IN_Button12Down, "activate button12 (behavior depends on mod)");
1843         Cmd_AddCommand ("-button12", IN_Button12Up, "deactivate button12");
1844         Cmd_AddCommand ("+button13", IN_Button13Down, "activate button13 (behavior depends on mod)");
1845         Cmd_AddCommand ("-button13", IN_Button13Up, "deactivate button13");
1846         Cmd_AddCommand ("+button14", IN_Button14Down, "activate button14 (behavior depends on mod)");
1847         Cmd_AddCommand ("-button14", IN_Button14Up, "deactivate button14");
1848         Cmd_AddCommand ("+button15", IN_Button15Down, "activate button15 (behavior depends on mod)");
1849         Cmd_AddCommand ("-button15", IN_Button15Up, "deactivate button15");
1850         Cmd_AddCommand ("+button16", IN_Button16Down, "activate button16 (behavior depends on mod)");
1851         Cmd_AddCommand ("-button16", IN_Button16Up, "deactivate button16");
1852
1853         // LordHavoc: added bestweapon command
1854         Cmd_AddCommand ("bestweapon", IN_BestWeapon, "send an impulse number to server to select the first usable weapon out of several (example: 8 7 6 5 4 3 2 1)");
1855         Cmd_AddCommand ("cycleweapon", IN_CycleWeapon, "send an impulse number to server to select the next usable weapon out of several (example: 9 4 8) if you are holding one of these, and choose the first one if you are holding none of these");
1856         Cmd_AddCommand ("register_bestweapon", IN_BestWeapon_Register_f, "(for QC usage only) change weapon parameters to be used by bestweapon; stuffcmd this in ClientConnect");
1857
1858         Cvar_RegisterVariable(&cl_movement);
1859         Cvar_RegisterVariable(&cl_movement_minping);
1860         Cvar_RegisterVariable(&cl_movement_track_canjump);
1861         Cvar_RegisterVariable(&cl_movement_maxspeed);
1862         Cvar_RegisterVariable(&cl_movement_maxairspeed);
1863         Cvar_RegisterVariable(&cl_movement_stopspeed);
1864         Cvar_RegisterVariable(&cl_movement_friction);
1865         Cvar_RegisterVariable(&cl_movement_wallfriction);
1866         Cvar_RegisterVariable(&cl_movement_waterfriction);
1867         Cvar_RegisterVariable(&cl_movement_edgefriction);
1868         Cvar_RegisterVariable(&cl_movement_stepheight);
1869         Cvar_RegisterVariable(&cl_movement_accelerate);
1870         Cvar_RegisterVariable(&cl_movement_airaccelerate);
1871         Cvar_RegisterVariable(&cl_movement_wateraccelerate);
1872         Cvar_RegisterVariable(&cl_movement_jumpvelocity);
1873         Cvar_RegisterVariable(&cl_movement_airaccel_qw);
1874         Cvar_RegisterVariable(&cl_movement_airaccel_sideways_friction);
1875
1876         Cvar_RegisterVariable(&in_pitch_min);
1877         Cvar_RegisterVariable(&in_pitch_max);
1878         Cvar_RegisterVariable(&m_filter);
1879
1880         Cvar_RegisterVariable(&cl_netfps);
1881         Cvar_RegisterVariable(&cl_netrepeatinput);
1882         Cvar_RegisterVariable(&cl_netimmediatebuttons);
1883
1884         Cvar_RegisterVariable(&cl_nodelta);
1885 }
1886