2 Copyright (C) 1996-1997 Id Software, Inc.
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13 See the GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 // cl.input.c -- builds an intended movement command to send to the server
22 // Quake is a trademark of Id Software, Inc., (c) 1996 Id Software, Inc. All
30 ===============================================================================
34 Continuous button event tracking is complicated by the fact that two different
35 input sources (say, mouse button 1 and the control key) can both press the
36 same button, but the button should only be released when both of the
37 pressing key have been released.
39 When a key event issues a button command (+forward, +attack, etc), it appends
40 its key number as a parameter to the command so it can be matched up with
43 state bit 0 is the current state of the key
44 state bit 1 is edge triggered on the up to down transition
45 state bit 2 is edge triggered on the down to up transition
47 ===============================================================================
51 kbutton_t in_mlook, in_klook;
52 kbutton_t in_left, in_right, in_forward, in_back;
53 kbutton_t in_lookup, in_lookdown, in_moveleft, in_moveright;
54 kbutton_t in_strafe, in_speed, in_jump, in_attack, in_use;
55 kbutton_t in_up, in_down;
56 // LadyHavoc: added 6 new buttons
57 kbutton_t in_button3, in_button4, in_button5, in_button6, in_button7, in_button8;
59 kbutton_t in_button9, in_button10, in_button11, in_button12, in_button13, in_button14, in_button15, in_button16;
65 static void KeyDown (cmd_state_t *cmd, kbutton_t *b)
74 k = -1; // typed manually at the console for continuous down
76 if (k == b->down[0] || k == b->down[1])
77 return; // repeating key
85 Con_Print("Three keys down for a button!\n");
91 b->state |= 1 + 2; // down + impulse down
94 static void KeyUp (cmd_state_t *cmd, kbutton_t *b)
103 { // typed manually at the console, assume for unsticking, so clear all
104 b->down[0] = b->down[1] = 0;
105 b->state = 4; // impulse up
111 else if (b->down[1] == k)
114 return; // key up without coresponding down (menu pass through)
115 if (b->down[0] || b->down[1])
116 return; // some other key is still holding it down
119 return; // still up (this should not happen)
120 b->state &= ~1; // now up
121 b->state |= 4; // impulse up
124 static void IN_KLookDown(cmd_state_t *cmd) {KeyDown(cmd, &in_klook);}
125 static void IN_KLookUp(cmd_state_t *cmd) {KeyUp(cmd, &in_klook);}
126 static void IN_MLookDown(cmd_state_t *cmd) {KeyDown(cmd, &in_mlook);}
127 static void IN_MLookUp(cmd_state_t *cmd)
129 KeyUp(cmd, &in_mlook);
130 if ( !(in_mlook.state&1) && lookspring.value)
131 V_StartPitchDrift_f(cmd);
133 static void IN_UpDown(cmd_state_t *cmd) {KeyDown(cmd, &in_up);}
134 static void IN_UpUp(cmd_state_t *cmd) {KeyUp(cmd, &in_up);}
135 static void IN_DownDown(cmd_state_t *cmd) {KeyDown(cmd, &in_down);}
136 static void IN_DownUp(cmd_state_t *cmd) {KeyUp(cmd, &in_down);}
137 static void IN_LeftDown(cmd_state_t *cmd) {KeyDown(cmd, &in_left);}
138 static void IN_LeftUp(cmd_state_t *cmd) {KeyUp(cmd, &in_left);}
139 static void IN_RightDown(cmd_state_t *cmd) {KeyDown(cmd, &in_right);}
140 static void IN_RightUp(cmd_state_t *cmd) {KeyUp(cmd, &in_right);}
141 static void IN_ForwardDown(cmd_state_t *cmd) {KeyDown(cmd, &in_forward);}
142 static void IN_ForwardUp(cmd_state_t *cmd) {KeyUp(cmd, &in_forward);}
143 static void IN_BackDown(cmd_state_t *cmd) {KeyDown(cmd, &in_back);}
144 static void IN_BackUp(cmd_state_t *cmd) {KeyUp(cmd, &in_back);}
145 static void IN_LookupDown(cmd_state_t *cmd) {KeyDown(cmd, &in_lookup);}
146 static void IN_LookupUp(cmd_state_t *cmd) {KeyUp(cmd, &in_lookup);}
147 static void IN_LookdownDown(cmd_state_t *cmd) {KeyDown(cmd, &in_lookdown);}
148 static void IN_LookdownUp(cmd_state_t *cmd) {KeyUp(cmd, &in_lookdown);}
149 static void IN_MoveleftDown(cmd_state_t *cmd) {KeyDown(cmd, &in_moveleft);}
150 static void IN_MoveleftUp(cmd_state_t *cmd) {KeyUp(cmd, &in_moveleft);}
151 static void IN_MoverightDown(cmd_state_t *cmd) {KeyDown(cmd, &in_moveright);}
152 static void IN_MoverightUp(cmd_state_t *cmd) {KeyUp(cmd, &in_moveright);}
154 static void IN_SpeedDown(cmd_state_t *cmd) {KeyDown(cmd, &in_speed);}
155 static void IN_SpeedUp(cmd_state_t *cmd) {KeyUp(cmd, &in_speed);}
156 static void IN_StrafeDown(cmd_state_t *cmd) {KeyDown(cmd, &in_strafe);}
157 static void IN_StrafeUp(cmd_state_t *cmd) {KeyUp(cmd, &in_strafe);}
159 static void IN_AttackDown(cmd_state_t *cmd) {KeyDown(cmd, &in_attack);}
160 static void IN_AttackUp(cmd_state_t *cmd) {KeyUp(cmd, &in_attack);}
162 static void IN_UseDown(cmd_state_t *cmd) {KeyDown(cmd, &in_use);}
163 static void IN_UseUp(cmd_state_t *cmd) {KeyUp(cmd, &in_use);}
165 // LadyHavoc: added 6 new buttons
166 static void IN_Button3Down(cmd_state_t *cmd) {KeyDown(cmd, &in_button3);}
167 static void IN_Button3Up(cmd_state_t *cmd) {KeyUp(cmd, &in_button3);}
168 static void IN_Button4Down(cmd_state_t *cmd) {KeyDown(cmd, &in_button4);}
169 static void IN_Button4Up(cmd_state_t *cmd) {KeyUp(cmd, &in_button4);}
170 static void IN_Button5Down(cmd_state_t *cmd) {KeyDown(cmd, &in_button5);}
171 static void IN_Button5Up(cmd_state_t *cmd) {KeyUp(cmd, &in_button5);}
172 static void IN_Button6Down(cmd_state_t *cmd) {KeyDown(cmd, &in_button6);}
173 static void IN_Button6Up(cmd_state_t *cmd) {KeyUp(cmd, &in_button6);}
174 static void IN_Button7Down(cmd_state_t *cmd) {KeyDown(cmd, &in_button7);}
175 static void IN_Button7Up(cmd_state_t *cmd) {KeyUp(cmd, &in_button7);}
176 static void IN_Button8Down(cmd_state_t *cmd) {KeyDown(cmd, &in_button8);}
177 static void IN_Button8Up(cmd_state_t *cmd) {KeyUp(cmd, &in_button8);}
179 static void IN_Button9Down(cmd_state_t *cmd) {KeyDown(cmd, &in_button9);}
180 static void IN_Button9Up(cmd_state_t *cmd) {KeyUp(cmd, &in_button9);}
181 static void IN_Button10Down(cmd_state_t *cmd) {KeyDown(cmd, &in_button10);}
182 static void IN_Button10Up(cmd_state_t *cmd) {KeyUp(cmd, &in_button10);}
183 static void IN_Button11Down(cmd_state_t *cmd) {KeyDown(cmd, &in_button11);}
184 static void IN_Button11Up(cmd_state_t *cmd) {KeyUp(cmd, &in_button11);}
185 static void IN_Button12Down(cmd_state_t *cmd) {KeyDown(cmd, &in_button12);}
186 static void IN_Button12Up(cmd_state_t *cmd) {KeyUp(cmd, &in_button12);}
187 static void IN_Button13Down(cmd_state_t *cmd) {KeyDown(cmd, &in_button13);}
188 static void IN_Button13Up(cmd_state_t *cmd) {KeyUp(cmd, &in_button13);}
189 static void IN_Button14Down(cmd_state_t *cmd) {KeyDown(cmd, &in_button14);}
190 static void IN_Button14Up(cmd_state_t *cmd) {KeyUp(cmd, &in_button14);}
191 static void IN_Button15Down(cmd_state_t *cmd) {KeyDown(cmd, &in_button15);}
192 static void IN_Button15Up(cmd_state_t *cmd) {KeyUp(cmd, &in_button15);}
193 static void IN_Button16Down(cmd_state_t *cmd) {KeyDown(cmd, &in_button16);}
194 static void IN_Button16Up(cmd_state_t *cmd) {KeyUp(cmd, &in_button16);}
196 static void IN_JumpDown(cmd_state_t *cmd) {KeyDown(cmd, &in_jump);}
197 static void IN_JumpUp(cmd_state_t *cmd) {KeyUp(cmd, &in_jump);}
199 static void IN_Impulse(cmd_state_t *cmd) {in_impulse=atoi(Cmd_Argv(cmd, 1));}
201 in_bestweapon_info_t in_bestweapon_info[IN_BESTWEAPON_MAX];
203 static void IN_BestWeapon_Register(const char *name, int impulse, int weaponbit, int activeweaponcode, int ammostat, int ammomin)
206 for(i = 0; i < IN_BESTWEAPON_MAX && in_bestweapon_info[i].impulse; ++i)
207 if(in_bestweapon_info[i].impulse == impulse)
209 if(i >= IN_BESTWEAPON_MAX)
211 Con_Printf("no slot left for weapon definition; increase IN_BESTWEAPON_MAX\n");
214 strlcpy(in_bestweapon_info[i].name, name, sizeof(in_bestweapon_info[i].name));
215 in_bestweapon_info[i].impulse = impulse;
217 in_bestweapon_info[i].weaponbit = weaponbit;
218 if(activeweaponcode != -1)
219 in_bestweapon_info[i].activeweaponcode = activeweaponcode;
221 in_bestweapon_info[i].ammostat = ammostat;
223 in_bestweapon_info[i].ammomin = ammomin;
226 void IN_BestWeapon_ResetData (void)
228 memset(in_bestweapon_info, 0, sizeof(in_bestweapon_info));
229 IN_BestWeapon_Register("1", 1, IT_AXE, IT_AXE, STAT_SHELLS, 0);
230 IN_BestWeapon_Register("2", 2, IT_SHOTGUN, IT_SHOTGUN, STAT_SHELLS, 1);
231 IN_BestWeapon_Register("3", 3, IT_SUPER_SHOTGUN, IT_SUPER_SHOTGUN, STAT_SHELLS, 1);
232 IN_BestWeapon_Register("4", 4, IT_NAILGUN, IT_NAILGUN, STAT_NAILS, 1);
233 IN_BestWeapon_Register("5", 5, IT_SUPER_NAILGUN, IT_SUPER_NAILGUN, STAT_NAILS, 1);
234 IN_BestWeapon_Register("6", 6, IT_GRENADE_LAUNCHER, IT_GRENADE_LAUNCHER, STAT_ROCKETS, 1);
235 IN_BestWeapon_Register("7", 7, IT_ROCKET_LAUNCHER, IT_ROCKET_LAUNCHER, STAT_ROCKETS, 1);
236 IN_BestWeapon_Register("8", 8, IT_LIGHTNING, IT_LIGHTNING, STAT_CELLS, 1);
237 IN_BestWeapon_Register("9", 9, 128, 128, STAT_CELLS, 1); // generic energy weapon for mods
238 IN_BestWeapon_Register("p", 209, 128, 128, STAT_CELLS, 1); // dpmod plasma gun
239 IN_BestWeapon_Register("w", 210, 8388608, 8388608, STAT_CELLS, 1); // dpmod plasma wave cannon
240 IN_BestWeapon_Register("l", 225, HIT_LASER_CANNON, HIT_LASER_CANNON, STAT_CELLS, 1); // hipnotic laser cannon
241 IN_BestWeapon_Register("h", 226, HIT_MJOLNIR, HIT_MJOLNIR, STAT_CELLS, 0); // hipnotic mjolnir hammer
244 static void IN_BestWeapon_Register_f(cmd_state_t *cmd)
246 if(Cmd_Argc(cmd) == 7)
248 IN_BestWeapon_Register(
250 atoi(Cmd_Argv(cmd, 2)),
251 atoi(Cmd_Argv(cmd, 3)),
252 atoi(Cmd_Argv(cmd, 4)),
253 atoi(Cmd_Argv(cmd, 5)),
254 atoi(Cmd_Argv(cmd, 6))
257 else if(Cmd_Argc(cmd) == 2 && !strcmp(Cmd_Argv(cmd, 1), "clear"))
259 memset(in_bestweapon_info, 0, sizeof(in_bestweapon_info));
261 else if(Cmd_Argc(cmd) == 2 && !strcmp(Cmd_Argv(cmd, 1), "quake"))
263 IN_BestWeapon_ResetData();
267 Con_Printf("Usage: %s weaponshortname impulse itemcode activeweaponcode ammostat ammomin; %s clear; %s quake\n", Cmd_Argv(cmd, 0), Cmd_Argv(cmd, 0), Cmd_Argv(cmd, 0));
271 static void IN_BestWeapon_f(cmd_state_t *cmd)
275 if (Cmd_Argc(cmd) < 2)
277 Con_Printf("bestweapon requires 1 or more parameters\n");
280 for (i = 1;i < Cmd_Argc(cmd);i++)
282 t = Cmd_Argv(cmd, i);
283 // figure out which weapon this character refers to
284 for (n = 0;n < IN_BESTWEAPON_MAX && in_bestweapon_info[n].impulse;n++)
286 if (!strcmp(in_bestweapon_info[n].name, t))
288 // we found out what weapon this character refers to
289 // check if the inventory contains the weapon and enough ammo
290 if ((cl.stats[STAT_ITEMS] & in_bestweapon_info[n].weaponbit) && (cl.stats[in_bestweapon_info[n].ammostat] >= in_bestweapon_info[n].ammomin))
292 // we found one of the weapons the player wanted
293 // send an impulse to switch to it
294 in_impulse = in_bestweapon_info[n].impulse;
300 // if we couldn't identify the weapon we just ignore it and continue checking for other weapons
302 // if we couldn't find any of the weapons, there's nothing more we can do...
309 Returns 0.25 if a key was pressed and released during the frame,
310 0.5 if it was pressed and held
311 0 if held then released, and
312 1.0 if held for the entire time
315 float CL_KeyState (kbutton_t *key)
318 qboolean impulsedown, impulseup, down;
320 impulsedown = (key->state & 2) != 0;
321 impulseup = (key->state & 4) != 0;
322 down = (key->state & 1) != 0;
325 if (impulsedown && !impulseup)
328 val = 0.5; // pressed and held this frame
330 val = 0; // I_Error ();
332 if (impulseup && !impulsedown)
335 val = 0; // I_Error ();
337 val = 0; // released this frame
339 if (!impulsedown && !impulseup)
342 val = 1.0; // held the entire frame
344 val = 0; // up the entire frame
346 if (impulsedown && impulseup)
349 val = 0.75; // released and re-pressed this frame
351 val = 0.25; // pressed and released this frame
354 key->state &= 1; // clear impulses
362 //==========================================================================
364 cvar_t cl_upspeed = {CVAR_CLIENT | CVAR_SAVE, "cl_upspeed","400","vertical movement speed (while swimming or flying)"};
365 cvar_t cl_forwardspeed = {CVAR_CLIENT | CVAR_SAVE, "cl_forwardspeed","400","forward movement speed"};
366 cvar_t cl_backspeed = {CVAR_CLIENT | CVAR_SAVE, "cl_backspeed","400","backward movement speed"};
367 cvar_t cl_sidespeed = {CVAR_CLIENT | CVAR_SAVE, "cl_sidespeed","350","strafe movement speed"};
369 cvar_t cl_movespeedkey = {CVAR_CLIENT | CVAR_SAVE, "cl_movespeedkey","2.0","how much +speed multiplies keyboard movement speed"};
370 cvar_t cl_movecliptokeyboard = {CVAR_CLIENT, "cl_movecliptokeyboard", "0", "if set to 1, any move is clipped to the nine keyboard states; if set to 2, only the direction is clipped, not the amount"};
372 cvar_t cl_yawspeed = {CVAR_CLIENT | CVAR_SAVE, "cl_yawspeed","140","keyboard yaw turning speed"};
373 cvar_t cl_pitchspeed = {CVAR_CLIENT | CVAR_SAVE, "cl_pitchspeed","150","keyboard pitch turning speed"};
375 cvar_t cl_anglespeedkey = {CVAR_CLIENT | CVAR_SAVE, "cl_anglespeedkey","1.5","how much +speed multiplies keyboard turning speed"};
377 cvar_t cl_movement = {CVAR_CLIENT | CVAR_SAVE, "cl_movement", "0", "enables clientside prediction of your player movement on DP servers (use cl_nopred for QWSV servers)"};
378 cvar_t cl_movement_replay = {CVAR_CLIENT, "cl_movement_replay", "1", "use engine prediction"};
379 cvar_t cl_movement_nettimeout = {CVAR_CLIENT | CVAR_SAVE, "cl_movement_nettimeout", "0.3", "stops predicting moves when server is lagging badly (avoids major performance problems), timeout in seconds"};
380 cvar_t cl_movement_minping = {CVAR_CLIENT | CVAR_SAVE, "cl_movement_minping", "0", "whether to use prediction when ping is lower than this value in milliseconds"};
381 cvar_t cl_movement_track_canjump = {CVAR_CLIENT | 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"};
382 cvar_t cl_movement_maxspeed = {CVAR_CLIENT, "cl_movement_maxspeed", "320", "how fast you can move (should match sv_maxspeed)"};
383 cvar_t cl_movement_maxairspeed = {CVAR_CLIENT, "cl_movement_maxairspeed", "30", "how fast you can move while in the air (should match sv_maxairspeed)"};
384 cvar_t cl_movement_stopspeed = {CVAR_CLIENT, "cl_movement_stopspeed", "100", "speed below which you will be slowed rapidly to a stop rather than sliding endlessly (should match sv_stopspeed)"};
385 cvar_t cl_movement_friction = {CVAR_CLIENT, "cl_movement_friction", "4", "how fast you slow down (should match sv_friction)"};
386 cvar_t cl_movement_wallfriction = {CVAR_CLIENT, "cl_movement_wallfriction", "1", "how fast you slow down while sliding along a wall (should match sv_wallfriction)"};
387 cvar_t cl_movement_waterfriction = {CVAR_CLIENT, "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"};
388 cvar_t cl_movement_edgefriction = {CVAR_CLIENT, "cl_movement_edgefriction", "1", "how much to slow down when you may be about to fall off a ledge (should match edgefriction)"};
389 cvar_t cl_movement_stepheight = {CVAR_CLIENT, "cl_movement_stepheight", "18", "how tall a step you can step in one instant (should match sv_stepheight)"};
390 cvar_t cl_movement_accelerate = {CVAR_CLIENT, "cl_movement_accelerate", "10", "how fast you accelerate (should match sv_accelerate)"};
391 cvar_t cl_movement_airaccelerate = {CVAR_CLIENT, "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"};
392 cvar_t cl_movement_wateraccelerate = {CVAR_CLIENT, "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"};
393 cvar_t cl_movement_jumpvelocity = {CVAR_CLIENT, "cl_movement_jumpvelocity", "270", "how fast you move upward when you begin a jump (should match the quakec code)"};
394 cvar_t cl_movement_airaccel_qw = {CVAR_CLIENT, "cl_movement_airaccel_qw", "1", "ratio of QW-style air control as opposed to simple acceleration (reduces speed gain when zigzagging) (should match sv_airaccel_qw); when < 0, the speed is clamped against the maximum allowed forward speed after the move"};
395 cvar_t cl_movement_airaccel_sideways_friction = {CVAR_CLIENT, "cl_movement_airaccel_sideways_friction", "0", "anti-sideways movement stabilization (should match sv_airaccel_sideways_friction); when < 0, only so much friction is applied that braking (by accelerating backwards) cannot be stronger"};
396 cvar_t cl_nopred = {CVAR_CLIENT | CVAR_SAVE, "cl_nopred", "0", "(QWSV only) disables player movement prediction when playing on QWSV servers (this setting is separate from cl_movement because player expectations are different when playing on DP vs QW servers)"};
398 cvar_t in_pitch_min = {CVAR_CLIENT, "in_pitch_min", "-90", "how far you can aim upward (quake used -70)"};
399 cvar_t in_pitch_max = {CVAR_CLIENT, "in_pitch_max", "90", "how far you can aim downward (quake used 80)"};
401 cvar_t m_filter = {CVAR_CLIENT | CVAR_SAVE, "m_filter","0", "smoothes mouse movement, less responsive but smoother aiming"};
402 cvar_t m_accelerate = {CVAR_CLIENT | CVAR_SAVE, "m_accelerate","1", "mouse acceleration factor (try 2)"};
403 cvar_t m_accelerate_minspeed = {CVAR_CLIENT | CVAR_SAVE, "m_accelerate_minspeed","5000", "below this speed, no acceleration is done"};
404 cvar_t m_accelerate_maxspeed = {CVAR_CLIENT | CVAR_SAVE, "m_accelerate_maxspeed","10000", "above this speed, full acceleration is done"};
405 cvar_t m_accelerate_filter = {CVAR_CLIENT | CVAR_SAVE, "m_accelerate_filter","0.1", "mouse acceleration factor filtering"};
407 cvar_t cl_netfps = {CVAR_CLIENT | CVAR_SAVE, "cl_netfps","72", "how many input packets to send to server each second"};
408 cvar_t cl_netrepeatinput = {CVAR_CLIENT | 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)"};
409 cvar_t cl_netimmediatebuttons = {CVAR_CLIENT | 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)"};
411 cvar_t cl_nodelta = {CVAR_CLIENT, "cl_nodelta", "0", "disables delta compression of non-player entities in QW network protocol"};
413 cvar_t cl_csqc_generatemousemoveevents = {CVAR_CLIENT, "cl_csqc_generatemousemoveevents", "1", "enables calls to CSQC_InputEvent with type 2, for compliance with EXT_CSQC spec"};
415 extern cvar_t v_flipped;
421 Moves the local angle positions
424 static void CL_AdjustAngles (void)
429 if (in_speed.state & 1)
430 speed = cl.realframetime * cl_anglespeedkey.value;
432 speed = cl.realframetime;
434 if (!(in_strafe.state & 1))
436 cl.viewangles[YAW] -= speed*cl_yawspeed.value*CL_KeyState (&in_right);
437 cl.viewangles[YAW] += speed*cl_yawspeed.value*CL_KeyState (&in_left);
439 if (in_klook.state & 1)
442 cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * CL_KeyState (&in_forward);
443 cl.viewangles[PITCH] += speed*cl_pitchspeed.value * CL_KeyState (&in_back);
446 up = CL_KeyState (&in_lookup);
447 down = CL_KeyState(&in_lookdown);
449 cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * up;
450 cl.viewangles[PITCH] += speed*cl_pitchspeed.value * down;
455 cl.viewangles[YAW] = ANGLEMOD(cl.viewangles[YAW]);
456 cl.viewangles[PITCH] = ANGLEMOD(cl.viewangles[PITCH]);
457 if (cl.viewangles[YAW] >= 180)
458 cl.viewangles[YAW] -= 360;
459 if (cl.viewangles[PITCH] >= 180)
460 cl.viewangles[PITCH] -= 360;
461 // TODO: honor serverinfo minpitch and maxpitch values in PROTOCOL_QUAKEWORLD
462 // TODO: honor proquake pq_fullpitch cvar when playing on proquake server (server stuffcmd's this to 0 usually)
463 cl.viewangles[PITCH] = bound(in_pitch_min.value, cl.viewangles[PITCH], in_pitch_max.value);
464 cl.viewangles[ROLL] = bound(-180, cl.viewangles[ROLL], 180);
467 int cl_ignoremousemoves = 2;
473 Send the intended movement message to the server
479 static float old_mouse_x = 0, old_mouse_y = 0;
481 // clamp before the move to prevent starting with bad angles
484 if(v_flipped.integer)
485 cl.viewangles[YAW] = -cl.viewangles[YAW];
487 // reset some of the command fields
488 cl.cmd.forwardmove = 0;
492 // get basic movement from keyboard
493 if (in_strafe.state & 1)
495 cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_right);
496 cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_left);
499 cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_moveright);
500 cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_moveleft);
502 cl.cmd.upmove += cl_upspeed.value * CL_KeyState (&in_up);
503 cl.cmd.upmove -= cl_upspeed.value * CL_KeyState (&in_down);
505 if (! (in_klook.state & 1) )
507 cl.cmd.forwardmove += cl_forwardspeed.value * CL_KeyState (&in_forward);
508 cl.cmd.forwardmove -= cl_backspeed.value * CL_KeyState (&in_back);
511 // adjust for speed key
512 if (in_speed.state & 1)
514 cl.cmd.forwardmove *= cl_movespeedkey.value;
515 cl.cmd.sidemove *= cl_movespeedkey.value;
516 cl.cmd.upmove *= cl_movespeedkey.value;
519 // allow mice or other external controllers to add to the move
522 // send mouse move to csqc
523 if (cl.csqc_loaded && cl_csqc_generatemousemoveevents.integer)
525 if (cl.csqc_wantsmousemove)
527 // event type 3 is a DP_CSQC thing
528 static int oldwindowmouse[2];
529 if (oldwindowmouse[0] != in_windowmouse_x || oldwindowmouse[1] != in_windowmouse_y)
531 CL_VM_InputEvent(3, in_windowmouse_x * vid_conwidth.value / vid.width, in_windowmouse_y * vid_conheight.value / vid.height);
532 oldwindowmouse[0] = in_windowmouse_x;
533 oldwindowmouse[1] = in_windowmouse_y;
538 if (in_mouse_x || in_mouse_y)
539 CL_VM_InputEvent(2, in_mouse_x, in_mouse_y);
543 // apply m_accelerate if it is on
544 if(m_accelerate.value > 1)
546 static float averagespeed = 0;
547 float speed, f, mi, ma;
549 speed = sqrt(in_mouse_x * in_mouse_x + in_mouse_y * in_mouse_y) / cl.realframetime;
550 if(m_accelerate_filter.value > 0)
551 f = bound(0, cl.realframetime / m_accelerate_filter.value, 1);
554 averagespeed = speed * f + averagespeed * (1 - f);
556 mi = max(1, m_accelerate_minspeed.value);
557 ma = max(m_accelerate_minspeed.value + 1, m_accelerate_maxspeed.value);
559 if(averagespeed <= mi)
563 else if(averagespeed >= ma)
565 f = m_accelerate.value;
570 f = (f - mi) / (ma - mi) * (m_accelerate.value - 1) + 1;
577 // apply m_filter if it is on
580 if (m_filter.integer)
582 in_mouse_x = (mx + old_mouse_x) * 0.5;
583 in_mouse_y = (my + old_mouse_y) * 0.5;
588 // ignore a mouse move if mouse was activated/deactivated this frame
589 if (cl_ignoremousemoves)
591 cl_ignoremousemoves--;
592 in_mouse_x = old_mouse_x = 0;
593 in_mouse_y = old_mouse_y = 0;
596 // if not in menu, apply mouse move to viewangles/movement
597 if (!key_consoleactive && key_dest == key_game && !cl.csqc_wantsmousemove && cl_prydoncursor.integer <= 0)
599 float modulatedsensitivity = sensitivity.value * cl.sensitivityscale;
600 if (in_strafe.state & 1)
602 // strafing mode, all looking is movement
604 cl.cmd.sidemove += m_side.value * in_mouse_x * modulatedsensitivity;
605 if (noclip_anglehack)
606 cl.cmd.upmove -= m_forward.value * in_mouse_y * modulatedsensitivity;
608 cl.cmd.forwardmove -= m_forward.value * in_mouse_y * modulatedsensitivity;
610 else if ((in_mlook.state & 1) || freelook.integer)
612 // mouselook, lookstrafe causes turning to become strafing
614 if (lookstrafe.integer)
615 cl.cmd.sidemove += m_side.value * in_mouse_x * modulatedsensitivity;
617 cl.viewangles[YAW] -= m_yaw.value * in_mouse_x * modulatedsensitivity * cl.viewzoom;
618 cl.viewangles[PITCH] += m_pitch.value * in_mouse_y * modulatedsensitivity * cl.viewzoom;
622 // non-mouselook, yaw turning and forward/back movement
623 cl.viewangles[YAW] -= m_yaw.value * in_mouse_x * modulatedsensitivity * cl.viewzoom;
624 cl.cmd.forwardmove -= m_forward.value * in_mouse_y * modulatedsensitivity;
627 else // don't pitch drift when csqc is controlling the mouse
629 // mouse interacting with the scene, mostly stationary view
631 // update prydon cursor
632 cl.cmd.cursor_screen[0] = in_windowmouse_x * 2.0 / vid.width - 1.0;
633 cl.cmd.cursor_screen[1] = in_windowmouse_y * 2.0 / vid.height - 1.0;
636 if(v_flipped.integer)
638 cl.viewangles[YAW] = -cl.viewangles[YAW];
639 cl.cmd.sidemove = -cl.cmd.sidemove;
642 // clamp after the move to prevent rendering with bad angles
645 if(cl_movecliptokeyboard.integer)
648 if (in_speed.state & 1)
649 f *= cl_movespeedkey.value;
650 if(cl_movecliptokeyboard.integer == 2)
652 // digital direction, analog amount
653 vec_t wishvel_x, wishvel_y;
654 wishvel_x = fabs(cl.cmd.forwardmove);
655 wishvel_y = fabs(cl.cmd.sidemove);
656 if(wishvel_x != 0 && wishvel_y != 0 && wishvel_x != wishvel_y)
658 vec_t wishspeed = sqrt(wishvel_x * wishvel_x + wishvel_y * wishvel_y);
659 if(wishvel_x >= 2 * wishvel_y)
662 if(cl.cmd.forwardmove > 0)
663 cl.cmd.forwardmove = wishspeed;
665 cl.cmd.forwardmove = -wishspeed;
668 else if(wishvel_y >= 2 * wishvel_x)
671 cl.cmd.forwardmove = 0;
672 if(cl.cmd.sidemove > 0)
673 cl.cmd.sidemove = wishspeed;
675 cl.cmd.sidemove = -wishspeed;
680 if(cl.cmd.forwardmove > 0)
681 cl.cmd.forwardmove = 0.70710678118654752440 * wishspeed;
683 cl.cmd.forwardmove = -0.70710678118654752440 * wishspeed;
684 if(cl.cmd.sidemove > 0)
685 cl.cmd.sidemove = 0.70710678118654752440 * wishspeed;
687 cl.cmd.sidemove = -0.70710678118654752440 * wishspeed;
691 else if(cl_movecliptokeyboard.integer)
693 // digital direction, digital amount
694 if(cl.cmd.sidemove >= cl_sidespeed.value * f * 0.5)
695 cl.cmd.sidemove = cl_sidespeed.value * f;
696 else if(cl.cmd.sidemove <= -cl_sidespeed.value * f * 0.5)
697 cl.cmd.sidemove = -cl_sidespeed.value * f;
700 if(cl.cmd.forwardmove >= cl_forwardspeed.value * f * 0.5)
701 cl.cmd.forwardmove = cl_forwardspeed.value * f;
702 else if(cl.cmd.forwardmove <= -cl_backspeed.value * f * 0.5)
703 cl.cmd.forwardmove = -cl_backspeed.value * f;
705 cl.cmd.forwardmove = 0;
710 #include "cl_collision.h"
712 static void CL_UpdatePrydonCursor(void)
716 if (cl_prydoncursor.integer <= 0)
717 VectorClear(cl.cmd.cursor_screen);
720 if (cl.cmd.cursor_screen[0] < -1)
722 cl.viewangles[YAW] -= m_yaw.value * (cl.cmd.cursor_screen[0] - -1) * vid.width * sensitivity.value * cl.viewzoom;
723 cl.cmd.cursor_screen[0] = -1;
725 if (cl.cmd.cursor_screen[0] > 1)
727 cl.viewangles[YAW] -= m_yaw.value * (cl.cmd.cursor_screen[0] - 1) * vid.width * sensitivity.value * cl.viewzoom;
728 cl.cmd.cursor_screen[0] = 1;
730 if (cl.cmd.cursor_screen[1] < -1)
732 cl.viewangles[PITCH] += m_pitch.value * (cl.cmd.cursor_screen[1] - -1) * vid.height * sensitivity.value * cl.viewzoom;
733 cl.cmd.cursor_screen[1] = -1;
735 if (cl.cmd.cursor_screen[1] > 1)
737 cl.viewangles[PITCH] += m_pitch.value * (cl.cmd.cursor_screen[1] - 1) * vid.height * sensitivity.value * cl.viewzoom;
738 cl.cmd.cursor_screen[1] = 1;
741 cl.cmd.cursor_screen[0] = bound(-1, cl.cmd.cursor_screen[0], 1);
742 cl.cmd.cursor_screen[1] = bound(-1, cl.cmd.cursor_screen[1], 1);
743 cl.cmd.cursor_screen[2] = 1;
745 // calculate current view matrix
746 Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, cl.cmd.cursor_start);
747 // calculate direction vector of cursor in viewspace by using frustum slopes
748 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);
749 Matrix4x4_Transform(&r_refdef.view.matrix, temp, cl.cmd.cursor_end);
750 // trace from view origin to the cursor
751 if (cl_prydoncursor_notrace.integer)
753 cl.cmd.cursor_fraction = 1.0f;
754 VectorCopy(cl.cmd.cursor_end, cl.cmd.cursor_impact);
755 VectorClear(cl.cmd.cursor_normal);
756 cl.cmd.cursor_entitynumber = 0;
759 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);
762 #define NUMOFFSETS 27
763 static vec3_t offsets[NUMOFFSETS] =
765 // 1 no nudge (just return the original if this test passes)
766 { 0.000, 0.000, 0.000},
768 { 0.000, 0.000, 0.125}, { 0.000, 0.000, -0.125},
769 {-0.125, 0.000, 0.000}, { 0.125, 0.000, 0.000},
770 { 0.000, -0.125, 0.000}, { 0.000, 0.125, 0.000},
771 // 4 diagonal flat nudges
772 {-0.125, -0.125, 0.000}, { 0.125, -0.125, 0.000},
773 {-0.125, 0.125, 0.000}, { 0.125, 0.125, 0.000},
774 // 8 diagonal upward nudges
775 {-0.125, 0.000, 0.125}, { 0.125, 0.000, 0.125},
776 { 0.000, -0.125, 0.125}, { 0.000, 0.125, 0.125},
777 {-0.125, -0.125, 0.125}, { 0.125, -0.125, 0.125},
778 {-0.125, 0.125, 0.125}, { 0.125, 0.125, 0.125},
779 // 8 diagonal downward nudges
780 {-0.125, 0.000, -0.125}, { 0.125, 0.000, -0.125},
781 { 0.000, -0.125, -0.125}, { 0.000, 0.125, -0.125},
782 {-0.125, -0.125, -0.125}, { 0.125, -0.125, -0.125},
783 {-0.125, 0.125, -0.125}, { 0.125, 0.125, -0.125},
786 static qboolean CL_ClientMovement_Unstick(cl_clientmovement_state_t *s)
790 for (i = 0;i < NUMOFFSETS;i++)
792 VectorAdd(offsets[i], s->origin, neworigin);
793 if (!CL_TraceBox(neworigin, cl.playercrouchmins, cl.playercrouchmaxs, neworigin, MOVE_NORMAL, s->self, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, 0, 0, collision_extendmovelength.value, true, true, NULL, true).startsolid)
795 VectorCopy(neworigin, s->origin);
799 // if all offsets failed, give up
803 static void CL_ClientMovement_UpdateStatus(cl_clientmovement_state_t *s)
806 vec3_t origin1, origin2;
809 // make sure player is not stuck
810 CL_ClientMovement_Unstick(s);
815 // wants to crouch, this always works..
821 // wants to stand, if currently crouching we need to check for a
825 trace = CL_TraceBox(s->origin, cl.playerstandmins, cl.playerstandmaxs, s->origin, MOVE_NORMAL, s->self, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, 0, 0, collision_extendmovelength.value, true, true, NULL, true);
826 if (!trace.startsolid)
832 VectorCopy(cl.playercrouchmins, s->mins);
833 VectorCopy(cl.playercrouchmaxs, s->maxs);
837 VectorCopy(cl.playerstandmins, s->mins);
838 VectorCopy(cl.playerstandmaxs, s->maxs);
842 VectorSet(origin1, s->origin[0], s->origin[1], s->origin[2] + 1);
843 VectorSet(origin2, s->origin[0], s->origin[1], s->origin[2] - 1); // -2 causes clientside doublejump bug at above 150fps, raising that to 300fps :)
844 trace = CL_TraceBox(origin1, s->mins, s->maxs, origin2, MOVE_NORMAL, s->self, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, 0, 0, collision_extendmovelength.value, true, true, NULL, true);
845 if(trace.fraction < 1 && trace.plane.normal[2] > 0.7)
849 // this code actually "predicts" an impact; so let's clip velocity first
850 f = DotProduct(s->velocity, trace.plane.normal);
851 if(f < 0) // only if moving downwards actually
852 VectorMA(s->velocity, -f, trace.plane.normal, s->velocity);
857 // set watertype/waterlevel
858 VectorSet(origin1, s->origin[0], s->origin[1], s->origin[2] + s->mins[2] + 1);
859 s->waterlevel = WATERLEVEL_NONE;
860 s->watertype = CL_TracePoint(origin1, MOVE_NOMONSTERS, s->self, 0, 0, 0, true, false, NULL, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK;
863 s->waterlevel = WATERLEVEL_WETFEET;
864 origin1[2] = s->origin[2] + (s->mins[2] + s->maxs[2]) * 0.5f;
865 if (CL_TracePoint(origin1, MOVE_NOMONSTERS, s->self, 0, 0, 0, true, false, NULL, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK)
867 s->waterlevel = WATERLEVEL_SWIMMING;
868 origin1[2] = s->origin[2] + 22;
869 if (CL_TracePoint(origin1, MOVE_NOMONSTERS, s->self, 0, 0, 0, true, false, NULL, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK)
870 s->waterlevel = WATERLEVEL_SUBMERGED;
874 // water jump prediction
875 if (s->onground || s->velocity[2] <= 0 || s->waterjumptime <= 0)
876 s->waterjumptime = 0;
879 static void CL_ClientMovement_Move(cl_clientmovement_state_t *s)
885 vec3_t currentorigin2;
887 vec3_t primalvelocity;
891 CL_ClientMovement_UpdateStatus(s);
892 VectorCopy(s->velocity, primalvelocity);
893 for (bump = 0, t = s->cmd.frametime;bump < 8 && VectorLength2(s->velocity) > 0;bump++)
895 VectorMA(s->origin, t, s->velocity, neworigin);
896 trace = CL_TraceBox(s->origin, s->mins, s->maxs, neworigin, MOVE_NORMAL, s->self, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, 0, 0, collision_extendmovelength.value, true, true, NULL, true);
897 if (trace.fraction < 1 && trace.plane.normal[2] == 0)
899 // may be a step or wall, try stepping up
900 // first move forward at a higher level
901 VectorSet(currentorigin2, s->origin[0], s->origin[1], s->origin[2] + cl.movevars_stepheight);
902 VectorSet(neworigin2, neworigin[0], neworigin[1], s->origin[2] + cl.movevars_stepheight);
903 trace2 = CL_TraceBox(currentorigin2, s->mins, s->maxs, neworigin2, MOVE_NORMAL, s->self, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, 0, 0, collision_extendmovelength.value, true, true, NULL, true);
904 if (!trace2.startsolid)
906 // then move down from there
907 VectorCopy(trace2.endpos, currentorigin2);
908 VectorSet(neworigin2, trace2.endpos[0], trace2.endpos[1], s->origin[2]);
909 trace3 = CL_TraceBox(currentorigin2, s->mins, s->maxs, neworigin2, MOVE_NORMAL, s->self, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, 0, 0, collision_extendmovelength.value, true, true, NULL, true);
910 //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]);
911 // accept the new trace if it made some progress
912 if (fabs(trace3.endpos[0] - trace.endpos[0]) >= 0.03125 || fabs(trace3.endpos[1] - trace.endpos[1]) >= 0.03125)
915 VectorCopy(trace3.endpos, trace.endpos);
920 // check if it moved at all
921 if (trace.fraction >= 0.001)
922 VectorCopy(trace.endpos, s->origin);
924 // check if it moved all the way
925 if (trace.fraction == 1)
928 // this is only really needed for nogravityonground combined with gravityunaffectedbyticrate
929 // <LadyHavoc> I'm pretty sure I commented it out solely because it seemed redundant
930 // this got commented out in a change that supposedly makes the code match QW better
931 // so if this is broken, maybe put it in an if(cls.protocol != PROTOCOL_QUAKEWORLD) block
932 if (trace.plane.normal[2] > 0.7)
935 t -= t * trace.fraction;
937 f = DotProduct(s->velocity, trace.plane.normal);
938 VectorMA(s->velocity, -f, trace.plane.normal, s->velocity);
940 if (s->waterjumptime > 0)
941 VectorCopy(primalvelocity, s->velocity);
945 static void CL_ClientMovement_Physics_Swim(cl_clientmovement_state_t *s)
952 // water jump only in certain situations
953 // this mimics quakeworld code
954 if (s->cmd.jump && s->waterlevel == 2 && s->velocity[2] >= -180)
959 VectorSet(yawangles, 0, s->cmd.viewangles[1], 0);
960 AngleVectors(yawangles, forward, NULL, NULL);
961 VectorMA(s->origin, 24, forward, spot);
963 if (CL_TracePoint(spot, MOVE_NOMONSTERS, s->self, 0, 0, 0, true, false, NULL, false).startsolid)
966 if (!CL_TracePoint(spot, MOVE_NOMONSTERS, s->self, 0, 0, 0, true, false, NULL, false).startsolid)
968 VectorScale(forward, 50, s->velocity);
969 s->velocity[2] = 310;
970 s->waterjumptime = 2;
972 s->cmd.canjump = false;
977 if (!(s->cmd.forwardmove*s->cmd.forwardmove + s->cmd.sidemove*s->cmd.sidemove + s->cmd.upmove*s->cmd.upmove))
979 // drift towards bottom
980 VectorSet(wishvel, 0, 0, -60);
988 // calculate movement vector
989 AngleVectors(s->cmd.viewangles, forward, right, up);
990 VectorSet(up, 0, 0, 1);
991 VectorMAMAM(s->cmd.forwardmove, forward, s->cmd.sidemove, right, s->cmd.upmove, up, wishvel);
994 // split wishvel into wishspeed and wishdir
995 wishspeed = VectorLength(wishvel);
997 VectorScale(wishvel, 1 / wishspeed, wishdir);
999 VectorSet( wishdir, 0.0, 0.0, 0.0 );
1000 wishspeed = min(wishspeed, cl.movevars_maxspeed) * 0.7;
1005 if (s->waterjumptime <= 0)
1008 f = 1 - s->cmd.frametime * cl.movevars_waterfriction * (cls.protocol == PROTOCOL_QUAKEWORLD ? s->waterlevel : 1);
1010 VectorScale(s->velocity, f, s->velocity);
1012 // water acceleration
1013 f = wishspeed - DotProduct(s->velocity, wishdir);
1016 f = min(cl.movevars_wateraccelerate * s->cmd.frametime * wishspeed, f);
1017 VectorMA(s->velocity, f, wishdir, s->velocity);
1020 // holding jump button swims upward slowly
1023 if (s->watertype & SUPERCONTENTS_LAVA)
1024 s->velocity[2] = 50;
1025 else if (s->watertype & SUPERCONTENTS_SLIME)
1026 s->velocity[2] = 80;
1029 if (IS_NEXUIZ_DERIVED(gamemode))
1030 s->velocity[2] = 200;
1032 s->velocity[2] = 100;
1037 CL_ClientMovement_Move(s);
1040 static vec_t CL_IsMoveInDirection(vec_t forward, vec_t side, vec_t angle)
1042 if(forward == 0 && side == 0)
1043 return 0; // avoid division by zero
1044 angle -= RAD2DEG(atan2(side, forward));
1045 angle = (ANGLEMOD(angle + 180) - 180) / 45;
1050 return 1 - fabs(angle);
1053 static vec_t CL_GeomLerp(vec_t a, vec_t lerp, vec_t b)
1069 return a * pow(fabs(b / a), lerp);
1072 static void CL_ClientMovement_Physics_CPM_PM_Aircontrol(cl_clientmovement_state_t *s, vec3_t wishdir, vec_t wishspeed)
1074 vec_t zspeed, speed, dot, k;
1077 // this doesn't play well with analog input
1078 if(s->cmd.forwardmove == 0 || s->cmd.sidemove != 0)
1082 k = 32 * (2 * CL_IsMoveInDirection(s->cmd.forwardmove, s->cmd.sidemove, 0) - 1);
1087 k *= bound(0, wishspeed / cl.movevars_maxairspeed, 1);
1089 zspeed = s->velocity[2];
1091 speed = VectorNormalizeLength(s->velocity);
1093 dot = DotProduct(s->velocity, wishdir);
1095 if(dot > 0) { // we can't change direction while slowing down
1096 k *= pow(dot, cl.movevars_aircontrol_power)*s->cmd.frametime;
1097 speed = max(0, speed - cl.movevars_aircontrol_penalty * sqrt(max(0, 1 - dot*dot)) * k/32);
1098 k *= cl.movevars_aircontrol;
1099 VectorMAM(speed, s->velocity, k, wishdir, s->velocity);
1100 VectorNormalize(s->velocity);
1103 VectorScale(s->velocity, speed, s->velocity);
1104 s->velocity[2] = zspeed;
1107 static float CL_ClientMovement_Physics_AdjustAirAccelQW(float accelqw, float factor)
1110 (accelqw < 0 ? -1 : +1)
1112 bound(0.000001, 1 - (1 - fabs(accelqw)) * factor, 1);
1115 static void CL_ClientMovement_Physics_PM_Accelerate(cl_clientmovement_state_t *s, vec3_t wishdir, vec_t wishspeed, vec_t wishspeed0, vec_t accel, vec_t accelqw, vec_t stretchfactor, vec_t sidefric, vec_t speedlimit)
1122 vec_t vel_xy_current;
1123 vec_t vel_xy_backward, vel_xy_forward;
1126 if(stretchfactor > 0)
1127 speedclamp = stretchfactor;
1128 else if(accelqw < 0)
1131 speedclamp = -1; // no clamping
1136 if(cl.moveflags & MOVEFLAG_Q2AIRACCELERATE)
1137 wishspeed0 = wishspeed; // don't need to emulate this Q1 bug
1139 vel_straight = DotProduct(s->velocity, wishdir);
1140 vel_z = s->velocity[2];
1141 VectorCopy(s->velocity, vel_xy); vel_xy[2] -= vel_z;
1142 VectorMA(vel_xy, -vel_straight, wishdir, vel_perpend);
1144 step = accel * s->cmd.frametime * wishspeed0;
1146 vel_xy_current = VectorLength(vel_xy);
1148 accelqw = CL_ClientMovement_Physics_AdjustAirAccelQW(accelqw, (speedlimit - bound(wishspeed, vel_xy_current, speedlimit)) / max(1, speedlimit - wishspeed));
1149 vel_xy_forward = vel_xy_current + bound(0, wishspeed - vel_xy_current, step) * accelqw + step * (1 - accelqw);
1150 vel_xy_backward = vel_xy_current - bound(0, wishspeed + vel_xy_current, step) * accelqw - step * (1 - accelqw);
1151 if(vel_xy_backward < 0)
1152 vel_xy_backward = 0; // not that it REALLY occurs that this would cause wrong behaviour afterwards
1154 vel_straight = vel_straight + bound(0, wishspeed - vel_straight, step) * accelqw + step * (1 - accelqw);
1156 if(sidefric < 0 && VectorLength2(vel_perpend))
1157 // negative: only apply so much sideways friction to stay below the speed you could get by "braking"
1160 f = max(0, 1 + s->cmd.frametime * wishspeed * sidefric);
1161 fmin = (vel_xy_backward*vel_xy_backward - vel_straight*vel_straight) / VectorLength2(vel_perpend);
1163 // vel_xy_backward*vel_xy_backward - vel_straight*vel_straight > vel_perpend*vel_perpend
1164 // vel_xy_backward*vel_xy_backward > vel_straight*vel_straight + vel_perpend*vel_perpend
1165 // vel_xy_backward*vel_xy_backward > vel_xy * vel_xy
1166 // obviously, this cannot be
1168 VectorScale(vel_perpend, f, vel_perpend);
1172 VectorScale(vel_perpend, max(fmin, f), vel_perpend);
1176 VectorScale(vel_perpend, max(0, 1 - s->cmd.frametime * wishspeed * sidefric), vel_perpend);
1178 VectorMA(vel_perpend, vel_straight, wishdir, s->velocity);
1182 vec_t vel_xy_preclamp;
1183 vel_xy_preclamp = VectorLength(s->velocity);
1184 if(vel_xy_preclamp > 0) // prevent division by zero
1186 vel_xy_current += (vel_xy_forward - vel_xy_current) * speedclamp;
1187 if(vel_xy_current < vel_xy_preclamp)
1188 VectorScale(s->velocity, (vel_xy_current / vel_xy_preclamp), s->velocity);
1192 s->velocity[2] += vel_z;
1195 static void CL_ClientMovement_Physics_PM_AirAccelerate(cl_clientmovement_state_t *s, vec3_t wishdir, vec_t wishspeed)
1197 vec3_t curvel, wishvel, acceldir, curdir;
1198 float addspeed, accelspeed, curspeed;
1201 float airforwardaccel = cl.movevars_warsowbunny_airforwardaccel;
1202 float bunnyaccel = cl.movevars_warsowbunny_accel;
1203 float bunnytopspeed = cl.movevars_warsowbunny_topspeed;
1204 float turnaccel = cl.movevars_warsowbunny_turnaccel;
1205 float backtosideratio = cl.movevars_warsowbunny_backtosideratio;
1210 VectorCopy( s->velocity, curvel );
1212 curspeed = VectorLength( curvel );
1214 if( wishspeed > curspeed * 1.01f )
1216 float faccelspeed = curspeed + airforwardaccel * cl.movevars_maxairspeed * s->cmd.frametime;
1217 if( faccelspeed < wishspeed )
1218 wishspeed = faccelspeed;
1222 float f = ( bunnytopspeed - curspeed ) / ( bunnytopspeed - cl.movevars_maxairspeed );
1225 wishspeed = max( curspeed, cl.movevars_maxairspeed ) + bunnyaccel * f * cl.movevars_maxairspeed * s->cmd.frametime;
1227 VectorScale( wishdir, wishspeed, wishvel );
1228 VectorSubtract( wishvel, curvel, acceldir );
1229 addspeed = VectorNormalizeLength( acceldir );
1231 accelspeed = turnaccel * cl.movevars_maxairspeed /* wishspeed */ * s->cmd.frametime;
1232 if( accelspeed > addspeed )
1233 accelspeed = addspeed;
1235 if( backtosideratio < 1.0f )
1237 VectorNormalize2( curvel, curdir );
1238 dot = DotProduct( acceldir, curdir );
1240 VectorMA( acceldir, -( 1.0f - backtosideratio ) * dot, curdir, acceldir );
1243 VectorMA( s->velocity, accelspeed, acceldir, s->velocity );
1246 static void CL_ClientMovement_Physics_Walk(cl_clientmovement_state_t *s)
1262 // jump if on ground with jump button pressed but only if it has been
1263 // released at least once since the last jump
1266 if (s->onground && (s->cmd.canjump || !cl_movement_track_canjump.integer))
1268 s->velocity[2] += cl.movevars_jumpvelocity;
1269 s->onground = false;
1270 s->cmd.canjump = false;
1274 s->cmd.canjump = true;
1276 // calculate movement vector
1277 VectorSet(yawangles, 0, s->cmd.viewangles[1], 0);
1278 AngleVectors(yawangles, forward, right, up);
1279 VectorMAM(s->cmd.forwardmove, forward, s->cmd.sidemove, right, wishvel);
1281 // split wishvel into wishspeed and wishdir
1282 wishspeed = VectorLength(wishvel);
1284 VectorScale(wishvel, 1 / wishspeed, wishdir);
1286 VectorSet( wishdir, 0.0, 0.0, 0.0 );
1287 // check if onground
1290 wishspeed = min(wishspeed, cl.movevars_maxspeed);
1294 // apply edge friction
1295 f = sqrt(s->velocity[0] * s->velocity[0] + s->velocity[1] * s->velocity[1]);
1298 friction = cl.movevars_friction;
1299 if (cl.movevars_edgefriction != 1)
1303 // note: QW uses the full player box for the trace, and yet still
1304 // uses s->origin[2] + s->mins[2], which is clearly an bug, but
1305 // this mimics it for compatibility
1306 VectorSet(neworigin2, s->origin[0] + s->velocity[0]*(16/f), s->origin[1] + s->velocity[1]*(16/f), s->origin[2] + s->mins[2]);
1307 VectorSet(neworigin3, neworigin2[0], neworigin2[1], neworigin2[2] - 34);
1308 if (cls.protocol == PROTOCOL_QUAKEWORLD)
1309 trace = CL_TraceBox(neworigin2, s->mins, s->maxs, neworigin3, MOVE_NORMAL, s->self, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, 0, 0, collision_extendmovelength.value, true, true, NULL, true);
1311 trace = CL_TraceLine(neworigin2, neworigin3, MOVE_NORMAL, s->self, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, 0, 0, collision_extendmovelength.value, true, true, NULL, true, false);
1312 if (trace.fraction == 1 && !trace.startsolid)
1313 friction *= cl.movevars_edgefriction;
1315 // apply ground friction
1316 f = 1 - s->cmd.frametime * friction * ((f < cl.movevars_stopspeed) ? (cl.movevars_stopspeed / f) : 1);
1318 VectorScale(s->velocity, f, s->velocity);
1320 addspeed = wishspeed - DotProduct(s->velocity, wishdir);
1323 accelspeed = min(cl.movevars_accelerate * s->cmd.frametime * wishspeed, addspeed);
1324 VectorMA(s->velocity, accelspeed, wishdir, s->velocity);
1326 gravity = cl.movevars_gravity * cl.movevars_entgravity * s->cmd.frametime;
1327 if(!(cl.moveflags & MOVEFLAG_NOGRAVITYONGROUND))
1329 if(cl.moveflags & MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE)
1330 s->velocity[2] -= gravity * 0.5f;
1332 s->velocity[2] -= gravity;
1334 if (cls.protocol == PROTOCOL_QUAKEWORLD)
1336 if (VectorLength2(s->velocity))
1337 CL_ClientMovement_Move(s);
1338 if(!(cl.moveflags & MOVEFLAG_NOGRAVITYONGROUND) || !s->onground)
1340 if(cl.moveflags & MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE)
1341 s->velocity[2] -= gravity * 0.5f;
1346 if (s->waterjumptime <= 0)
1348 // apply air speed limit
1349 vec_t accel, wishspeed0, wishspeed2, accelqw, strafity;
1350 qboolean accelerating;
1352 accelqw = cl.movevars_airaccel_qw;
1353 wishspeed0 = wishspeed;
1354 wishspeed = min(wishspeed, cl.movevars_maxairspeed);
1357 accel = cl.movevars_airaccelerate;
1359 accelerating = (DotProduct(s->velocity, wishdir) > 0);
1360 wishspeed2 = wishspeed;
1363 if(cl.movevars_airstopaccelerate != 0)
1366 curdir[0] = s->velocity[0];
1367 curdir[1] = s->velocity[1];
1369 VectorNormalize(curdir);
1370 accel = accel + (cl.movevars_airstopaccelerate - accel) * max(0, -DotProduct(curdir, wishdir));
1372 strafity = CL_IsMoveInDirection(s->cmd.forwardmove, s->cmd.sidemove, -90) + CL_IsMoveInDirection(s->cmd.forwardmove, s->cmd.sidemove, +90); // if one is nonzero, other is always zero
1373 if(cl.movevars_maxairstrafespeed)
1374 wishspeed = min(wishspeed, CL_GeomLerp(cl.movevars_maxairspeed, strafity, cl.movevars_maxairstrafespeed));
1375 if(cl.movevars_airstrafeaccelerate)
1376 accel = CL_GeomLerp(cl.movevars_airaccelerate, strafity, cl.movevars_airstrafeaccelerate);
1377 if(cl.movevars_airstrafeaccel_qw)
1379 (((strafity > 0.5 ? cl.movevars_airstrafeaccel_qw : cl.movevars_airaccel_qw) >= 0) ? +1 : -1)
1381 (1 - CL_GeomLerp(1 - fabs(cl.movevars_airaccel_qw), strafity, 1 - fabs(cl.movevars_airstrafeaccel_qw)));
1384 if(cl.movevars_warsowbunny_turnaccel && accelerating && s->cmd.sidemove == 0 && s->cmd.forwardmove != 0)
1385 CL_ClientMovement_Physics_PM_AirAccelerate(s, wishdir, wishspeed2);
1387 CL_ClientMovement_Physics_PM_Accelerate(s, wishdir, wishspeed, wishspeed0, accel, accelqw, cl.movevars_airaccel_qw_stretchfactor, cl.movevars_airaccel_sideways_friction / cl.movevars_maxairspeed, cl.movevars_airspeedlimit_nonqw);
1389 if(cl.movevars_aircontrol)
1390 CL_ClientMovement_Physics_CPM_PM_Aircontrol(s, wishdir, wishspeed2);
1392 gravity = cl.movevars_gravity * cl.movevars_entgravity * s->cmd.frametime;
1393 if(cl.moveflags & MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE)
1394 s->velocity[2] -= gravity * 0.5f;
1396 s->velocity[2] -= gravity;
1397 CL_ClientMovement_Move(s);
1398 if(!(cl.moveflags & MOVEFLAG_NOGRAVITYONGROUND) || !s->onground)
1400 if(cl.moveflags & MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE)
1401 s->velocity[2] -= gravity * 0.5f;
1406 static void CL_ClientMovement_PlayerMove(cl_clientmovement_state_t *s)
1408 //Con_Printf(" %f", frametime);
1410 s->cmd.canjump = true;
1411 s->waterjumptime -= s->cmd.frametime;
1412 CL_ClientMovement_UpdateStatus(s);
1413 if (s->waterlevel >= WATERLEVEL_SWIMMING)
1414 CL_ClientMovement_Physics_Swim(s);
1416 CL_ClientMovement_Physics_Walk(s);
1419 extern cvar_t slowmo;
1420 void CL_UpdateMoveVars(void)
1422 if (cls.protocol == PROTOCOL_QUAKEWORLD)
1426 else if (cl.stats[STAT_MOVEVARS_TICRATE])
1428 cl.moveflags = cl.stats[STAT_MOVEFLAGS];
1429 cl.movevars_ticrate = cl.statsf[STAT_MOVEVARS_TICRATE];
1430 cl.movevars_timescale = cl.statsf[STAT_MOVEVARS_TIMESCALE];
1431 cl.movevars_gravity = cl.statsf[STAT_MOVEVARS_GRAVITY];
1432 cl.movevars_stopspeed = cl.statsf[STAT_MOVEVARS_STOPSPEED] ;
1433 cl.movevars_maxspeed = cl.statsf[STAT_MOVEVARS_MAXSPEED];
1434 cl.movevars_spectatormaxspeed = cl.statsf[STAT_MOVEVARS_SPECTATORMAXSPEED];
1435 cl.movevars_accelerate = cl.statsf[STAT_MOVEVARS_ACCELERATE];
1436 cl.movevars_airaccelerate = cl.statsf[STAT_MOVEVARS_AIRACCELERATE];
1437 cl.movevars_wateraccelerate = cl.statsf[STAT_MOVEVARS_WATERACCELERATE];
1438 cl.movevars_entgravity = cl.statsf[STAT_MOVEVARS_ENTGRAVITY];
1439 cl.movevars_jumpvelocity = cl.statsf[STAT_MOVEVARS_JUMPVELOCITY];
1440 cl.movevars_edgefriction = cl.statsf[STAT_MOVEVARS_EDGEFRICTION];
1441 cl.movevars_maxairspeed = cl.statsf[STAT_MOVEVARS_MAXAIRSPEED];
1442 cl.movevars_stepheight = cl.statsf[STAT_MOVEVARS_STEPHEIGHT];
1443 cl.movevars_airaccel_qw = cl.statsf[STAT_MOVEVARS_AIRACCEL_QW];
1444 cl.movevars_airaccel_qw_stretchfactor = cl.statsf[STAT_MOVEVARS_AIRACCEL_QW_STRETCHFACTOR];
1445 cl.movevars_airaccel_sideways_friction = cl.statsf[STAT_MOVEVARS_AIRACCEL_SIDEWAYS_FRICTION];
1446 cl.movevars_friction = cl.statsf[STAT_MOVEVARS_FRICTION];
1447 cl.movevars_wallfriction = cl.statsf[STAT_MOVEVARS_WALLFRICTION];
1448 cl.movevars_waterfriction = cl.statsf[STAT_MOVEVARS_WATERFRICTION];
1449 cl.movevars_airstopaccelerate = cl.statsf[STAT_MOVEVARS_AIRSTOPACCELERATE];
1450 cl.movevars_airstrafeaccelerate = cl.statsf[STAT_MOVEVARS_AIRSTRAFEACCELERATE];
1451 cl.movevars_maxairstrafespeed = cl.statsf[STAT_MOVEVARS_MAXAIRSTRAFESPEED];
1452 cl.movevars_airstrafeaccel_qw = cl.statsf[STAT_MOVEVARS_AIRSTRAFEACCEL_QW];
1453 cl.movevars_aircontrol = cl.statsf[STAT_MOVEVARS_AIRCONTROL];
1454 cl.movevars_aircontrol_power = cl.statsf[STAT_MOVEVARS_AIRCONTROL_POWER];
1455 cl.movevars_aircontrol_penalty = cl.statsf[STAT_MOVEVARS_AIRCONTROL_PENALTY];
1456 cl.movevars_warsowbunny_airforwardaccel = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_AIRFORWARDACCEL];
1457 cl.movevars_warsowbunny_accel = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_ACCEL];
1458 cl.movevars_warsowbunny_topspeed = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_TOPSPEED];
1459 cl.movevars_warsowbunny_turnaccel = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_TURNACCEL];
1460 cl.movevars_warsowbunny_backtosideratio = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_BACKTOSIDERATIO];
1461 cl.movevars_airspeedlimit_nonqw = cl.statsf[STAT_MOVEVARS_AIRSPEEDLIMIT_NONQW];
1466 cl.movevars_ticrate = (cls.demoplayback ? 1.0f : slowmo.value) / bound(1.0f, cl_netfps.value, 1000.0f);
1467 cl.movevars_timescale = (cls.demoplayback ? 1.0f : slowmo.value);
1468 cl.movevars_gravity = sv_gravity.value;
1469 cl.movevars_stopspeed = cl_movement_stopspeed.value;
1470 cl.movevars_maxspeed = cl_movement_maxspeed.value;
1471 cl.movevars_spectatormaxspeed = cl_movement_maxspeed.value;
1472 cl.movevars_accelerate = cl_movement_accelerate.value;
1473 cl.movevars_airaccelerate = cl_movement_airaccelerate.value < 0 ? cl_movement_accelerate.value : cl_movement_airaccelerate.value;
1474 cl.movevars_wateraccelerate = cl_movement_wateraccelerate.value < 0 ? cl_movement_accelerate.value : cl_movement_wateraccelerate.value;
1475 cl.movevars_friction = cl_movement_friction.value;
1476 cl.movevars_wallfriction = cl_movement_wallfriction.value;
1477 cl.movevars_waterfriction = cl_movement_waterfriction.value < 0 ? cl_movement_friction.value : cl_movement_waterfriction.value;
1478 cl.movevars_entgravity = 1;
1479 cl.movevars_jumpvelocity = cl_movement_jumpvelocity.value;
1480 cl.movevars_edgefriction = cl_movement_edgefriction.value;
1481 cl.movevars_maxairspeed = cl_movement_maxairspeed.value;
1482 cl.movevars_stepheight = cl_movement_stepheight.value;
1483 cl.movevars_airaccel_qw = cl_movement_airaccel_qw.value;
1484 cl.movevars_airaccel_qw_stretchfactor = 0;
1485 cl.movevars_airaccel_sideways_friction = cl_movement_airaccel_sideways_friction.value;
1486 cl.movevars_airstopaccelerate = 0;
1487 cl.movevars_airstrafeaccelerate = 0;
1488 cl.movevars_maxairstrafespeed = 0;
1489 cl.movevars_airstrafeaccel_qw = 0;
1490 cl.movevars_aircontrol = 0;
1491 cl.movevars_aircontrol_power = 2;
1492 cl.movevars_aircontrol_penalty = 0;
1493 cl.movevars_warsowbunny_airforwardaccel = 0;
1494 cl.movevars_warsowbunny_accel = 0;
1495 cl.movevars_warsowbunny_topspeed = 0;
1496 cl.movevars_warsowbunny_turnaccel = 0;
1497 cl.movevars_warsowbunny_backtosideratio = 0;
1498 cl.movevars_airspeedlimit_nonqw = 0;
1501 if(!(cl.moveflags & MOVEFLAG_VALID))
1503 if(gamemode == GAME_NEXUIZ) // Legacy hack to work with old servers of Nexuiz.
1504 cl.moveflags = MOVEFLAG_Q2AIRACCELERATE;
1507 if(cl.movevars_aircontrol_power <= 0)
1508 cl.movevars_aircontrol_power = 2; // CPMA default
1511 void CL_ClientMovement_PlayerMove_Frame(cl_clientmovement_state_t *s)
1513 // if a move is more than 50ms, do it as two moves (matching qwsv)
1514 //Con_Printf("%i ", s.cmd.msec);
1515 if(s->cmd.frametime > 0.0005)
1517 if (s->cmd.frametime > 0.05)
1519 s->cmd.frametime /= 2;
1520 CL_ClientMovement_PlayerMove(s);
1522 CL_ClientMovement_PlayerMove(s);
1526 // we REALLY need this handling to happen, even if the move is not executed
1528 s->cmd.canjump = true;
1532 void CL_ClientMovement_Replay(void)
1535 double totalmovemsec;
1536 cl_clientmovement_state_t s;
1538 VectorCopy(cl.mvelocity[0], cl.movement_velocity);
1540 if (cl.movement_predicted && !cl.movement_replay)
1543 if (!cl_movement_replay.integer)
1546 // set up starting state for the series of moves
1547 memset(&s, 0, sizeof(s));
1548 VectorCopy(cl.entities[cl.playerentity].state_current.origin, s.origin);
1549 VectorCopy(cl.mvelocity[0], s.velocity);
1550 s.crouched = true; // will be updated on first move
1551 //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]);
1554 for (i = 0;i < CL_MAX_USERCMDS;i++)
1555 if (cl.movecmd[i].sequence > cls.servermovesequence)
1556 totalmovemsec += cl.movecmd[i].msec;
1557 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);
1558 //Con_Printf("%i = %.0f >= %.0f && %u && (%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);
1559 if (cl.movement_predicted)
1561 //Con_Printf("%ims\n", cl.movecmd[0].msec);
1563 // replay the input queue to predict current location
1564 // note: this relies on the fact there's always one queue item at the end
1566 // find how many are still valid
1567 for (i = 0;i < CL_MAX_USERCMDS;i++)
1568 if (cl.movecmd[i].sequence <= cls.servermovesequence)
1570 // now walk them in oldest to newest order
1571 for (i--;i >= 0;i--)
1573 s.cmd = cl.movecmd[i];
1574 if (i < CL_MAX_USERCMDS - 1)
1575 s.cmd.canjump = cl.movecmd[i+1].canjump;
1577 CL_ClientMovement_PlayerMove_Frame(&s);
1579 cl.movecmd[i].canjump = s.cmd.canjump;
1582 CL_ClientMovement_UpdateStatus(&s);
1586 // get the first movement queue entry to know whether to crouch and such
1587 s.cmd = cl.movecmd[0];
1590 if (!cls.demoplayback) // for bob, speedometer
1592 cl.movement_replay = false;
1593 // update the interpolation target position and velocity
1594 VectorCopy(s.origin, cl.movement_origin);
1595 VectorCopy(s.velocity, cl.movement_velocity);
1598 // update the onground flag if appropriate
1599 if (cl.movement_predicted)
1601 // when predicted we simply set the flag according to the UpdateStatus
1602 cl.onground = s.onground;
1606 // when not predicted, cl.onground is cleared by cl_parse.c each time
1607 // an update packet is received, but can be forced on here to hide
1608 // server inconsistencies in the onground flag
1609 // (which mostly occur when stepping up stairs at very high framerates
1610 // where after the step up the move continues forward and not
1611 // downward so the ground is not detected)
1613 // such onground inconsistencies can cause jittery gun bobbing and
1614 // stair smoothing, so we set onground if UpdateStatus says so
1620 static void QW_MSG_WriteDeltaUsercmd(sizebuf_t *buf, usercmd_t *from, usercmd_t *to)
1625 if (to->viewangles[0] != from->viewangles[0])
1626 bits |= QW_CM_ANGLE1;
1627 if (to->viewangles[1] != from->viewangles[1])
1628 bits |= QW_CM_ANGLE2;
1629 if (to->viewangles[2] != from->viewangles[2])
1630 bits |= QW_CM_ANGLE3;
1631 if (to->forwardmove != from->forwardmove)
1632 bits |= QW_CM_FORWARD;
1633 if (to->sidemove != from->sidemove)
1635 if (to->upmove != from->upmove)
1637 if (to->buttons != from->buttons)
1638 bits |= QW_CM_BUTTONS;
1639 if (to->impulse != from->impulse)
1640 bits |= QW_CM_IMPULSE;
1642 MSG_WriteByte(buf, bits);
1643 if (bits & QW_CM_ANGLE1)
1644 MSG_WriteAngle16i(buf, to->viewangles[0]);
1645 if (bits & QW_CM_ANGLE2)
1646 MSG_WriteAngle16i(buf, to->viewangles[1]);
1647 if (bits & QW_CM_ANGLE3)
1648 MSG_WriteAngle16i(buf, to->viewangles[2]);
1649 if (bits & QW_CM_FORWARD)
1650 MSG_WriteShort(buf, (short) to->forwardmove);
1651 if (bits & QW_CM_SIDE)
1652 MSG_WriteShort(buf, (short) to->sidemove);
1653 if (bits & QW_CM_UP)
1654 MSG_WriteShort(buf, (short) to->upmove);
1655 if (bits & QW_CM_BUTTONS)
1656 MSG_WriteByte(buf, to->buttons);
1657 if (bits & QW_CM_IMPULSE)
1658 MSG_WriteByte(buf, to->impulse);
1659 MSG_WriteByte(buf, to->msec);
1662 void CL_NewFrameReceived(int num)
1664 if (developer_networkentities.integer >= 10)
1665 Con_Printf("recv: svc_entities %i\n", num);
1666 cl.latestframenums[cl.latestframenumsposition] = num;
1667 cl.latestsendnums[cl.latestframenumsposition] = cl.cmd.sequence;
1668 cl.latestframenumsposition = (cl.latestframenumsposition + 1) % LATESTFRAMENUMS;
1671 void CL_RotateMoves(const matrix4x4_t *m)
1673 // rotate viewangles in all previous moves
1677 for (i = 0;i < CL_MAX_USERCMDS;i++)
1679 if (cl.movecmd[i].sequence > cls.servermovesequence)
1681 usercmd_t *c = &cl.movecmd[i];
1682 AngleVectors(c->viewangles, f, r, u);
1683 Matrix4x4_Transform(m, f, v); VectorCopy(v, f);
1684 Matrix4x4_Transform(m, u, v); VectorCopy(v, u);
1685 AnglesFromVectors(c->viewangles, f, u, false);
1695 usercmd_t nullcmd; // for delta compression of qw moves
1696 void CL_SendMove(void)
1698 int i, j, packetloss;
1704 unsigned char data[1024];
1710 // if playing a demo, do nothing
1714 // we don't que moves during a lag spike (potential network timeout)
1715 quemove = realtime - cl.last_received_message < cl_movement_nettimeout.value;
1717 // we build up cl.cmd and then decide whether to send or not
1718 // we store this into cl.movecmd[0] for prediction each frame even if we
1719 // do not send, to make sure that prediction is instant
1720 cl.cmd.time = cl.time;
1721 cl.cmd.sequence = cls.netcon->outgoing_unreliable_sequence;
1724 // LadyHavoc: added 6 new buttons and use and chat buttons, and prydon cursor active button
1726 if (in_attack.state & 3) bits |= 1;
1727 if (in_jump.state & 3) bits |= 2;
1728 if (in_button3.state & 3) bits |= 4;
1729 if (in_button4.state & 3) bits |= 8;
1730 if (in_button5.state & 3) bits |= 16;
1731 if (in_button6.state & 3) bits |= 32;
1732 if (in_button7.state & 3) bits |= 64;
1733 if (in_button8.state & 3) bits |= 128;
1734 if (in_use.state & 3) bits |= 256;
1735 if (key_dest != key_game || key_consoleactive) bits |= 512;
1736 if (cl_prydoncursor.integer > 0) bits |= 1024;
1737 if (in_button9.state & 3) bits |= 2048;
1738 if (in_button10.state & 3) bits |= 4096;
1739 if (in_button11.state & 3) bits |= 8192;
1740 if (in_button12.state & 3) bits |= 16384;
1741 if (in_button13.state & 3) bits |= 32768;
1742 if (in_button14.state & 3) bits |= 65536;
1743 if (in_button15.state & 3) bits |= 131072;
1744 if (in_button16.state & 3) bits |= 262144;
1745 // button bits 19-31 unused currently
1746 // rotate/zoom view serverside if PRYDON_CLIENTCURSOR cursor is at edge of screen
1747 if(cl_prydoncursor.integer > 0)
1749 if (cl.cmd.cursor_screen[0] <= -1) bits |= 8;
1750 if (cl.cmd.cursor_screen[0] >= 1) bits |= 16;
1751 if (cl.cmd.cursor_screen[1] <= -1) bits |= 32;
1752 if (cl.cmd.cursor_screen[1] >= 1) bits |= 64;
1755 // set buttons and impulse
1756 cl.cmd.buttons = bits;
1757 cl.cmd.impulse = in_impulse;
1760 VectorCopy(cl.viewangles, cl.cmd.viewangles);
1762 msecdelta = (int)(floor(cl.cmd.time * 1000) - floor(cl.movecmd[1].time * 1000));
1763 cl.cmd.msec = (unsigned char)bound(0, msecdelta, 255);
1764 // ridiculous value rejection (matches qw)
1765 if (cl.cmd.msec > 250)
1767 cl.cmd.frametime = cl.cmd.msec * (1.0 / 1000.0);
1769 switch(cls.protocol)
1771 case PROTOCOL_QUAKEWORLD:
1772 // quakeworld uses a different cvar with opposite meaning, for compatibility
1773 cl.cmd.predicted = cl_nopred.integer == 0;
1775 case PROTOCOL_DARKPLACES6:
1776 case PROTOCOL_DARKPLACES7:
1777 cl.cmd.predicted = cl_movement.integer != 0;
1780 cl.cmd.predicted = false;
1784 // movement is set by input code (forwardmove/sidemove/upmove)
1785 // always dump the first two moves, because they may contain leftover inputs from the last level
1786 if (cl.cmd.sequence <= 2)
1787 cl.cmd.forwardmove = cl.cmd.sidemove = cl.cmd.upmove = cl.cmd.impulse = cl.cmd.buttons = 0;
1789 cl.cmd.jump = (cl.cmd.buttons & 2) != 0;
1791 switch (cls.protocol)
1793 case PROTOCOL_QUAKEWORLD:
1794 case PROTOCOL_QUAKE:
1795 case PROTOCOL_QUAKEDP:
1796 case PROTOCOL_NEHAHRAMOVIE:
1797 case PROTOCOL_NEHAHRABJP:
1798 case PROTOCOL_NEHAHRABJP2:
1799 case PROTOCOL_NEHAHRABJP3:
1800 case PROTOCOL_DARKPLACES1:
1801 case PROTOCOL_DARKPLACES2:
1802 case PROTOCOL_DARKPLACES3:
1803 case PROTOCOL_DARKPLACES4:
1804 case PROTOCOL_DARKPLACES5:
1806 case PROTOCOL_DARKPLACES6:
1807 case PROTOCOL_DARKPLACES7:
1808 // FIXME: cl.cmd.buttons & 16 is +button5, Nexuiz/Xonotic specific
1809 cl.cmd.crouch = (cl.cmd.buttons & 16) != 0;
1811 case PROTOCOL_UNKNOWN:
1816 cl.movecmd[0] = cl.cmd;
1818 // don't predict more than 200fps
1819 if (realtime >= cl.lastpackettime + 0.005)
1820 cl.movement_replay = true; // redo the prediction
1822 // now decide whether to actually send this move
1823 // (otherwise it is only for prediction)
1825 // don't send too often or else network connections can get clogged by a
1826 // high renderer framerate
1827 packettime = 1.0 / bound(1, cl_netfps.value, 1000);
1828 if (cl.movevars_timescale && cl.movevars_ticrate)
1830 float maxtic = cl.movevars_ticrate / cl.movevars_timescale;
1831 packettime = min(packettime, maxtic);
1834 // do not send 0ms packets because they mess up physics
1835 if(cl.cmd.msec == 0 && cl.time > cl.oldtime && (cls.protocol == PROTOCOL_QUAKEWORLD || cls.signon == SIGNONS))
1837 // always send if buttons changed or an impulse is pending
1838 // even if it violates the rate limit!
1839 important = (cl.cmd.impulse || (cl_netimmediatebuttons.integer && cl.cmd.buttons != cl.movecmd[1].buttons));
1840 // don't send too often (cl_netfps)
1841 if (!important && realtime < cl.lastpackettime + packettime)
1843 // don't choke the connection with packets (obey rate limit)
1844 // it is important that this check be last, because it adds a new
1845 // frame to the shownetgraph output and any cancelation after this
1846 // will produce a nasty spike-like look to the netgraph
1847 // we also still send if it is important
1848 if (!NetConn_CanSend(cls.netcon) && !important)
1850 // try to round off the lastpackettime to a multiple of the packet interval
1851 // (this causes it to emit packets at a steady beat)
1853 cl.lastpackettime = floor(realtime / packettime) * packettime;
1855 cl.lastpackettime = realtime;
1857 buf.maxsize = sizeof(data);
1861 // send the movement message
1862 // PROTOCOL_QUAKE clc_move = 16 bytes total
1863 // PROTOCOL_QUAKEDP clc_move = 16 bytes total
1864 // PROTOCOL_NEHAHRAMOVIE clc_move = 16 bytes total
1865 // PROTOCOL_DARKPLACES1 clc_move = 19 bytes total
1866 // PROTOCOL_DARKPLACES2 clc_move = 25 bytes total
1867 // PROTOCOL_DARKPLACES3 clc_move = 25 bytes total
1868 // PROTOCOL_DARKPLACES4 clc_move = 19 bytes total
1869 // PROTOCOL_DARKPLACES5 clc_move = 19 bytes total
1870 // PROTOCOL_DARKPLACES6 clc_move = 52 bytes total
1871 // PROTOCOL_DARKPLACES7 clc_move = 56 bytes total per move (can be up to 16 moves)
1872 // PROTOCOL_QUAKEWORLD clc_move = 34 bytes total (typically, but can reach 43 bytes, or even 49 bytes with roll)
1874 // set prydon cursor info
1875 CL_UpdatePrydonCursor();
1877 if (cls.protocol == PROTOCOL_QUAKEWORLD || cls.signon == SIGNONS)
1879 switch (cls.protocol)
1881 case PROTOCOL_QUAKEWORLD:
1882 MSG_WriteByte(&buf, qw_clc_move);
1883 // save the position for a checksum byte
1884 checksumindex = buf.cursize;
1885 MSG_WriteByte(&buf, 0);
1886 // packet loss percentage
1887 for (j = 0, packetloss = 0;j < NETGRAPH_PACKETS;j++)
1888 if (cls.netcon->incoming_netgraph[j].unreliablebytes == NETGRAPH_LOSTPACKET)
1890 packetloss = packetloss * 100 / NETGRAPH_PACKETS;
1891 MSG_WriteByte(&buf, packetloss);
1892 // write most recent 3 moves
1893 QW_MSG_WriteDeltaUsercmd(&buf, &nullcmd, &cl.movecmd[2]);
1894 QW_MSG_WriteDeltaUsercmd(&buf, &cl.movecmd[2], &cl.movecmd[1]);
1895 QW_MSG_WriteDeltaUsercmd(&buf, &cl.movecmd[1], &cl.cmd);
1896 // calculate the checksum
1897 buf.data[checksumindex] = COM_BlockSequenceCRCByteQW(buf.data + checksumindex + 1, buf.cursize - checksumindex - 1, cls.netcon->outgoing_unreliable_sequence);
1898 // if delta compression history overflows, request no delta
1899 if (cls.netcon->outgoing_unreliable_sequence - cl.qw_validsequence >= QW_UPDATE_BACKUP-1)
1900 cl.qw_validsequence = 0;
1901 // request delta compression if appropriate
1902 if (cl.qw_validsequence && !cl_nodelta.integer && cls.state == ca_connected && !cls.demorecording)
1904 cl.qw_deltasequence[cls.netcon->outgoing_unreliable_sequence & QW_UPDATE_MASK] = cl.qw_validsequence;
1905 MSG_WriteByte(&buf, qw_clc_delta);
1906 MSG_WriteByte(&buf, cl.qw_validsequence & 255);
1909 cl.qw_deltasequence[cls.netcon->outgoing_unreliable_sequence & QW_UPDATE_MASK] = -1;
1911 case PROTOCOL_QUAKE:
1912 case PROTOCOL_QUAKEDP:
1913 case PROTOCOL_NEHAHRAMOVIE:
1914 case PROTOCOL_NEHAHRABJP:
1915 case PROTOCOL_NEHAHRABJP2:
1916 case PROTOCOL_NEHAHRABJP3:
1918 MSG_WriteByte (&buf, clc_move);
1919 MSG_WriteFloat (&buf, cl.cmd.time); // last server packet time
1920 // 3 bytes (6 bytes in proquake)
1921 if (cls.proquake_servermod == 1) // MOD_PROQUAKE
1923 for (i = 0;i < 3;i++)
1924 MSG_WriteAngle16i (&buf, cl.cmd.viewangles[i]);
1928 for (i = 0;i < 3;i++)
1929 MSG_WriteAngle8i (&buf, cl.cmd.viewangles[i]);
1932 MSG_WriteCoord16i (&buf, cl.cmd.forwardmove);
1933 MSG_WriteCoord16i (&buf, cl.cmd.sidemove);
1934 MSG_WriteCoord16i (&buf, cl.cmd.upmove);
1936 MSG_WriteByte (&buf, cl.cmd.buttons);
1937 MSG_WriteByte (&buf, cl.cmd.impulse);
1939 case PROTOCOL_DARKPLACES2:
1940 case PROTOCOL_DARKPLACES3:
1942 MSG_WriteByte (&buf, clc_move);
1943 MSG_WriteFloat (&buf, cl.cmd.time); // last server packet time
1945 for (i = 0;i < 3;i++)
1946 MSG_WriteAngle32f (&buf, cl.cmd.viewangles[i]);
1948 MSG_WriteCoord16i (&buf, cl.cmd.forwardmove);
1949 MSG_WriteCoord16i (&buf, cl.cmd.sidemove);
1950 MSG_WriteCoord16i (&buf, cl.cmd.upmove);
1952 MSG_WriteByte (&buf, cl.cmd.buttons);
1953 MSG_WriteByte (&buf, cl.cmd.impulse);
1955 case PROTOCOL_DARKPLACES1:
1956 case PROTOCOL_DARKPLACES4:
1957 case PROTOCOL_DARKPLACES5:
1959 MSG_WriteByte (&buf, clc_move);
1960 MSG_WriteFloat (&buf, cl.cmd.time); // last server packet time
1962 for (i = 0;i < 3;i++)
1963 MSG_WriteAngle16i (&buf, cl.cmd.viewangles[i]);
1965 MSG_WriteCoord16i (&buf, cl.cmd.forwardmove);
1966 MSG_WriteCoord16i (&buf, cl.cmd.sidemove);
1967 MSG_WriteCoord16i (&buf, cl.cmd.upmove);
1969 MSG_WriteByte (&buf, cl.cmd.buttons);
1970 MSG_WriteByte (&buf, cl.cmd.impulse);
1971 case PROTOCOL_DARKPLACES6:
1972 case PROTOCOL_DARKPLACES7:
1973 // set the maxusercmds variable to limit how many should be sent
1974 maxusercmds = bound(1, cl_netrepeatinput.integer + 1, min(3, CL_MAX_USERCMDS));
1975 // when movement prediction is off, there's not much point in repeating old input as it will just be ignored
1976 if (!cl.cmd.predicted)
1979 // send the latest moves in order, the old ones will be
1980 // ignored by the server harmlessly, however if the previous
1981 // packets were lost these moves will be used
1983 // this reduces packet loss impact on gameplay.
1984 for (j = 0, cmd = &cl.movecmd[maxusercmds-1];j < maxusercmds;j++, cmd--)
1986 // don't repeat any stale moves
1987 if (cmd->sequence && cmd->sequence < cls.servermovesequence)
1990 MSG_WriteByte (&buf, clc_move);
1991 if (cls.protocol != PROTOCOL_DARKPLACES6)
1992 MSG_WriteLong (&buf, cmd->predicted ? cmd->sequence : 0);
1993 MSG_WriteFloat (&buf, cmd->time); // last server packet time
1995 for (i = 0;i < 3;i++)
1996 MSG_WriteAngle16i (&buf, cmd->viewangles[i]);
1998 MSG_WriteCoord16i (&buf, cmd->forwardmove);
1999 MSG_WriteCoord16i (&buf, cmd->sidemove);
2000 MSG_WriteCoord16i (&buf, cmd->upmove);
2002 MSG_WriteLong (&buf, cmd->buttons);
2003 MSG_WriteByte (&buf, cmd->impulse);
2004 // PRYDON_CLIENTCURSOR
2006 MSG_WriteShort (&buf, (short)(cmd->cursor_screen[0] * 32767.0f));
2007 MSG_WriteShort (&buf, (short)(cmd->cursor_screen[1] * 32767.0f));
2008 MSG_WriteFloat (&buf, cmd->cursor_start[0]);
2009 MSG_WriteFloat (&buf, cmd->cursor_start[1]);
2010 MSG_WriteFloat (&buf, cmd->cursor_start[2]);
2011 MSG_WriteFloat (&buf, cmd->cursor_impact[0]);
2012 MSG_WriteFloat (&buf, cmd->cursor_impact[1]);
2013 MSG_WriteFloat (&buf, cmd->cursor_impact[2]);
2014 MSG_WriteShort (&buf, cmd->cursor_entitynumber);
2017 case PROTOCOL_UNKNOWN:
2022 if (cls.protocol != PROTOCOL_QUAKEWORLD && buf.cursize)
2024 // ack entity frame numbers received since the last input was sent
2025 // (redundent to improve handling of client->server packet loss)
2026 // if cl_netrepeatinput is 1 and client framerate matches server
2027 // framerate, this is 10 bytes, if client framerate is lower this
2029 unsigned int oldsequence = cl.cmd.sequence;
2030 unsigned int delta = bound(1, cl_netrepeatinput.integer + 1, 3);
2031 if (oldsequence > delta)
2032 oldsequence = oldsequence - delta;
2035 for (i = 0;i < LATESTFRAMENUMS;i++)
2037 j = (cl.latestframenumsposition + i) % LATESTFRAMENUMS;
2038 if (cl.latestsendnums[j] >= oldsequence)
2040 if (developer_networkentities.integer >= 10)
2041 Con_Printf("send clc_ackframe %i\n", cl.latestframenums[j]);
2042 MSG_WriteByte(&buf, clc_ackframe);
2043 MSG_WriteLong(&buf, cl.latestframenums[j]);
2048 // PROTOCOL_DARKPLACES6 = 67 bytes per packet
2049 // PROTOCOL_DARKPLACES7 = 71 bytes per packet
2051 // acknowledge any recently received data blocks
2052 for (i = 0;i < CL_MAX_DOWNLOADACKS && (cls.dp_downloadack[i].start || cls.dp_downloadack[i].size);i++)
2054 MSG_WriteByte(&buf, clc_ackdownloaddata);
2055 MSG_WriteLong(&buf, cls.dp_downloadack[i].start);
2056 MSG_WriteShort(&buf, cls.dp_downloadack[i].size);
2057 cls.dp_downloadack[i].start = 0;
2058 cls.dp_downloadack[i].size = 0;
2061 // send the reliable message (forwarded commands) if there is one
2062 if (buf.cursize || cls.netcon->message.cursize)
2063 NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol, max(20*(buf.cursize+40), cl_rate.integer), cl_rate_burstsize.integer, false);
2067 // update the cl.movecmd array which holds the most recent moves,
2068 // because we now need a new slot for the next input
2069 for (i = CL_MAX_USERCMDS - 1;i >= 1;i--)
2070 cl.movecmd[i] = cl.movecmd[i-1];
2071 cl.movecmd[0].msec = 0;
2072 cl.movecmd[0].frametime = 0;
2075 // clear button 'click' states
2076 in_attack.state &= ~2;
2077 in_jump.state &= ~2;
2078 in_button3.state &= ~2;
2079 in_button4.state &= ~2;
2080 in_button5.state &= ~2;
2081 in_button6.state &= ~2;
2082 in_button7.state &= ~2;
2083 in_button8.state &= ~2;
2085 in_button9.state &= ~2;
2086 in_button10.state &= ~2;
2087 in_button11.state &= ~2;
2088 in_button12.state &= ~2;
2089 in_button13.state &= ~2;
2090 in_button14.state &= ~2;
2091 in_button15.state &= ~2;
2092 in_button16.state &= ~2;
2096 if (cls.netcon->message.overflowed)
2098 Con_Print("CL_SendMove: lost server connection\n");
2100 SV_LockThreadMutex();
2101 Host_ShutdownServer();
2102 SV_UnlockThreadMutex();
2111 void CL_InitInput (void)
2113 Cmd_AddCommand(&cmd_client, "+moveup",IN_UpDown, "swim upward");
2114 Cmd_AddCommand(&cmd_client, "-moveup",IN_UpUp, "stop swimming upward");
2115 Cmd_AddCommand(&cmd_client, "+movedown",IN_DownDown, "swim downward");
2116 Cmd_AddCommand(&cmd_client, "-movedown",IN_DownUp, "stop swimming downward");
2117 Cmd_AddCommand(&cmd_client, "+left",IN_LeftDown, "turn left");
2118 Cmd_AddCommand(&cmd_client, "-left",IN_LeftUp, "stop turning left");
2119 Cmd_AddCommand(&cmd_client, "+right",IN_RightDown, "turn right");
2120 Cmd_AddCommand(&cmd_client, "-right",IN_RightUp, "stop turning right");
2121 Cmd_AddCommand(&cmd_client, "+forward",IN_ForwardDown, "move forward");
2122 Cmd_AddCommand(&cmd_client, "-forward",IN_ForwardUp, "stop moving forward");
2123 Cmd_AddCommand(&cmd_client, "+back",IN_BackDown, "move backward");
2124 Cmd_AddCommand(&cmd_client, "-back",IN_BackUp, "stop moving backward");
2125 Cmd_AddCommand(&cmd_client, "+lookup", IN_LookupDown, "look upward");
2126 Cmd_AddCommand(&cmd_client, "-lookup", IN_LookupUp, "stop looking upward");
2127 Cmd_AddCommand(&cmd_client, "+lookdown", IN_LookdownDown, "look downward");
2128 Cmd_AddCommand(&cmd_client, "-lookdown", IN_LookdownUp, "stop looking downward");
2129 Cmd_AddCommand(&cmd_client, "+strafe", IN_StrafeDown, "activate strafing mode (move instead of turn)");
2130 Cmd_AddCommand(&cmd_client, "-strafe", IN_StrafeUp, "deactivate strafing mode");
2131 Cmd_AddCommand(&cmd_client, "+moveleft", IN_MoveleftDown, "strafe left");
2132 Cmd_AddCommand(&cmd_client, "-moveleft", IN_MoveleftUp, "stop strafing left");
2133 Cmd_AddCommand(&cmd_client, "+moveright", IN_MoverightDown, "strafe right");
2134 Cmd_AddCommand(&cmd_client, "-moveright", IN_MoverightUp, "stop strafing right");
2135 Cmd_AddCommand(&cmd_client, "+speed", IN_SpeedDown, "activate run mode (faster movement and turning)");
2136 Cmd_AddCommand(&cmd_client, "-speed", IN_SpeedUp, "deactivate run mode");
2137 Cmd_AddCommand(&cmd_client, "+attack", IN_AttackDown, "begin firing");
2138 Cmd_AddCommand(&cmd_client, "-attack", IN_AttackUp, "stop firing");
2139 Cmd_AddCommand(&cmd_client, "+jump", IN_JumpDown, "jump");
2140 Cmd_AddCommand(&cmd_client, "-jump", IN_JumpUp, "end jump (so you can jump again)");
2141 Cmd_AddCommand(&cmd_client, "impulse", IN_Impulse, "send an impulse number to server (select weapon, use item, etc)");
2142 Cmd_AddCommand(&cmd_client, "+klook", IN_KLookDown, "activate keyboard looking mode, do not recenter view");
2143 Cmd_AddCommand(&cmd_client, "-klook", IN_KLookUp, "deactivate keyboard looking mode");
2144 Cmd_AddCommand(&cmd_client, "+mlook", IN_MLookDown, "activate mouse looking mode, do not recenter view");
2145 Cmd_AddCommand(&cmd_client, "-mlook", IN_MLookUp, "deactivate mouse looking mode");
2147 // LadyHavoc: added lots of buttons
2148 Cmd_AddCommand(&cmd_client, "+use", IN_UseDown, "use something (may be used by some mods)");
2149 Cmd_AddCommand(&cmd_client, "-use", IN_UseUp, "stop using something");
2150 Cmd_AddCommand(&cmd_client, "+button3", IN_Button3Down, "activate button3 (behavior depends on mod)");
2151 Cmd_AddCommand(&cmd_client, "-button3", IN_Button3Up, "deactivate button3");
2152 Cmd_AddCommand(&cmd_client, "+button4", IN_Button4Down, "activate button4 (behavior depends on mod)");
2153 Cmd_AddCommand(&cmd_client, "-button4", IN_Button4Up, "deactivate button4");
2154 Cmd_AddCommand(&cmd_client, "+button5", IN_Button5Down, "activate button5 (behavior depends on mod)");
2155 Cmd_AddCommand(&cmd_client, "-button5", IN_Button5Up, "deactivate button5");
2156 Cmd_AddCommand(&cmd_client, "+button6", IN_Button6Down, "activate button6 (behavior depends on mod)");
2157 Cmd_AddCommand(&cmd_client, "-button6", IN_Button6Up, "deactivate button6");
2158 Cmd_AddCommand(&cmd_client, "+button7", IN_Button7Down, "activate button7 (behavior depends on mod)");
2159 Cmd_AddCommand(&cmd_client, "-button7", IN_Button7Up, "deactivate button7");
2160 Cmd_AddCommand(&cmd_client, "+button8", IN_Button8Down, "activate button8 (behavior depends on mod)");
2161 Cmd_AddCommand(&cmd_client, "-button8", IN_Button8Up, "deactivate button8");
2162 Cmd_AddCommand(&cmd_client, "+button9", IN_Button9Down, "activate button9 (behavior depends on mod)");
2163 Cmd_AddCommand(&cmd_client, "-button9", IN_Button9Up, "deactivate button9");
2164 Cmd_AddCommand(&cmd_client, "+button10", IN_Button10Down, "activate button10 (behavior depends on mod)");
2165 Cmd_AddCommand(&cmd_client, "-button10", IN_Button10Up, "deactivate button10");
2166 Cmd_AddCommand(&cmd_client, "+button11", IN_Button11Down, "activate button11 (behavior depends on mod)");
2167 Cmd_AddCommand(&cmd_client, "-button11", IN_Button11Up, "deactivate button11");
2168 Cmd_AddCommand(&cmd_client, "+button12", IN_Button12Down, "activate button12 (behavior depends on mod)");
2169 Cmd_AddCommand(&cmd_client, "-button12", IN_Button12Up, "deactivate button12");
2170 Cmd_AddCommand(&cmd_client, "+button13", IN_Button13Down, "activate button13 (behavior depends on mod)");
2171 Cmd_AddCommand(&cmd_client, "-button13", IN_Button13Up, "deactivate button13");
2172 Cmd_AddCommand(&cmd_client, "+button14", IN_Button14Down, "activate button14 (behavior depends on mod)");
2173 Cmd_AddCommand(&cmd_client, "-button14", IN_Button14Up, "deactivate button14");
2174 Cmd_AddCommand(&cmd_client, "+button15", IN_Button15Down, "activate button15 (behavior depends on mod)");
2175 Cmd_AddCommand(&cmd_client, "-button15", IN_Button15Up, "deactivate button15");
2176 Cmd_AddCommand(&cmd_client, "+button16", IN_Button16Down, "activate button16 (behavior depends on mod)");
2177 Cmd_AddCommand(&cmd_client, "-button16", IN_Button16Up, "deactivate button16");
2179 // LadyHavoc: added bestweapon command
2180 Cmd_AddCommand(&cmd_client, "bestweapon", IN_BestWeapon_f, "send an impulse number to server to select the first usable weapon out of several (example: 8 7 6 5 4 3 2 1)");
2181 Cmd_AddCommand(&cmd_client, "register_bestweapon", IN_BestWeapon_Register_f, "(for QC usage only) change weapon parameters to be used by bestweapon; stuffcmd this in ClientConnect");
2183 Cvar_RegisterVariable(&cl_movecliptokeyboard);
2184 Cvar_RegisterVariable(&cl_movement);
2185 Cvar_RegisterVariable(&cl_movement_replay);
2186 Cvar_RegisterVariable(&cl_movement_nettimeout);
2187 Cvar_RegisterVariable(&cl_movement_minping);
2188 Cvar_RegisterVariable(&cl_movement_track_canjump);
2189 Cvar_RegisterVariable(&cl_movement_maxspeed);
2190 Cvar_RegisterVariable(&cl_movement_maxairspeed);
2191 Cvar_RegisterVariable(&cl_movement_stopspeed);
2192 Cvar_RegisterVariable(&cl_movement_friction);
2193 Cvar_RegisterVariable(&cl_movement_wallfriction);
2194 Cvar_RegisterVariable(&cl_movement_waterfriction);
2195 Cvar_RegisterVariable(&cl_movement_edgefriction);
2196 Cvar_RegisterVariable(&cl_movement_stepheight);
2197 Cvar_RegisterVariable(&cl_movement_accelerate);
2198 Cvar_RegisterVariable(&cl_movement_airaccelerate);
2199 Cvar_RegisterVariable(&cl_movement_wateraccelerate);
2200 Cvar_RegisterVariable(&cl_movement_jumpvelocity);
2201 Cvar_RegisterVariable(&cl_movement_airaccel_qw);
2202 Cvar_RegisterVariable(&cl_movement_airaccel_sideways_friction);
2203 Cvar_RegisterVariable(&cl_nopred);
2205 Cvar_RegisterVariable(&in_pitch_min);
2206 Cvar_RegisterVariable(&in_pitch_max);
2207 Cvar_RegisterVariable(&m_filter);
2208 Cvar_RegisterVariable(&m_accelerate);
2209 Cvar_RegisterVariable(&m_accelerate_minspeed);
2210 Cvar_RegisterVariable(&m_accelerate_maxspeed);
2211 Cvar_RegisterVariable(&m_accelerate_filter);
2213 Cvar_RegisterVariable(&cl_netfps);
2214 Cvar_RegisterVariable(&cl_netrepeatinput);
2215 Cvar_RegisterVariable(&cl_netimmediatebuttons);
2217 Cvar_RegisterVariable(&cl_nodelta);
2219 Cvar_RegisterVariable(&cl_csqc_generatemousemoveevents);