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 qbool 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 = {CF_CLIENT | CF_ARCHIVE, "cl_upspeed","400","vertical movement speed (while swimming or flying)"};
365 cvar_t cl_forwardspeed = {CF_CLIENT | CF_ARCHIVE, "cl_forwardspeed","400","forward movement speed"};
366 cvar_t cl_backspeed = {CF_CLIENT | CF_ARCHIVE, "cl_backspeed","400","backward movement speed"};
367 cvar_t cl_sidespeed = {CF_CLIENT | CF_ARCHIVE, "cl_sidespeed","350","strafe movement speed"};
369 cvar_t cl_movespeedkey = {CF_CLIENT | CF_ARCHIVE, "cl_movespeedkey","2.0","how much +speed multiplies keyboard movement speed"};
370 cvar_t cl_movecliptokeyboard = {CF_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 = {CF_CLIENT | CF_ARCHIVE, "cl_yawspeed","140","keyboard yaw turning speed"};
373 cvar_t cl_pitchspeed = {CF_CLIENT | CF_ARCHIVE, "cl_pitchspeed","150","keyboard pitch turning speed"};
375 cvar_t cl_anglespeedkey = {CF_CLIENT | CF_ARCHIVE, "cl_anglespeedkey","1.5","how much +speed multiplies keyboard turning speed"};
377 cvar_t cl_movement = {CF_CLIENT | CF_ARCHIVE, "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 = {CF_CLIENT, "cl_movement_replay", "1", "use engine prediction"};
379 cvar_t cl_movement_nettimeout = {CF_CLIENT | CF_ARCHIVE, "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 = {CF_CLIENT | CF_ARCHIVE, "cl_movement_minping", "0", "whether to use prediction when ping is lower than this value in milliseconds"};
381 cvar_t cl_movement_track_canjump = {CF_CLIENT | CF_ARCHIVE, "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 = {CF_CLIENT, "cl_movement_maxspeed", "320", "how fast you can move (should match sv_maxspeed)"};
383 cvar_t cl_movement_maxairspeed = {CF_CLIENT, "cl_movement_maxairspeed", "30", "how fast you can move while in the air (should match sv_maxairspeed)"};
384 cvar_t cl_movement_stopspeed = {CF_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 = {CF_CLIENT, "cl_movement_friction", "4", "how fast you slow down (should match sv_friction)"};
386 cvar_t cl_movement_wallfriction = {CF_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 = {CF_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 = {CF_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 = {CF_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 = {CF_CLIENT, "cl_movement_accelerate", "10", "how fast you accelerate (should match sv_accelerate)"};
391 cvar_t cl_movement_airaccelerate = {CF_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 = {CF_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 = {CF_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 = {CF_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 = {CF_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 = {CF_CLIENT | CF_ARCHIVE, "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 = {CF_CLIENT, "in_pitch_min", "-90", "how far you can aim upward (quake used -70)"};
399 cvar_t in_pitch_max = {CF_CLIENT, "in_pitch_max", "90", "how far you can aim downward (quake used 80)"};
401 cvar_t m_filter = {CF_CLIENT | CF_ARCHIVE, "m_filter","0", "smoothes mouse movement, less responsive but smoother aiming"};
402 cvar_t m_accelerate = {CF_CLIENT | CF_ARCHIVE, "m_accelerate","1", "linear mouse acceleration factor (set to 1 to disable the linear acceleration and use only the power or natural acceleration; set to 0 to disable all acceleration)"};
403 cvar_t m_accelerate_minspeed = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_minspeed","5000", "below this speed in px/s, no acceleration is done, with a linear slope between (applied only on linear acceleration)"};
404 cvar_t m_accelerate_maxspeed = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_maxspeed","10000", "above this speed in px/s, full acceleration is done, with a linear slope between (applied only on linear acceleration)"};
405 cvar_t m_accelerate_filter = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_filter","0", "linear mouse acceleration factor filtering lowpass constant in seconds (set to 0 for no filtering)"};
406 cvar_t m_accelerate_power_offset = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_power_offset","0", "below this speed in px/ms, no power acceleration is done"};
407 cvar_t m_accelerate_power = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_power","2", "acceleration power (must be above 1 to be useful)"};
408 cvar_t m_accelerate_power_senscap = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_power_senscap", "0", "maximum acceleration factor generated by power acceleration; use 0 for unbounded"};
409 cvar_t m_accelerate_power_strength = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_power_strength", "0", "strength of the power mouse acceleration effect"};
410 cvar_t m_accelerate_natural_strength = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_natural_strength", "0", "How quickly the accelsensitivity approaches the m_accelerate_natural_accelsenscap, values are compressed between 0 and 1 but higher numbers are allowed"};
411 cvar_t m_accelerate_natural_accelsenscap = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_natural_accelsenscap", "0", "Horizontal asymptote that sets the maximum value for the natural mouse acceleration curve, value 2, for example, means that the maximum sensitivity is 2 times the base sensitivity"};
412 cvar_t m_accelerate_natural_offset = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_natural_offset", "0", "below this speed in px/ms, no natural acceleration is done"};
414 cvar_t cl_netfps = {CF_CLIENT | CF_ARCHIVE, "cl_netfps","72", "how many input packets to send to server each second"};
415 cvar_t cl_netrepeatinput = {CF_CLIENT | CF_ARCHIVE, "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)"};
416 cvar_t cl_netimmediatebuttons = {CF_CLIENT | CF_ARCHIVE, "cl_netimmediatebuttons", "1", "sends extra packets whenever your buttons change or an impulse is used (basically: whenever you click fire or change weapon)"};
418 cvar_t cl_nodelta = {CF_CLIENT, "cl_nodelta", "0", "disables delta compression of non-player entities in QW network protocol"};
420 cvar_t cl_csqc_generatemousemoveevents = {CF_CLIENT, "cl_csqc_generatemousemoveevents", "1", "enables calls to CSQC_InputEvent with type 2, for compliance with EXT_CSQC spec"};
422 extern cvar_t v_flipped;
428 Moves the local angle positions
431 static void CL_AdjustAngles (void)
436 if (in_speed.state & 1)
437 speed = cl.realframetime * cl_anglespeedkey.value;
439 speed = cl.realframetime;
441 if (!(in_strafe.state & 1))
443 cl.viewangles[YAW] -= speed*cl_yawspeed.value*CL_KeyState (&in_right);
444 cl.viewangles[YAW] += speed*cl_yawspeed.value*CL_KeyState (&in_left);
446 if (in_klook.state & 1)
449 cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * CL_KeyState (&in_forward);
450 cl.viewangles[PITCH] += speed*cl_pitchspeed.value * CL_KeyState (&in_back);
453 up = CL_KeyState (&in_lookup);
454 down = CL_KeyState(&in_lookdown);
456 cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * up;
457 cl.viewangles[PITCH] += speed*cl_pitchspeed.value * down;
462 cl.viewangles[YAW] = ANGLEMOD(cl.viewangles[YAW]);
463 cl.viewangles[PITCH] = ANGLEMOD(cl.viewangles[PITCH]);
464 if (cl.viewangles[YAW] >= 180)
465 cl.viewangles[YAW] -= 360;
466 if (cl.viewangles[PITCH] >= 180)
467 cl.viewangles[PITCH] -= 360;
468 // TODO: honor serverinfo minpitch and maxpitch values in PROTOCOL_QUAKEWORLD
469 // TODO: honor proquake pq_fullpitch cvar when playing on proquake server (server stuffcmd's this to 0 usually)
470 cl.viewangles[PITCH] = bound(in_pitch_min.value, cl.viewangles[PITCH], in_pitch_max.value);
471 cl.viewangles[ROLL] = bound(-180, cl.viewangles[ROLL], 180);
474 int cl_ignoremousemoves = 2;
480 Send the intended movement message to the server
486 static float old_mouse_x = 0, old_mouse_y = 0;
488 // clamp before the move to prevent starting with bad angles
491 if(v_flipped.integer)
492 cl.viewangles[YAW] = -cl.viewangles[YAW];
494 // reset some of the command fields
495 cl.cmd.forwardmove = 0;
499 // get basic movement from keyboard
500 if (in_strafe.state & 1)
502 cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_right);
503 cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_left);
506 cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_moveright);
507 cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_moveleft);
509 cl.cmd.upmove += cl_upspeed.value * CL_KeyState (&in_up);
510 cl.cmd.upmove -= cl_upspeed.value * CL_KeyState (&in_down);
512 if (! (in_klook.state & 1) )
514 cl.cmd.forwardmove += cl_forwardspeed.value * CL_KeyState (&in_forward);
515 cl.cmd.forwardmove -= cl_backspeed.value * CL_KeyState (&in_back);
518 // adjust for speed key
519 if (in_speed.state & 1)
521 cl.cmd.forwardmove *= cl_movespeedkey.value;
522 cl.cmd.sidemove *= cl_movespeedkey.value;
523 cl.cmd.upmove *= cl_movespeedkey.value;
526 // allow mice or other external controllers to add to the move
529 // send mouse move to csqc
530 if (cl.csqc_loaded && cl_csqc_generatemousemoveevents.integer)
532 if (cl.csqc_wantsmousemove)
534 // event type 3 is a DP_CSQC thing
535 static int oldwindowmouse[2];
536 if (oldwindowmouse[0] != in_windowmouse_x || oldwindowmouse[1] != in_windowmouse_y)
538 CL_VM_InputEvent(3, in_windowmouse_x * vid_conwidth.value / vid.width, in_windowmouse_y * vid_conheight.value / vid.height);
539 oldwindowmouse[0] = in_windowmouse_x;
540 oldwindowmouse[1] = in_windowmouse_y;
545 if (in_mouse_x || in_mouse_y)
546 CL_VM_InputEvent(2, in_mouse_x, in_mouse_y);
550 // apply m_accelerate if it is on
551 if(m_accelerate.value > 0)
553 float mouse_deltadist = sqrtf(in_mouse_x * in_mouse_x + in_mouse_y * in_mouse_y);
554 float speed = mouse_deltadist / cl.realframetime;
555 static float averagespeed = 0;
557 if(m_accelerate_filter.value > 0)
558 f = bound(0, cl.realframetime / m_accelerate_filter.value, 1);
561 averagespeed = speed * f + averagespeed * (1 - f);
563 // Note: this check is technically unnecessary, as everything in here cancels out if it is zero.
564 if (m_accelerate.value != 1.0f)
566 // First do linear slope acceleration which was ripped "in
567 // spirit" from many classic mouse driver implementations.
568 // If m_accelerate.value == 1, this code does nothing at all.
570 mi = max(1, m_accelerate_minspeed.value);
571 ma = max(m_accelerate_minspeed.value + 1, m_accelerate_maxspeed.value);
573 if(averagespeed <= mi)
577 else if(averagespeed >= ma)
579 f = m_accelerate.value;
584 f = (f - mi) / (ma - mi) * (m_accelerate.value - 1) + 1;
590 // Note: this check is technically unnecessary, as everything in here cancels out if it is zero.
591 if (m_accelerate_power_strength.value != 0.0f)
593 // Then do Quake Live-style power acceleration.
594 // Note that this behavior REPLACES the usual
595 // sensitivity, so we apply it but then divide by
596 // sensitivity.value so that the later multiplication
597 // restores it again.
598 float accelsens = 1.0f;
599 float adjusted_speed_pxms = (averagespeed * 0.001f - m_accelerate_power_offset.value) * m_accelerate_power_strength.value;
600 float inv_sensitivity = 1.0f / sensitivity.value;
601 if (adjusted_speed_pxms > 0)
603 if (m_accelerate_power.value > 1.0f)
605 // TODO: How does this interact with sensitivity changes? Is this intended?
606 // Currently: more sensitivity = less acceleration at same pixel speed.
607 accelsens += expf((m_accelerate_power.value - 1.0f) * logf(adjusted_speed_pxms)) * inv_sensitivity;
611 // The limit of the then-branch for m_accelerate_power -> 1.
612 accelsens += inv_sensitivity;
613 // Note: QL had just accelsens = 1.0f.
614 // This is mathematically wrong though.
619 // The limit of the then-branch for adjusted_speed -> 0.
620 // accelsens += 0.0f;
622 if (m_accelerate_power_senscap.value > 0.0f && accelsens > m_accelerate_power_senscap.value * inv_sensitivity)
624 // TODO: How does this interact with sensitivity changes? Is this intended?
625 // Currently: senscap is in absolute sensitivity units, so if senscap < sensitivity, it overrides.
626 accelsens = m_accelerate_power_senscap.value * inv_sensitivity;
629 in_mouse_x *= accelsens;
630 in_mouse_y *= accelsens;
633 if (m_accelerate_natural_strength.value > 0.0f && m_accelerate_natural_accelsenscap.value >= 0.0f)
635 float accelsens = 1.0f;
636 float adjusted_speed_pxms = (averagespeed * 0.001f - m_accelerate_natural_offset.value);
638 if (adjusted_speed_pxms > 0 && m_accelerate_natural_accelsenscap.value != 1.0f)
640 float adjusted_accelsenscap = m_accelerate_natural_accelsenscap.value - 1.0f;
641 // This equation is made to multiply the sensitivity for a factor between 1 and m_accelerate_natural_accelsenscap
642 // this means there is no need to divide it for the sensitivity.value as the whole
643 // expression needs to be multiplied by the sensitivity at the end instead of only having the sens multiplied
644 accelsens += (adjusted_accelsenscap - adjusted_accelsenscap * exp( - ((adjusted_speed_pxms * m_accelerate_natural_strength.value) / fabs(adjusted_accelsenscap) )));
647 in_mouse_x *= accelsens;
648 in_mouse_y *= accelsens;
652 // apply m_filter if it is on
655 if (m_filter.integer)
657 in_mouse_x = (mx + old_mouse_x) * 0.5;
658 in_mouse_y = (my + old_mouse_y) * 0.5;
663 // ignore a mouse move if mouse was activated/deactivated this frame
664 if (cl_ignoremousemoves)
666 cl_ignoremousemoves--;
667 in_mouse_x = old_mouse_x = 0;
668 in_mouse_y = old_mouse_y = 0;
671 // if not in menu, apply mouse move to viewangles/movement
672 if (!key_consoleactive && key_dest == key_game && !cl.csqc_wantsmousemove && cl_prydoncursor.integer <= 0)
674 float modulatedsensitivity = sensitivity.value * cl.sensitivityscale;
675 if (in_strafe.state & 1)
677 // strafing mode, all looking is movement
679 cl.cmd.sidemove += m_side.value * in_mouse_x * modulatedsensitivity;
680 if (noclip_anglehack)
681 cl.cmd.upmove -= m_forward.value * in_mouse_y * modulatedsensitivity;
683 cl.cmd.forwardmove -= m_forward.value * in_mouse_y * modulatedsensitivity;
685 else if ((in_mlook.state & 1) || freelook.integer)
687 // mouselook, lookstrafe causes turning to become strafing
689 if (lookstrafe.integer)
690 cl.cmd.sidemove += m_side.value * in_mouse_x * modulatedsensitivity;
692 cl.viewangles[YAW] -= m_yaw.value * in_mouse_x * modulatedsensitivity * cl.viewzoom;
693 cl.viewangles[PITCH] += m_pitch.value * in_mouse_y * modulatedsensitivity * cl.viewzoom;
697 // non-mouselook, yaw turning and forward/back movement
698 cl.viewangles[YAW] -= m_yaw.value * in_mouse_x * modulatedsensitivity * cl.viewzoom;
699 cl.cmd.forwardmove -= m_forward.value * in_mouse_y * modulatedsensitivity;
702 else // don't pitch drift when csqc is controlling the mouse
704 // mouse interacting with the scene, mostly stationary view
706 // update prydon cursor
707 cl.cmd.cursor_screen[0] = in_windowmouse_x * 2.0 / vid.width - 1.0;
708 cl.cmd.cursor_screen[1] = in_windowmouse_y * 2.0 / vid.height - 1.0;
711 if(v_flipped.integer)
713 cl.viewangles[YAW] = -cl.viewangles[YAW];
714 cl.cmd.sidemove = -cl.cmd.sidemove;
717 // clamp after the move to prevent rendering with bad angles
720 if(cl_movecliptokeyboard.integer)
723 if (in_speed.state & 1)
724 f *= cl_movespeedkey.value;
725 if(cl_movecliptokeyboard.integer == 2)
727 // digital direction, analog amount
728 vec_t wishvel_x, wishvel_y;
729 wishvel_x = fabs(cl.cmd.forwardmove);
730 wishvel_y = fabs(cl.cmd.sidemove);
731 if(wishvel_x != 0 && wishvel_y != 0 && wishvel_x != wishvel_y)
733 vec_t wishspeed = sqrt(wishvel_x * wishvel_x + wishvel_y * wishvel_y);
734 if(wishvel_x >= 2 * wishvel_y)
737 if(cl.cmd.forwardmove > 0)
738 cl.cmd.forwardmove = wishspeed;
740 cl.cmd.forwardmove = -wishspeed;
743 else if(wishvel_y >= 2 * wishvel_x)
746 cl.cmd.forwardmove = 0;
747 if(cl.cmd.sidemove > 0)
748 cl.cmd.sidemove = wishspeed;
750 cl.cmd.sidemove = -wishspeed;
755 if(cl.cmd.forwardmove > 0)
756 cl.cmd.forwardmove = 0.70710678118654752440 * wishspeed;
758 cl.cmd.forwardmove = -0.70710678118654752440 * wishspeed;
759 if(cl.cmd.sidemove > 0)
760 cl.cmd.sidemove = 0.70710678118654752440 * wishspeed;
762 cl.cmd.sidemove = -0.70710678118654752440 * wishspeed;
766 else if(cl_movecliptokeyboard.integer)
768 // digital direction, digital amount
769 if(cl.cmd.sidemove >= cl_sidespeed.value * f * 0.5)
770 cl.cmd.sidemove = cl_sidespeed.value * f;
771 else if(cl.cmd.sidemove <= -cl_sidespeed.value * f * 0.5)
772 cl.cmd.sidemove = -cl_sidespeed.value * f;
775 if(cl.cmd.forwardmove >= cl_forwardspeed.value * f * 0.5)
776 cl.cmd.forwardmove = cl_forwardspeed.value * f;
777 else if(cl.cmd.forwardmove <= -cl_backspeed.value * f * 0.5)
778 cl.cmd.forwardmove = -cl_backspeed.value * f;
780 cl.cmd.forwardmove = 0;
785 #include "cl_collision.h"
787 static void CL_UpdatePrydonCursor(void)
791 if (cl_prydoncursor.integer <= 0)
792 VectorClear(cl.cmd.cursor_screen);
795 if (cl.cmd.cursor_screen[0] < -1)
797 cl.viewangles[YAW] -= m_yaw.value * (cl.cmd.cursor_screen[0] - -1) * vid.width * sensitivity.value * cl.viewzoom;
798 cl.cmd.cursor_screen[0] = -1;
800 if (cl.cmd.cursor_screen[0] > 1)
802 cl.viewangles[YAW] -= m_yaw.value * (cl.cmd.cursor_screen[0] - 1) * vid.width * sensitivity.value * cl.viewzoom;
803 cl.cmd.cursor_screen[0] = 1;
805 if (cl.cmd.cursor_screen[1] < -1)
807 cl.viewangles[PITCH] += m_pitch.value * (cl.cmd.cursor_screen[1] - -1) * vid.height * sensitivity.value * cl.viewzoom;
808 cl.cmd.cursor_screen[1] = -1;
810 if (cl.cmd.cursor_screen[1] > 1)
812 cl.viewangles[PITCH] += m_pitch.value * (cl.cmd.cursor_screen[1] - 1) * vid.height * sensitivity.value * cl.viewzoom;
813 cl.cmd.cursor_screen[1] = 1;
816 cl.cmd.cursor_screen[0] = bound(-1, cl.cmd.cursor_screen[0], 1);
817 cl.cmd.cursor_screen[1] = bound(-1, cl.cmd.cursor_screen[1], 1);
818 cl.cmd.cursor_screen[2] = 1;
820 // calculate current view matrix
821 Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, cl.cmd.cursor_start);
822 // calculate direction vector of cursor in viewspace by using frustum slopes
823 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);
824 Matrix4x4_Transform(&r_refdef.view.matrix, temp, cl.cmd.cursor_end);
825 // trace from view origin to the cursor
826 if (cl_prydoncursor_notrace.integer)
828 cl.cmd.cursor_fraction = 1.0f;
829 VectorCopy(cl.cmd.cursor_end, cl.cmd.cursor_impact);
830 VectorClear(cl.cmd.cursor_normal);
831 cl.cmd.cursor_entitynumber = 0;
834 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);
837 #define NUMOFFSETS 27
838 static vec3_t offsets[NUMOFFSETS] =
840 // 1 no nudge (just return the original if this test passes)
841 { 0.000, 0.000, 0.000},
843 { 0.000, 0.000, 0.125}, { 0.000, 0.000, -0.125},
844 {-0.125, 0.000, 0.000}, { 0.125, 0.000, 0.000},
845 { 0.000, -0.125, 0.000}, { 0.000, 0.125, 0.000},
846 // 4 diagonal flat nudges
847 {-0.125, -0.125, 0.000}, { 0.125, -0.125, 0.000},
848 {-0.125, 0.125, 0.000}, { 0.125, 0.125, 0.000},
849 // 8 diagonal upward nudges
850 {-0.125, 0.000, 0.125}, { 0.125, 0.000, 0.125},
851 { 0.000, -0.125, 0.125}, { 0.000, 0.125, 0.125},
852 {-0.125, -0.125, 0.125}, { 0.125, -0.125, 0.125},
853 {-0.125, 0.125, 0.125}, { 0.125, 0.125, 0.125},
854 // 8 diagonal downward nudges
855 {-0.125, 0.000, -0.125}, { 0.125, 0.000, -0.125},
856 { 0.000, -0.125, -0.125}, { 0.000, 0.125, -0.125},
857 {-0.125, -0.125, -0.125}, { 0.125, -0.125, -0.125},
858 {-0.125, 0.125, -0.125}, { 0.125, 0.125, -0.125},
861 static qbool CL_ClientMovement_Unstick(cl_clientmovement_state_t *s)
865 for (i = 0;i < NUMOFFSETS;i++)
867 VectorAdd(offsets[i], s->origin, neworigin);
868 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)
870 VectorCopy(neworigin, s->origin);
874 // if all offsets failed, give up
878 static void CL_ClientMovement_UpdateStatus(cl_clientmovement_state_t *s)
881 vec3_t origin1, origin2;
884 // make sure player is not stuck
885 CL_ClientMovement_Unstick(s);
890 // wants to crouch, this always works..
896 // wants to stand, if currently crouching we need to check for a
900 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);
901 if (!trace.startsolid)
907 VectorCopy(cl.playercrouchmins, s->mins);
908 VectorCopy(cl.playercrouchmaxs, s->maxs);
912 VectorCopy(cl.playerstandmins, s->mins);
913 VectorCopy(cl.playerstandmaxs, s->maxs);
917 VectorSet(origin1, s->origin[0], s->origin[1], s->origin[2] + 1);
918 VectorSet(origin2, s->origin[0], s->origin[1], s->origin[2] - 1); // -2 causes clientside doublejump bug at above 150fps, raising that to 300fps :)
919 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);
920 if(trace.fraction < 1 && trace.plane.normal[2] > 0.7)
924 // this code actually "predicts" an impact; so let's clip velocity first
925 f = DotProduct(s->velocity, trace.plane.normal);
926 if(f < 0) // only if moving downwards actually
927 VectorMA(s->velocity, -f, trace.plane.normal, s->velocity);
932 // set watertype/waterlevel
933 VectorSet(origin1, s->origin[0], s->origin[1], s->origin[2] + s->mins[2] + 1);
934 s->waterlevel = WATERLEVEL_NONE;
935 s->watertype = CL_TracePoint(origin1, MOVE_NOMONSTERS, s->self, 0, 0, 0, true, false, NULL, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK;
938 s->waterlevel = WATERLEVEL_WETFEET;
939 origin1[2] = s->origin[2] + (s->mins[2] + s->maxs[2]) * 0.5f;
940 if (CL_TracePoint(origin1, MOVE_NOMONSTERS, s->self, 0, 0, 0, true, false, NULL, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK)
942 s->waterlevel = WATERLEVEL_SWIMMING;
943 origin1[2] = s->origin[2] + 22;
944 if (CL_TracePoint(origin1, MOVE_NOMONSTERS, s->self, 0, 0, 0, true, false, NULL, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK)
945 s->waterlevel = WATERLEVEL_SUBMERGED;
949 // water jump prediction
950 if (s->onground || s->velocity[2] <= 0 || s->waterjumptime <= 0)
951 s->waterjumptime = 0;
954 static void CL_ClientMovement_Move(cl_clientmovement_state_t *s)
960 vec3_t currentorigin2;
962 vec3_t primalvelocity;
966 CL_ClientMovement_UpdateStatus(s);
967 VectorCopy(s->velocity, primalvelocity);
968 for (bump = 0, t = s->cmd.frametime;bump < 8 && VectorLength2(s->velocity) > 0;bump++)
970 VectorMA(s->origin, t, s->velocity, neworigin);
971 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);
972 if (trace.fraction < 1 && trace.plane.normal[2] == 0)
974 // may be a step or wall, try stepping up
975 // first move forward at a higher level
976 VectorSet(currentorigin2, s->origin[0], s->origin[1], s->origin[2] + cl.movevars_stepheight);
977 VectorSet(neworigin2, neworigin[0], neworigin[1], s->origin[2] + cl.movevars_stepheight);
978 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);
979 if (!trace2.startsolid)
981 // then move down from there
982 VectorCopy(trace2.endpos, currentorigin2);
983 VectorSet(neworigin2, trace2.endpos[0], trace2.endpos[1], s->origin[2]);
984 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);
985 //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]);
986 // accept the new trace if it made some progress
987 if (fabs(trace3.endpos[0] - trace.endpos[0]) >= 0.03125 || fabs(trace3.endpos[1] - trace.endpos[1]) >= 0.03125)
990 VectorCopy(trace3.endpos, trace.endpos);
995 // check if it moved at all
996 if (trace.fraction >= 0.001)
997 VectorCopy(trace.endpos, s->origin);
999 // check if it moved all the way
1000 if (trace.fraction == 1)
1003 // this is only really needed for nogravityonground combined with gravityunaffectedbyticrate
1004 // <LadyHavoc> I'm pretty sure I commented it out solely because it seemed redundant
1005 // this got commented out in a change that supposedly makes the code match QW better
1006 // so if this is broken, maybe put it in an if(cls.protocol != PROTOCOL_QUAKEWORLD) block
1007 if (trace.plane.normal[2] > 0.7)
1010 t -= t * trace.fraction;
1012 f = DotProduct(s->velocity, trace.plane.normal);
1013 VectorMA(s->velocity, -f, trace.plane.normal, s->velocity);
1015 if (s->waterjumptime > 0)
1016 VectorCopy(primalvelocity, s->velocity);
1020 static void CL_ClientMovement_Physics_Swim(cl_clientmovement_state_t *s)
1027 // water jump only in certain situations
1028 // this mimics quakeworld code
1029 if (s->cmd.jump && s->waterlevel == 2 && s->velocity[2] >= -180)
1034 VectorSet(yawangles, 0, s->cmd.viewangles[1], 0);
1035 AngleVectors(yawangles, forward, NULL, NULL);
1036 VectorMA(s->origin, 24, forward, spot);
1038 if (CL_TracePoint(spot, MOVE_NOMONSTERS, s->self, 0, 0, 0, true, false, NULL, false).startsolid)
1041 if (!CL_TracePoint(spot, MOVE_NOMONSTERS, s->self, 0, 0, 0, true, false, NULL, false).startsolid)
1043 VectorScale(forward, 50, s->velocity);
1044 s->velocity[2] = 310;
1045 s->waterjumptime = 2;
1046 s->onground = false;
1047 s->cmd.canjump = false;
1052 if (!(s->cmd.forwardmove*s->cmd.forwardmove + s->cmd.sidemove*s->cmd.sidemove + s->cmd.upmove*s->cmd.upmove))
1054 // drift towards bottom
1055 VectorSet(wishvel, 0, 0, -60);
1063 // calculate movement vector
1064 AngleVectors(s->cmd.viewangles, forward, right, up);
1065 VectorSet(up, 0, 0, 1);
1066 VectorMAMAM(s->cmd.forwardmove, forward, s->cmd.sidemove, right, s->cmd.upmove, up, wishvel);
1069 // split wishvel into wishspeed and wishdir
1070 VectorCopy(wishvel, wishdir);
1071 wishspeed = VectorNormalizeLength(wishdir);
1072 wishspeed = min(wishspeed, cl.movevars_maxspeed) * 0.7;
1077 if (s->waterjumptime <= 0)
1080 f = 1 - s->cmd.frametime * cl.movevars_waterfriction * (cls.protocol == PROTOCOL_QUAKEWORLD ? s->waterlevel : 1);
1082 VectorScale(s->velocity, f, s->velocity);
1084 // water acceleration
1085 f = wishspeed - DotProduct(s->velocity, wishdir);
1088 f = min(cl.movevars_wateraccelerate * s->cmd.frametime * wishspeed, f);
1089 VectorMA(s->velocity, f, wishdir, s->velocity);
1092 // holding jump button swims upward slowly
1095 if (s->watertype & SUPERCONTENTS_LAVA)
1096 s->velocity[2] = 50;
1097 else if (s->watertype & SUPERCONTENTS_SLIME)
1098 s->velocity[2] = 80;
1101 if (IS_NEXUIZ_DERIVED(gamemode))
1102 s->velocity[2] = 200;
1104 s->velocity[2] = 100;
1109 CL_ClientMovement_Move(s);
1112 static vec_t CL_IsMoveInDirection(vec_t forward, vec_t side, vec_t angle)
1114 if(forward == 0 && side == 0)
1115 return 0; // avoid division by zero
1116 angle -= RAD2DEG(atan2(side, forward));
1117 angle = (ANGLEMOD(angle + 180) - 180) / 45;
1122 return 1 - fabs(angle);
1125 static vec_t CL_GeomLerp(vec_t a, vec_t lerp, vec_t b)
1141 return a * pow(fabs(b / a), lerp);
1144 static void CL_ClientMovement_Physics_CPM_PM_Aircontrol(cl_clientmovement_state_t *s, vec3_t wishdir, vec_t wishspeed)
1146 vec_t zspeed, speed, dot, k;
1149 // this doesn't play well with analog input
1150 if(s->cmd.forwardmove == 0 || s->cmd.sidemove != 0)
1154 k = 32 * (2 * CL_IsMoveInDirection(s->cmd.forwardmove, s->cmd.sidemove, 0) - 1);
1159 k *= bound(0, wishspeed / cl.movevars_maxairspeed, 1);
1161 zspeed = s->velocity[2];
1163 speed = VectorNormalizeLength(s->velocity);
1165 dot = DotProduct(s->velocity, wishdir);
1167 if(dot > 0) { // we can't change direction while slowing down
1168 k *= pow(dot, cl.movevars_aircontrol_power)*s->cmd.frametime;
1169 speed = max(0, speed - cl.movevars_aircontrol_penalty * sqrt(max(0, 1 - dot*dot)) * k/32);
1170 k *= cl.movevars_aircontrol;
1171 VectorMAM(speed, s->velocity, k, wishdir, s->velocity);
1172 VectorNormalize(s->velocity);
1175 VectorScale(s->velocity, speed, s->velocity);
1176 s->velocity[2] = zspeed;
1179 static float CL_ClientMovement_Physics_AdjustAirAccelQW(float accelqw, float factor)
1182 (accelqw < 0 ? -1 : +1)
1184 bound(0.000001, 1 - (1 - fabs(accelqw)) * factor, 1);
1187 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)
1194 vec_t vel_xy_current;
1195 vec_t vel_xy_backward, vel_xy_forward;
1198 if(stretchfactor > 0)
1199 speedclamp = stretchfactor;
1200 else if(accelqw < 0)
1203 speedclamp = -1; // no clamping
1208 if(cl.moveflags & MOVEFLAG_Q2AIRACCELERATE)
1209 wishspeed0 = wishspeed; // don't need to emulate this Q1 bug
1211 vel_straight = DotProduct(s->velocity, wishdir);
1212 vel_z = s->velocity[2];
1213 VectorCopy(s->velocity, vel_xy); vel_xy[2] -= vel_z;
1214 VectorMA(vel_xy, -vel_straight, wishdir, vel_perpend);
1216 step = accel * s->cmd.frametime * wishspeed0;
1218 vel_xy_current = VectorLength(vel_xy);
1220 accelqw = CL_ClientMovement_Physics_AdjustAirAccelQW(accelqw, (speedlimit - bound(wishspeed, vel_xy_current, speedlimit)) / max(1, speedlimit - wishspeed));
1221 vel_xy_forward = vel_xy_current + bound(0, wishspeed - vel_xy_current, step) * accelqw + step * (1 - accelqw);
1222 vel_xy_backward = vel_xy_current - bound(0, wishspeed + vel_xy_current, step) * accelqw - step * (1 - accelqw);
1223 if(vel_xy_backward < 0)
1224 vel_xy_backward = 0; // not that it REALLY occurs that this would cause wrong behaviour afterwards
1226 vel_straight = vel_straight + bound(0, wishspeed - vel_straight, step) * accelqw + step * (1 - accelqw);
1228 if(sidefric < 0 && VectorLength2(vel_perpend))
1229 // negative: only apply so much sideways friction to stay below the speed you could get by "braking"
1232 f = max(0, 1 + s->cmd.frametime * wishspeed * sidefric);
1233 fmin = (vel_xy_backward*vel_xy_backward - vel_straight*vel_straight) / VectorLength2(vel_perpend);
1235 // vel_xy_backward*vel_xy_backward - vel_straight*vel_straight > vel_perpend*vel_perpend
1236 // vel_xy_backward*vel_xy_backward > vel_straight*vel_straight + vel_perpend*vel_perpend
1237 // vel_xy_backward*vel_xy_backward > vel_xy * vel_xy
1238 // obviously, this cannot be
1240 VectorScale(vel_perpend, f, vel_perpend);
1244 VectorScale(vel_perpend, max(fmin, f), vel_perpend);
1248 VectorScale(vel_perpend, max(0, 1 - s->cmd.frametime * wishspeed * sidefric), vel_perpend);
1250 VectorMA(vel_perpend, vel_straight, wishdir, s->velocity);
1254 vec_t vel_xy_preclamp;
1255 vel_xy_preclamp = VectorLength(s->velocity);
1256 if(vel_xy_preclamp > 0) // prevent division by zero
1258 vel_xy_current += (vel_xy_forward - vel_xy_current) * speedclamp;
1259 if(vel_xy_current < vel_xy_preclamp)
1260 VectorScale(s->velocity, (vel_xy_current / vel_xy_preclamp), s->velocity);
1264 s->velocity[2] += vel_z;
1267 static void CL_ClientMovement_Physics_PM_AirAccelerate(cl_clientmovement_state_t *s, vec3_t wishdir, vec_t wishspeed)
1269 vec3_t curvel, wishvel, acceldir, curdir;
1270 float addspeed, accelspeed, curspeed;
1273 float airforwardaccel = cl.movevars_warsowbunny_airforwardaccel;
1274 float bunnyaccel = cl.movevars_warsowbunny_accel;
1275 float bunnytopspeed = cl.movevars_warsowbunny_topspeed;
1276 float turnaccel = cl.movevars_warsowbunny_turnaccel;
1277 float backtosideratio = cl.movevars_warsowbunny_backtosideratio;
1282 VectorCopy( s->velocity, curvel );
1284 curspeed = VectorLength( curvel );
1286 if( wishspeed > curspeed * 1.01f )
1288 float faccelspeed = curspeed + airforwardaccel * cl.movevars_maxairspeed * s->cmd.frametime;
1289 if( faccelspeed < wishspeed )
1290 wishspeed = faccelspeed;
1294 float f = ( bunnytopspeed - curspeed ) / ( bunnytopspeed - cl.movevars_maxairspeed );
1297 wishspeed = max( curspeed, cl.movevars_maxairspeed ) + bunnyaccel * f * cl.movevars_maxairspeed * s->cmd.frametime;
1299 VectorScale( wishdir, wishspeed, wishvel );
1300 VectorSubtract( wishvel, curvel, acceldir );
1301 addspeed = VectorNormalizeLength( acceldir );
1303 accelspeed = turnaccel * cl.movevars_maxairspeed /* wishspeed */ * s->cmd.frametime;
1304 if( accelspeed > addspeed )
1305 accelspeed = addspeed;
1307 if( backtosideratio < 1.0f )
1309 VectorNormalize2( curvel, curdir );
1310 dot = DotProduct( acceldir, curdir );
1312 VectorMA( acceldir, -( 1.0f - backtosideratio ) * dot, curdir, acceldir );
1315 VectorMA( s->velocity, accelspeed, acceldir, s->velocity );
1318 static void CL_ClientMovement_Physics_CheckJump(cl_clientmovement_state_t *s)
1320 // jump if on ground with jump button pressed but only if it has been
1321 // released at least once since the last jump
1324 if (s->onground && (s->cmd.canjump || !cl_movement_track_canjump.integer))
1326 s->velocity[2] += cl.movevars_jumpvelocity;
1327 s->onground = false;
1328 s->cmd.canjump = false;
1332 s->cmd.canjump = true;
1335 static void CL_ClientMovement_Physics_Walk(cl_clientmovement_state_t *s)
1351 CL_ClientMovement_Physics_CheckJump(s);
1353 // calculate movement vector
1354 VectorSet(yawangles, 0, s->cmd.viewangles[1], 0);
1355 AngleVectors(yawangles, forward, right, up);
1356 VectorMAM(s->cmd.forwardmove, forward, s->cmd.sidemove, right, wishvel);
1358 // split wishvel into wishspeed and wishdir
1359 VectorCopy(wishvel, wishdir);
1360 wishspeed = VectorNormalizeLength(wishdir);
1362 // check if onground
1365 wishspeed = min(wishspeed, cl.movevars_maxspeed);
1369 // apply edge friction
1370 speed = VectorLength2(s->velocity);
1373 friction = cl.movevars_friction;
1374 if (cl.movevars_edgefriction != 1)
1378 // note: QW uses the full player box for the trace, and yet still
1379 // uses s->origin[2] + s->mins[2], which is clearly an bug, but
1380 // this mimics it for compatibility
1381 VectorSet(neworigin2, s->origin[0] + s->velocity[0]*(16/speed), s->origin[1] + s->velocity[1]*(16/speed), s->origin[2] + s->mins[2]);
1382 VectorSet(neworigin3, neworigin2[0], neworigin2[1], neworigin2[2] - 34);
1383 if (cls.protocol == PROTOCOL_QUAKEWORLD)
1384 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);
1386 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);
1387 if (trace.fraction == 1 && !trace.startsolid)
1388 friction *= cl.movevars_edgefriction;
1390 // apply ground friction
1391 speed = 1 - s->cmd.frametime * friction * ((speed < cl.movevars_stopspeed) ? (cl.movevars_stopspeed / speed) : 1);
1392 speed = max(speed, 0);
1393 VectorScale(s->velocity, speed, s->velocity);
1395 addspeed = wishspeed - DotProduct(s->velocity, wishdir);
1398 accelspeed = min(cl.movevars_accelerate * s->cmd.frametime * wishspeed, addspeed);
1399 VectorMA(s->velocity, accelspeed, wishdir, s->velocity);
1401 gravity = cl.movevars_gravity * cl.movevars_entgravity * s->cmd.frametime;
1402 if(!(cl.moveflags & MOVEFLAG_NOGRAVITYONGROUND))
1404 if(cl.moveflags & MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE)
1405 s->velocity[2] -= gravity * 0.5f;
1407 s->velocity[2] -= gravity;
1409 if (cls.protocol == PROTOCOL_QUAKEWORLD)
1411 if (VectorLength2(s->velocity))
1412 CL_ClientMovement_Move(s);
1413 if(!(cl.moveflags & MOVEFLAG_NOGRAVITYONGROUND) || !s->onground)
1415 if(cl.moveflags & MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE)
1416 s->velocity[2] -= gravity * 0.5f;
1421 if (s->waterjumptime <= 0)
1423 // apply air speed limit
1424 vec_t accel, wishspeed0, wishspeed2, accelqw, strafity;
1427 accelqw = cl.movevars_airaccel_qw;
1428 wishspeed0 = wishspeed;
1429 wishspeed = min(wishspeed, cl.movevars_maxairspeed);
1432 accel = cl.movevars_airaccelerate;
1434 accelerating = (DotProduct(s->velocity, wishdir) > 0);
1435 wishspeed2 = wishspeed;
1438 if(cl.movevars_airstopaccelerate != 0)
1441 curdir[0] = s->velocity[0];
1442 curdir[1] = s->velocity[1];
1444 VectorNormalize(curdir);
1445 accel = accel + (cl.movevars_airstopaccelerate - accel) * max(0, -DotProduct(curdir, wishdir));
1447 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
1448 if(cl.movevars_maxairstrafespeed)
1449 wishspeed = min(wishspeed, CL_GeomLerp(cl.movevars_maxairspeed, strafity, cl.movevars_maxairstrafespeed));
1450 if(cl.movevars_airstrafeaccelerate)
1451 accel = CL_GeomLerp(cl.movevars_airaccelerate, strafity, cl.movevars_airstrafeaccelerate);
1452 if(cl.movevars_airstrafeaccel_qw)
1454 (((strafity > 0.5 ? cl.movevars_airstrafeaccel_qw : cl.movevars_airaccel_qw) >= 0) ? +1 : -1)
1456 (1 - CL_GeomLerp(1 - fabs(cl.movevars_airaccel_qw), strafity, 1 - fabs(cl.movevars_airstrafeaccel_qw)));
1459 if(cl.movevars_warsowbunny_turnaccel && accelerating && s->cmd.sidemove == 0 && s->cmd.forwardmove != 0)
1460 CL_ClientMovement_Physics_PM_AirAccelerate(s, wishdir, wishspeed2);
1462 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);
1464 if(cl.movevars_aircontrol)
1465 CL_ClientMovement_Physics_CPM_PM_Aircontrol(s, wishdir, wishspeed2);
1467 gravity = cl.movevars_gravity * cl.movevars_entgravity * s->cmd.frametime;
1468 if(cl.moveflags & MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE)
1469 s->velocity[2] -= gravity * 0.5f;
1471 s->velocity[2] -= gravity;
1472 CL_ClientMovement_Move(s);
1473 if(!(cl.moveflags & MOVEFLAG_NOGRAVITYONGROUND) || !s->onground)
1475 if(cl.moveflags & MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE)
1476 s->velocity[2] -= gravity * 0.5f;
1481 static void CL_ClientMovement_PlayerMove(cl_clientmovement_state_t *s)
1483 //Con_Printf(" %f", frametime);
1485 s->cmd.canjump = true;
1486 s->waterjumptime -= s->cmd.frametime;
1487 CL_ClientMovement_UpdateStatus(s);
1488 if (s->waterlevel >= WATERLEVEL_SWIMMING)
1489 CL_ClientMovement_Physics_Swim(s);
1491 CL_ClientMovement_Physics_Walk(s);
1494 extern cvar_t host_timescale;
1495 void CL_UpdateMoveVars(void)
1497 if (cls.protocol == PROTOCOL_QUAKEWORLD)
1501 else if (cl.stats[STAT_MOVEVARS_TICRATE])
1503 cl.moveflags = cl.stats[STAT_MOVEFLAGS];
1504 cl.movevars_ticrate = cl.statsf[STAT_MOVEVARS_TICRATE];
1505 cl.movevars_timescale = cl.statsf[STAT_MOVEVARS_TIMESCALE];
1506 cl.movevars_gravity = cl.statsf[STAT_MOVEVARS_GRAVITY];
1507 cl.movevars_stopspeed = cl.statsf[STAT_MOVEVARS_STOPSPEED] ;
1508 cl.movevars_maxspeed = cl.statsf[STAT_MOVEVARS_MAXSPEED];
1509 cl.movevars_spectatormaxspeed = cl.statsf[STAT_MOVEVARS_SPECTATORMAXSPEED];
1510 cl.movevars_accelerate = cl.statsf[STAT_MOVEVARS_ACCELERATE];
1511 cl.movevars_airaccelerate = cl.statsf[STAT_MOVEVARS_AIRACCELERATE];
1512 cl.movevars_wateraccelerate = cl.statsf[STAT_MOVEVARS_WATERACCELERATE];
1513 cl.movevars_entgravity = cl.statsf[STAT_MOVEVARS_ENTGRAVITY];
1514 cl.movevars_jumpvelocity = cl.statsf[STAT_MOVEVARS_JUMPVELOCITY];
1515 cl.movevars_edgefriction = cl.statsf[STAT_MOVEVARS_EDGEFRICTION];
1516 cl.movevars_maxairspeed = cl.statsf[STAT_MOVEVARS_MAXAIRSPEED];
1517 cl.movevars_stepheight = cl.statsf[STAT_MOVEVARS_STEPHEIGHT];
1518 cl.movevars_airaccel_qw = cl.statsf[STAT_MOVEVARS_AIRACCEL_QW];
1519 cl.movevars_airaccel_qw_stretchfactor = cl.statsf[STAT_MOVEVARS_AIRACCEL_QW_STRETCHFACTOR];
1520 cl.movevars_airaccel_sideways_friction = cl.statsf[STAT_MOVEVARS_AIRACCEL_SIDEWAYS_FRICTION];
1521 cl.movevars_friction = cl.statsf[STAT_MOVEVARS_FRICTION];
1522 cl.movevars_wallfriction = cl.statsf[STAT_MOVEVARS_WALLFRICTION];
1523 cl.movevars_waterfriction = cl.statsf[STAT_MOVEVARS_WATERFRICTION];
1524 cl.movevars_airstopaccelerate = cl.statsf[STAT_MOVEVARS_AIRSTOPACCELERATE];
1525 cl.movevars_airstrafeaccelerate = cl.statsf[STAT_MOVEVARS_AIRSTRAFEACCELERATE];
1526 cl.movevars_maxairstrafespeed = cl.statsf[STAT_MOVEVARS_MAXAIRSTRAFESPEED];
1527 cl.movevars_airstrafeaccel_qw = cl.statsf[STAT_MOVEVARS_AIRSTRAFEACCEL_QW];
1528 cl.movevars_aircontrol = cl.statsf[STAT_MOVEVARS_AIRCONTROL];
1529 cl.movevars_aircontrol_power = cl.statsf[STAT_MOVEVARS_AIRCONTROL_POWER];
1530 cl.movevars_aircontrol_penalty = cl.statsf[STAT_MOVEVARS_AIRCONTROL_PENALTY];
1531 cl.movevars_warsowbunny_airforwardaccel = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_AIRFORWARDACCEL];
1532 cl.movevars_warsowbunny_accel = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_ACCEL];
1533 cl.movevars_warsowbunny_topspeed = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_TOPSPEED];
1534 cl.movevars_warsowbunny_turnaccel = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_TURNACCEL];
1535 cl.movevars_warsowbunny_backtosideratio = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_BACKTOSIDERATIO];
1536 cl.movevars_airspeedlimit_nonqw = cl.statsf[STAT_MOVEVARS_AIRSPEEDLIMIT_NONQW];
1541 cl.movevars_ticrate = 0; // bones_was_here: no guessing, unavailable ticrate triggers better fallbacks
1542 cl.movevars_timescale = (cls.demoplayback || host_timescale.value <= 0) ? 1.0f : host_timescale.value;
1543 cl.movevars_gravity = sv_gravity.value;
1544 cl.movevars_stopspeed = cl_movement_stopspeed.value;
1545 cl.movevars_maxspeed = cl_movement_maxspeed.value;
1546 cl.movevars_spectatormaxspeed = cl_movement_maxspeed.value;
1547 cl.movevars_accelerate = cl_movement_accelerate.value;
1548 cl.movevars_airaccelerate = cl_movement_airaccelerate.value < 0 ? cl_movement_accelerate.value : cl_movement_airaccelerate.value;
1549 cl.movevars_wateraccelerate = cl_movement_wateraccelerate.value < 0 ? cl_movement_accelerate.value : cl_movement_wateraccelerate.value;
1550 cl.movevars_friction = cl_movement_friction.value;
1551 cl.movevars_wallfriction = cl_movement_wallfriction.value;
1552 cl.movevars_waterfriction = cl_movement_waterfriction.value < 0 ? cl_movement_friction.value : cl_movement_waterfriction.value;
1553 cl.movevars_entgravity = 1;
1554 cl.movevars_jumpvelocity = cl_movement_jumpvelocity.value;
1555 cl.movevars_edgefriction = cl_movement_edgefriction.value;
1556 cl.movevars_maxairspeed = cl_movement_maxairspeed.value;
1557 cl.movevars_stepheight = cl_movement_stepheight.value;
1558 cl.movevars_airaccel_qw = cl_movement_airaccel_qw.value;
1559 cl.movevars_airaccel_qw_stretchfactor = 0;
1560 cl.movevars_airaccel_sideways_friction = cl_movement_airaccel_sideways_friction.value;
1561 cl.movevars_airstopaccelerate = 0;
1562 cl.movevars_airstrafeaccelerate = 0;
1563 cl.movevars_maxairstrafespeed = 0;
1564 cl.movevars_airstrafeaccel_qw = 0;
1565 cl.movevars_aircontrol = 0;
1566 cl.movevars_aircontrol_power = 2;
1567 cl.movevars_aircontrol_penalty = 0;
1568 cl.movevars_warsowbunny_airforwardaccel = 0;
1569 cl.movevars_warsowbunny_accel = 0;
1570 cl.movevars_warsowbunny_topspeed = 0;
1571 cl.movevars_warsowbunny_turnaccel = 0;
1572 cl.movevars_warsowbunny_backtosideratio = 0;
1573 cl.movevars_airspeedlimit_nonqw = 0;
1576 if(!(cl.moveflags & MOVEFLAG_VALID))
1578 if(gamemode == GAME_NEXUIZ) // Legacy hack to work with old servers of Nexuiz.
1579 cl.moveflags = MOVEFLAG_Q2AIRACCELERATE;
1582 if(cl.movevars_aircontrol_power <= 0)
1583 cl.movevars_aircontrol_power = 2; // CPMA default
1586 void CL_ClientMovement_PlayerMove_Frame(cl_clientmovement_state_t *s)
1588 // if a move is more than 50ms, do it as two moves (matching qwsv)
1589 //Con_Printf("%i ", s.cmd.msec);
1590 if(s->cmd.frametime > 0.0005)
1592 if (s->cmd.frametime > 0.05)
1594 s->cmd.frametime /= 2;
1595 CL_ClientMovement_PlayerMove(s);
1597 CL_ClientMovement_PlayerMove(s);
1601 // we REALLY need this handling to happen, even if the move is not executed
1603 s->cmd.canjump = true;
1607 void CL_ClientMovement_Replay(void)
1610 double totalmovemsec;
1611 cl_clientmovement_state_t s;
1613 VectorCopy(cl.mvelocity[0], cl.movement_velocity);
1615 if (cl.movement_predicted && !cl.movement_replay)
1618 if (!cl_movement_replay.integer)
1621 // set up starting state for the series of moves
1622 memset(&s, 0, sizeof(s));
1623 VectorCopy(cl.entities[cl.playerentity].state_current.origin, s.origin);
1624 VectorCopy(cl.mvelocity[0], s.velocity);
1625 s.crouched = true; // will be updated on first move
1626 //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]);
1629 for (i = 0;i < CL_MAX_USERCMDS;i++)
1630 if (cl.movecmd[i].sequence > cls.servermovesequence)
1631 totalmovemsec += cl.movecmd[i].msec;
1632 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);
1633 //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);
1634 if (cl.movement_predicted)
1636 //Con_Printf("%ims\n", cl.movecmd[0].msec);
1638 // replay the input queue to predict current location
1639 // note: this relies on the fact there's always one queue item at the end
1641 // find how many are still valid
1642 for (i = 0;i < CL_MAX_USERCMDS;i++)
1643 if (cl.movecmd[i].sequence <= cls.servermovesequence)
1645 // now walk them in oldest to newest order
1646 for (i--;i >= 0;i--)
1648 s.cmd = cl.movecmd[i];
1649 if (i < CL_MAX_USERCMDS - 1)
1650 s.cmd.canjump = cl.movecmd[i+1].canjump;
1652 CL_ClientMovement_PlayerMove_Frame(&s);
1654 cl.movecmd[i].canjump = s.cmd.canjump;
1657 CL_ClientMovement_UpdateStatus(&s);
1661 // get the first movement queue entry to know whether to crouch and such
1662 s.cmd = cl.movecmd[0];
1665 if (!cls.demoplayback) // for bob, speedometer
1667 cl.movement_replay = false;
1668 // update the interpolation target position and velocity
1669 VectorCopy(s.origin, cl.movement_origin);
1670 VectorCopy(s.velocity, cl.movement_velocity);
1673 // update the onground flag if appropriate
1674 if (cl.movement_predicted)
1676 // when predicted we simply set the flag according to the UpdateStatus
1677 cl.onground = s.onground;
1681 // when not predicted, cl.onground is cleared by cl_parse.c each time
1682 // an update packet is received, but can be forced on here to hide
1683 // server inconsistencies in the onground flag
1684 // (which mostly occur when stepping up stairs at very high framerates
1685 // where after the step up the move continues forward and not
1686 // downward so the ground is not detected)
1688 // such onground inconsistencies can cause jittery gun bobbing and
1689 // stair smoothing, so we set onground if UpdateStatus says so
1695 static void QW_MSG_WriteDeltaUsercmd(sizebuf_t *buf, usercmd_t *from, usercmd_t *to)
1700 if (to->viewangles[0] != from->viewangles[0])
1701 bits |= QW_CM_ANGLE1;
1702 if (to->viewangles[1] != from->viewangles[1])
1703 bits |= QW_CM_ANGLE2;
1704 if (to->viewangles[2] != from->viewangles[2])
1705 bits |= QW_CM_ANGLE3;
1706 if (to->forwardmove != from->forwardmove)
1707 bits |= QW_CM_FORWARD;
1708 if (to->sidemove != from->sidemove)
1710 if (to->upmove != from->upmove)
1712 if (to->buttons != from->buttons)
1713 bits |= QW_CM_BUTTONS;
1714 if (to->impulse != from->impulse)
1715 bits |= QW_CM_IMPULSE;
1717 MSG_WriteByte(buf, bits);
1718 if (bits & QW_CM_ANGLE1)
1719 MSG_WriteAngle16i(buf, to->viewangles[0]);
1720 if (bits & QW_CM_ANGLE2)
1721 MSG_WriteAngle16i(buf, to->viewangles[1]);
1722 if (bits & QW_CM_ANGLE3)
1723 MSG_WriteAngle16i(buf, to->viewangles[2]);
1724 if (bits & QW_CM_FORWARD)
1725 MSG_WriteShort(buf, (short) to->forwardmove);
1726 if (bits & QW_CM_SIDE)
1727 MSG_WriteShort(buf, (short) to->sidemove);
1728 if (bits & QW_CM_UP)
1729 MSG_WriteShort(buf, (short) to->upmove);
1730 if (bits & QW_CM_BUTTONS)
1731 MSG_WriteByte(buf, to->buttons);
1732 if (bits & QW_CM_IMPULSE)
1733 MSG_WriteByte(buf, to->impulse);
1734 MSG_WriteByte(buf, to->msec);
1737 void CL_NewFrameReceived(int num)
1739 if (developer_networkentities.integer >= 10)
1740 Con_Printf("recv: svc_entities %i\n", num);
1741 cl.latestframenums[cl.latestframenumsposition] = num;
1742 cl.latestsendnums[cl.latestframenumsposition] = cl.cmd.sequence;
1743 cl.latestframenumsposition = (cl.latestframenumsposition + 1) % LATESTFRAMENUMS;
1746 void CL_RotateMoves(const matrix4x4_t *m)
1748 // rotate viewangles in all previous moves
1752 for (i = 0;i < CL_MAX_USERCMDS;i++)
1754 if (cl.movecmd[i].sequence > cls.servermovesequence)
1756 usercmd_t *c = &cl.movecmd[i];
1757 AngleVectors(c->viewangles, f, r, u);
1758 Matrix4x4_Transform(m, f, v); VectorCopy(v, f);
1759 Matrix4x4_Transform(m, u, v); VectorCopy(v, u);
1760 AnglesFromVectors(c->viewangles, f, u, false);
1770 usercmd_t nullcmd; // for delta compression of qw moves
1771 void CL_SendMove(void)
1773 int i, j, packetloss;
1779 unsigned char data[1024];
1780 float packettime, sv_frametime, lag, frames_per_tic;
1781 qbool opportune_moment;
1785 // if playing a demo, do nothing
1789 // we don't que moves during a lag spike (potential network timeout)
1790 quemove = host.realtime - cl.last_received_message < cl_movement_nettimeout.value;
1792 // we build up cl.cmd and then decide whether to send or not
1793 // we store this into cl.movecmd[0] for prediction each frame even if we
1794 // do not send, to make sure that prediction is instant
1795 cl.cmd.time = cl.time;
1796 cl.cmd.sequence = cls.netcon->outgoing_unreliable_sequence;
1799 // LadyHavoc: added 6 new buttons and use and chat buttons, and prydon cursor active button
1801 if (in_attack.state & 3) bits |= 1;
1802 if (in_jump.state & 3) bits |= 2;
1803 if (in_button3.state & 3) bits |= 4;
1804 if (in_button4.state & 3) bits |= 8;
1805 if (in_button5.state & 3) bits |= 16;
1806 if (in_button6.state & 3) bits |= 32;
1807 if (in_button7.state & 3) bits |= 64;
1808 if (in_button8.state & 3) bits |= 128;
1809 if (in_use.state & 3) bits |= 256;
1810 if (key_dest != key_game || key_consoleactive || !vid_activewindow) bits |= 512;
1811 if (cl_prydoncursor.integer > 0) bits |= 1024;
1812 if (in_button9.state & 3) bits |= 2048;
1813 if (in_button10.state & 3) bits |= 4096;
1814 if (in_button11.state & 3) bits |= 8192;
1815 if (in_button12.state & 3) bits |= 16384;
1816 if (in_button13.state & 3) bits |= 32768;
1817 if (in_button14.state & 3) bits |= 65536;
1818 if (in_button15.state & 3) bits |= 131072;
1819 if (in_button16.state & 3) bits |= 262144;
1820 // button bits 19-31 unused currently
1821 // rotate/zoom view serverside if PRYDON_CLIENTCURSOR cursor is at edge of screen
1822 if(cl_prydoncursor.integer > 0)
1824 if (cl.cmd.cursor_screen[0] <= -1) bits |= 8;
1825 if (cl.cmd.cursor_screen[0] >= 1) bits |= 16;
1826 if (cl.cmd.cursor_screen[1] <= -1) bits |= 32;
1827 if (cl.cmd.cursor_screen[1] >= 1) bits |= 64;
1830 // set buttons and impulse
1831 cl.cmd.buttons = bits;
1832 cl.cmd.impulse = in_impulse;
1835 VectorCopy(cl.viewangles, cl.cmd.viewangles);
1837 // bones_was_here: previously cl.cmd.frametime was floored to nearest millisec
1838 // this meant the smoothest async movement required integer millisec
1839 // client and server frame times (eg 125fps)
1840 cl.cmd.frametime = bound(0.0, cl.cmd.time - cl.movecmd[1].time, 0.255);
1841 // ridiculous value rejection (matches qw)
1842 if (cl.cmd.frametime > 0.25)
1843 cl.cmd.frametime = 0.1;
1844 cl.cmd.msec = (unsigned char)floor(cl.cmd.frametime * 1000);
1846 switch(cls.protocol)
1848 case PROTOCOL_QUAKEWORLD:
1849 // quakeworld uses a different cvar with opposite meaning, for compatibility
1850 cl.cmd.predicted = cl_nopred.integer == 0;
1852 case PROTOCOL_DARKPLACES6:
1853 case PROTOCOL_DARKPLACES7:
1854 case PROTOCOL_DARKPLACES8:
1855 cl.cmd.predicted = cl_movement.integer != 0;
1858 cl.cmd.predicted = false;
1862 // movement is set by input code (forwardmove/sidemove/upmove)
1863 // always dump the first two moves, because they may contain leftover inputs from the last level
1864 if (cl.cmd.sequence <= 2)
1865 cl.cmd.forwardmove = cl.cmd.sidemove = cl.cmd.upmove = cl.cmd.impulse = cl.cmd.buttons = 0;
1867 cl.cmd.jump = (cl.cmd.buttons & 2) != 0;
1869 switch (cls.protocol)
1871 case PROTOCOL_QUAKEWORLD:
1872 case PROTOCOL_QUAKE:
1873 case PROTOCOL_QUAKEDP:
1874 case PROTOCOL_NEHAHRAMOVIE:
1875 case PROTOCOL_NEHAHRABJP:
1876 case PROTOCOL_NEHAHRABJP2:
1877 case PROTOCOL_NEHAHRABJP3:
1878 case PROTOCOL_DARKPLACES1:
1879 case PROTOCOL_DARKPLACES2:
1880 case PROTOCOL_DARKPLACES3:
1881 case PROTOCOL_DARKPLACES4:
1882 case PROTOCOL_DARKPLACES5:
1884 case PROTOCOL_DARKPLACES6:
1885 case PROTOCOL_DARKPLACES7:
1886 case PROTOCOL_DARKPLACES8:
1887 // FIXME: cl.cmd.buttons & 16 is +button5, Nexuiz/Xonotic specific
1888 cl.cmd.crouch = (cl.cmd.buttons & 16) != 0;
1890 case PROTOCOL_UNKNOWN:
1895 cl.movecmd[0] = cl.cmd;
1897 /* Accumulating cl.realframetime to prevent low packet rates,
1898 * previously with cl_maxfps == cl_netfps it did not send every frame because
1899 * host.realtime - cl.lastpackettime was often well below (or above) cl_packetinterval.
1901 cl.timesincepacket += cl.realframetime;
1903 // don't predict more than 256fps
1904 if (cl.timesincepacket >= 1/256)
1905 cl.movement_replay = true; // redo the prediction
1907 // now decide whether to actually send this move
1908 // (otherwise it is only for prediction)
1910 // do not send 0ms packets because they mess up physics
1911 if(cl.cmd.msec == 0 && cl.time > cl.oldtime && (cls.protocol == PROTOCOL_QUAKEWORLD || cls.signon == SIGNONS))
1914 // don't send too often or else network connections can get clogged by a
1915 // high renderer framerate
1916 packettime = 1.0f / bound(10.0f, cl_netfps.value, 1000.0f);
1917 if (cl.movevars_ticrate)
1919 packettime = bound(cl.movevars_ticrate * 0.5f, packettime, cl.movevars_ticrate);
1920 sv_frametime = cl.movevars_ticrate;
1922 else // fallback, may be affected by server->client network problems
1923 sv_frametime = (cl.mtime[0] - cl.mtime[1]) / cl.movevars_timescale;
1925 // always send if buttons changed or an impulse is pending
1926 // even if it violates the rate limit!
1927 important = (cl.cmd.impulse || (cl_netimmediatebuttons.integer && cl.cmd.buttons != cl.movecmd[1].buttons));
1929 lag = cl.mtime[0] - cl.cmd.time;
1930 frames_per_tic = sv_frametime / cl.realframetime;
1931 // opportune_moment = lag <= cl.realframetime * 2; // FAIL: can miss the moment with uncapped fps
1932 // opportune_moment = lag <= cl.realframetime * frames_per_tic * 0.5; // FAIL: too early at high fps, reducing multi causes misses at moderate fps
1933 opportune_moment = lag <= cl.realframetime * (frames_per_tic <= 1 ? 1 : sqrt(frames_per_tic)); // perfect
1935 // Two methods for deciding when to send
1938 // Traditional time interval, now used as fallback
1939 if (sv_frametime <= 0 || lag > sv_frametime || lag < 0) // unknown ticrate || lag/PL || still connecting
1941 if (cl.timesincepacket < packettime * 0.99999f)
1943 // Con_Printf("^6moveft %f realft %f lag %f tic %f inputsince %d\n", cl.cmd.frametime, cl.realframetime, lag, sv_frametime, cl.opt_inputs_since_update);
1947 // Server-synchronised, for better pings
1948 // Sends at least once per server frame
1949 else // cl.opt_inputs_since_update is usable
1951 if (!opportune_moment || cl.opt_inputs_since_update >= sv_frametime / packettime)
1953 // Con_Printf("^1moveft %f realft %f lag %f tic %f inputsince %d\n", cl.cmd.frametime, cl.realframetime, lag, sv_frametime, cl.opt_inputs_since_update);
1959 // don't choke the connection with packets (obey rate limit)
1960 // it is important that this check be last, because it adds a new
1961 // frame to the shownetgraph output and any cancelation after this
1962 // will produce a nasty spike-like look to the netgraph
1963 // we also still send if it is important
1964 if (!NetConn_CanSend(cls.netcon) && !important)
1967 // Con_Printf("%smoveft %f realft %f lag %f tic %f inputsince %d important %d\n", (lag < 0.0005 || !opportune_moment) ? "^3" : "^2", cl.cmd.frametime, cl.realframetime, lag, sv_frametime, cl.opt_inputs_since_update, important);
1969 if (opportune_moment) // this check is needed for optimal timing especially with cl_netimmediatebuttons
1970 ++cl.opt_inputs_since_update;
1972 // reset the packet timing accumulator
1973 cl.timesincepacket = 0;
1975 buf.maxsize = sizeof(data);
1979 // send the movement message
1980 // PROTOCOL_QUAKE clc_move = 16 bytes total
1981 // PROTOCOL_QUAKEDP clc_move = 16 bytes total
1982 // PROTOCOL_NEHAHRAMOVIE clc_move = 16 bytes total
1983 // PROTOCOL_DARKPLACES1 clc_move = 19 bytes total
1984 // PROTOCOL_DARKPLACES2 clc_move = 25 bytes total
1985 // PROTOCOL_DARKPLACES3 clc_move = 25 bytes total
1986 // PROTOCOL_DARKPLACES4 clc_move = 19 bytes total
1987 // PROTOCOL_DARKPLACES5 clc_move = 19 bytes total
1988 // PROTOCOL_DARKPLACES6 clc_move = 52 bytes total
1989 // PROTOCOL_DARKPLACES7 clc_move = 56 bytes total per move (can be up to 16 moves)
1990 // PROTOCOL_DARKPLACES8 clc_move = 56 bytes total per move (can be up to 16 moves)
1991 // PROTOCOL_QUAKEWORLD clc_move = 34 bytes total (typically, but can reach 43 bytes, or even 49 bytes with roll)
1993 // set prydon cursor info
1994 CL_UpdatePrydonCursor();
1996 if (cls.protocol == PROTOCOL_QUAKEWORLD || cls.signon == SIGNONS)
1998 switch (cls.protocol)
2000 case PROTOCOL_QUAKEWORLD:
2001 MSG_WriteByte(&buf, qw_clc_move);
2002 // save the position for a checksum byte
2003 checksumindex = buf.cursize;
2004 MSG_WriteByte(&buf, 0);
2005 // packet loss percentage
2006 for (j = 0, packetloss = 0;j < NETGRAPH_PACKETS;j++)
2007 if (cls.netcon->incoming_netgraph[j].unreliablebytes == NETGRAPH_LOSTPACKET)
2009 packetloss = packetloss * 100 / NETGRAPH_PACKETS;
2010 MSG_WriteByte(&buf, packetloss);
2011 // write most recent 3 moves
2012 QW_MSG_WriteDeltaUsercmd(&buf, &nullcmd, &cl.movecmd[2]);
2013 QW_MSG_WriteDeltaUsercmd(&buf, &cl.movecmd[2], &cl.movecmd[1]);
2014 QW_MSG_WriteDeltaUsercmd(&buf, &cl.movecmd[1], &cl.cmd);
2015 // calculate the checksum
2016 buf.data[checksumindex] = COM_BlockSequenceCRCByteQW(buf.data + checksumindex + 1, buf.cursize - checksumindex - 1, cls.netcon->outgoing_unreliable_sequence);
2017 // if delta compression history overflows, request no delta
2018 if (cls.netcon->outgoing_unreliable_sequence - cl.qw_validsequence >= QW_UPDATE_BACKUP-1)
2019 cl.qw_validsequence = 0;
2020 // request delta compression if appropriate
2021 if (cl.qw_validsequence && !cl_nodelta.integer && cls.state == ca_connected && !cls.demorecording)
2023 cl.qw_deltasequence[cls.netcon->outgoing_unreliable_sequence & QW_UPDATE_MASK] = cl.qw_validsequence;
2024 MSG_WriteByte(&buf, qw_clc_delta);
2025 MSG_WriteByte(&buf, cl.qw_validsequence & 255);
2028 cl.qw_deltasequence[cls.netcon->outgoing_unreliable_sequence & QW_UPDATE_MASK] = -1;
2030 case PROTOCOL_QUAKE:
2031 case PROTOCOL_QUAKEDP:
2032 case PROTOCOL_NEHAHRAMOVIE:
2033 case PROTOCOL_NEHAHRABJP:
2034 case PROTOCOL_NEHAHRABJP2:
2035 case PROTOCOL_NEHAHRABJP3:
2037 MSG_WriteByte (&buf, clc_move);
2038 MSG_WriteFloat (&buf, cl.cmd.time); // last server packet time
2039 // 3 bytes (6 bytes in proquake)
2040 if (cls.proquake_servermod == 1) // MOD_PROQUAKE
2042 for (i = 0;i < 3;i++)
2043 MSG_WriteAngle16i (&buf, cl.cmd.viewangles[i]);
2047 for (i = 0;i < 3;i++)
2048 MSG_WriteAngle8i (&buf, cl.cmd.viewangles[i]);
2051 MSG_WriteCoord16i (&buf, cl.cmd.forwardmove);
2052 MSG_WriteCoord16i (&buf, cl.cmd.sidemove);
2053 MSG_WriteCoord16i (&buf, cl.cmd.upmove);
2055 MSG_WriteByte (&buf, cl.cmd.buttons);
2056 MSG_WriteByte (&buf, cl.cmd.impulse);
2058 case PROTOCOL_DARKPLACES2:
2059 case PROTOCOL_DARKPLACES3:
2061 MSG_WriteByte (&buf, clc_move);
2062 MSG_WriteFloat (&buf, cl.cmd.time); // last server packet time
2064 for (i = 0;i < 3;i++)
2065 MSG_WriteAngle32f (&buf, cl.cmd.viewangles[i]);
2067 MSG_WriteCoord16i (&buf, cl.cmd.forwardmove);
2068 MSG_WriteCoord16i (&buf, cl.cmd.sidemove);
2069 MSG_WriteCoord16i (&buf, cl.cmd.upmove);
2071 MSG_WriteByte (&buf, cl.cmd.buttons);
2072 MSG_WriteByte (&buf, cl.cmd.impulse);
2074 case PROTOCOL_DARKPLACES1:
2075 case PROTOCOL_DARKPLACES4:
2076 case PROTOCOL_DARKPLACES5:
2078 MSG_WriteByte (&buf, clc_move);
2079 MSG_WriteFloat (&buf, cl.cmd.time); // last server packet time
2081 for (i = 0;i < 3;i++)
2082 MSG_WriteAngle16i (&buf, cl.cmd.viewangles[i]);
2084 MSG_WriteCoord16i (&buf, cl.cmd.forwardmove);
2085 MSG_WriteCoord16i (&buf, cl.cmd.sidemove);
2086 MSG_WriteCoord16i (&buf, cl.cmd.upmove);
2088 MSG_WriteByte (&buf, cl.cmd.buttons);
2089 MSG_WriteByte (&buf, cl.cmd.impulse);
2090 case PROTOCOL_DARKPLACES6:
2091 case PROTOCOL_DARKPLACES7:
2092 case PROTOCOL_DARKPLACES8:
2093 // set the maxusercmds variable to limit how many should be sent
2094 maxusercmds = bound(1, cl_netrepeatinput.integer + 1, min(3, CL_MAX_USERCMDS));
2095 // when movement prediction is off, there's not much point in repeating old input as it will just be ignored
2096 if (!cl.cmd.predicted)
2099 // send the latest moves in order, the old ones will be
2100 // ignored by the server harmlessly, however if the previous
2101 // packets were lost these moves will be used
2103 // this reduces packet loss impact on gameplay.
2104 for (j = 0, cmd = &cl.movecmd[maxusercmds-1];j < maxusercmds;j++, cmd--)
2106 // don't repeat any stale moves
2107 if (cmd->sequence && cmd->sequence < cls.servermovesequence)
2110 MSG_WriteByte (&buf, clc_move);
2111 if (cls.protocol != PROTOCOL_DARKPLACES6)
2112 MSG_WriteLong (&buf, cmd->predicted ? cmd->sequence : 0);
2113 MSG_WriteFloat (&buf, cmd->time); // last server packet time
2115 for (i = 0;i < 3;i++)
2116 MSG_WriteAngle16i (&buf, cmd->viewangles[i]);
2118 MSG_WriteCoord16i (&buf, cmd->forwardmove);
2119 MSG_WriteCoord16i (&buf, cmd->sidemove);
2120 MSG_WriteCoord16i (&buf, cmd->upmove);
2122 MSG_WriteLong (&buf, cmd->buttons);
2123 MSG_WriteByte (&buf, cmd->impulse);
2124 // PRYDON_CLIENTCURSOR
2126 MSG_WriteShort (&buf, (short)(cmd->cursor_screen[0] * 32767.0f));
2127 MSG_WriteShort (&buf, (short)(cmd->cursor_screen[1] * 32767.0f));
2128 MSG_WriteFloat (&buf, cmd->cursor_start[0]);
2129 MSG_WriteFloat (&buf, cmd->cursor_start[1]);
2130 MSG_WriteFloat (&buf, cmd->cursor_start[2]);
2131 MSG_WriteFloat (&buf, cmd->cursor_impact[0]);
2132 MSG_WriteFloat (&buf, cmd->cursor_impact[1]);
2133 MSG_WriteFloat (&buf, cmd->cursor_impact[2]);
2134 MSG_WriteShort (&buf, cmd->cursor_entitynumber);
2137 case PROTOCOL_UNKNOWN:
2142 if (cls.protocol != PROTOCOL_QUAKEWORLD && buf.cursize)
2144 // ack entity frame numbers received since the last input was sent
2145 // (redundent to improve handling of client->server packet loss)
2146 // if cl_netrepeatinput is 1 and client framerate matches server
2147 // framerate, this is 10 bytes, if client framerate is lower this
2149 unsigned int oldsequence = cl.cmd.sequence;
2150 unsigned int delta = bound(1, cl_netrepeatinput.integer + 1, 3);
2151 if (oldsequence > delta)
2152 oldsequence = oldsequence - delta;
2155 for (i = 0;i < LATESTFRAMENUMS;i++)
2157 j = (cl.latestframenumsposition + i) % LATESTFRAMENUMS;
2158 if (cl.latestsendnums[j] >= oldsequence)
2160 if (developer_networkentities.integer >= 10)
2161 Con_Printf("send clc_ackframe %i\n", cl.latestframenums[j]);
2162 MSG_WriteByte(&buf, clc_ackframe);
2163 MSG_WriteLong(&buf, cl.latestframenums[j]);
2168 // PROTOCOL_DARKPLACES6 = 67 bytes per packet
2169 // PROTOCOL_DARKPLACES7 = 71 bytes per packet
2171 // acknowledge any recently received data blocks
2172 for (i = 0;i < CL_MAX_DOWNLOADACKS && (cls.dp_downloadack[i].start || cls.dp_downloadack[i].size);i++)
2174 MSG_WriteByte(&buf, clc_ackdownloaddata);
2175 MSG_WriteLong(&buf, cls.dp_downloadack[i].start);
2176 MSG_WriteShort(&buf, cls.dp_downloadack[i].size);
2177 cls.dp_downloadack[i].start = 0;
2178 cls.dp_downloadack[i].size = 0;
2181 // send the reliable message (forwarded commands) if there is one
2182 if (buf.cursize || cls.netcon->message.cursize)
2183 NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol, max(20*(buf.cursize+40), cl_rate.integer), cl_rate_burstsize.integer, false);
2187 // update the cl.movecmd array which holds the most recent moves,
2188 // because we now need a new slot for the next input
2189 for (i = CL_MAX_USERCMDS - 1;i >= 1;i--)
2190 cl.movecmd[i] = cl.movecmd[i-1];
2191 cl.movecmd[0].msec = 0;
2192 cl.movecmd[0].frametime = 0;
2195 // clear button 'click' states
2196 in_attack.state &= ~2;
2197 in_jump.state &= ~2;
2198 in_button3.state &= ~2;
2199 in_button4.state &= ~2;
2200 in_button5.state &= ~2;
2201 in_button6.state &= ~2;
2202 in_button7.state &= ~2;
2203 in_button8.state &= ~2;
2205 in_button9.state &= ~2;
2206 in_button10.state &= ~2;
2207 in_button11.state &= ~2;
2208 in_button12.state &= ~2;
2209 in_button13.state &= ~2;
2210 in_button14.state &= ~2;
2211 in_button15.state &= ~2;
2212 in_button16.state &= ~2;
2216 if (cls.netcon->message.overflowed)
2217 CL_DisconnectEx(true, "Lost connection to server");
2225 void CL_InitInput (void)
2227 Cmd_AddCommand(CF_CLIENT, "+moveup",IN_UpDown, "swim upward");
2228 Cmd_AddCommand(CF_CLIENT, "-moveup",IN_UpUp, "stop swimming upward");
2229 Cmd_AddCommand(CF_CLIENT, "+movedown",IN_DownDown, "swim downward");
2230 Cmd_AddCommand(CF_CLIENT, "-movedown",IN_DownUp, "stop swimming downward");
2231 Cmd_AddCommand(CF_CLIENT, "+left",IN_LeftDown, "turn left");
2232 Cmd_AddCommand(CF_CLIENT, "-left",IN_LeftUp, "stop turning left");
2233 Cmd_AddCommand(CF_CLIENT, "+right",IN_RightDown, "turn right");
2234 Cmd_AddCommand(CF_CLIENT, "-right",IN_RightUp, "stop turning right");
2235 Cmd_AddCommand(CF_CLIENT, "+forward",IN_ForwardDown, "move forward");
2236 Cmd_AddCommand(CF_CLIENT, "-forward",IN_ForwardUp, "stop moving forward");
2237 Cmd_AddCommand(CF_CLIENT, "+back",IN_BackDown, "move backward");
2238 Cmd_AddCommand(CF_CLIENT, "-back",IN_BackUp, "stop moving backward");
2239 Cmd_AddCommand(CF_CLIENT, "+lookup", IN_LookupDown, "look upward");
2240 Cmd_AddCommand(CF_CLIENT, "-lookup", IN_LookupUp, "stop looking upward");
2241 Cmd_AddCommand(CF_CLIENT, "+lookdown", IN_LookdownDown, "look downward");
2242 Cmd_AddCommand(CF_CLIENT, "-lookdown", IN_LookdownUp, "stop looking downward");
2243 Cmd_AddCommand(CF_CLIENT, "+strafe", IN_StrafeDown, "activate strafing mode (move instead of turn)");
2244 Cmd_AddCommand(CF_CLIENT, "-strafe", IN_StrafeUp, "deactivate strafing mode");
2245 Cmd_AddCommand(CF_CLIENT, "+moveleft", IN_MoveleftDown, "strafe left");
2246 Cmd_AddCommand(CF_CLIENT, "-moveleft", IN_MoveleftUp, "stop strafing left");
2247 Cmd_AddCommand(CF_CLIENT, "+moveright", IN_MoverightDown, "strafe right");
2248 Cmd_AddCommand(CF_CLIENT, "-moveright", IN_MoverightUp, "stop strafing right");
2249 Cmd_AddCommand(CF_CLIENT, "+speed", IN_SpeedDown, "activate run mode (faster movement and turning)");
2250 Cmd_AddCommand(CF_CLIENT, "-speed", IN_SpeedUp, "deactivate run mode");
2251 Cmd_AddCommand(CF_CLIENT, "+attack", IN_AttackDown, "begin firing");
2252 Cmd_AddCommand(CF_CLIENT, "-attack", IN_AttackUp, "stop firing");
2253 Cmd_AddCommand(CF_CLIENT, "+jump", IN_JumpDown, "jump");
2254 Cmd_AddCommand(CF_CLIENT, "-jump", IN_JumpUp, "end jump (so you can jump again)");
2255 Cmd_AddCommand(CF_CLIENT, "impulse", IN_Impulse, "send an impulse number to server (select weapon, use item, etc)");
2256 Cmd_AddCommand(CF_CLIENT, "+klook", IN_KLookDown, "activate keyboard looking mode, do not recenter view");
2257 Cmd_AddCommand(CF_CLIENT, "-klook", IN_KLookUp, "deactivate keyboard looking mode");
2258 Cmd_AddCommand(CF_CLIENT, "+mlook", IN_MLookDown, "activate mouse looking mode, do not recenter view");
2259 Cmd_AddCommand(CF_CLIENT, "-mlook", IN_MLookUp, "deactivate mouse looking mode");
2261 // LadyHavoc: added lots of buttons
2262 Cmd_AddCommand(CF_CLIENT, "+use", IN_UseDown, "use something (may be used by some mods)");
2263 Cmd_AddCommand(CF_CLIENT, "-use", IN_UseUp, "stop using something");
2264 Cmd_AddCommand(CF_CLIENT, "+button3", IN_Button3Down, "activate button3 (behavior depends on mod)");
2265 Cmd_AddCommand(CF_CLIENT, "-button3", IN_Button3Up, "deactivate button3");
2266 Cmd_AddCommand(CF_CLIENT, "+button4", IN_Button4Down, "activate button4 (behavior depends on mod)");
2267 Cmd_AddCommand(CF_CLIENT, "-button4", IN_Button4Up, "deactivate button4");
2268 Cmd_AddCommand(CF_CLIENT, "+button5", IN_Button5Down, "activate button5 (behavior depends on mod)");
2269 Cmd_AddCommand(CF_CLIENT, "-button5", IN_Button5Up, "deactivate button5");
2270 Cmd_AddCommand(CF_CLIENT, "+button6", IN_Button6Down, "activate button6 (behavior depends on mod)");
2271 Cmd_AddCommand(CF_CLIENT, "-button6", IN_Button6Up, "deactivate button6");
2272 Cmd_AddCommand(CF_CLIENT, "+button7", IN_Button7Down, "activate button7 (behavior depends on mod)");
2273 Cmd_AddCommand(CF_CLIENT, "-button7", IN_Button7Up, "deactivate button7");
2274 Cmd_AddCommand(CF_CLIENT, "+button8", IN_Button8Down, "activate button8 (behavior depends on mod)");
2275 Cmd_AddCommand(CF_CLIENT, "-button8", IN_Button8Up, "deactivate button8");
2276 Cmd_AddCommand(CF_CLIENT, "+button9", IN_Button9Down, "activate button9 (behavior depends on mod)");
2277 Cmd_AddCommand(CF_CLIENT, "-button9", IN_Button9Up, "deactivate button9");
2278 Cmd_AddCommand(CF_CLIENT, "+button10", IN_Button10Down, "activate button10 (behavior depends on mod)");
2279 Cmd_AddCommand(CF_CLIENT, "-button10", IN_Button10Up, "deactivate button10");
2280 Cmd_AddCommand(CF_CLIENT, "+button11", IN_Button11Down, "activate button11 (behavior depends on mod)");
2281 Cmd_AddCommand(CF_CLIENT, "-button11", IN_Button11Up, "deactivate button11");
2282 Cmd_AddCommand(CF_CLIENT, "+button12", IN_Button12Down, "activate button12 (behavior depends on mod)");
2283 Cmd_AddCommand(CF_CLIENT, "-button12", IN_Button12Up, "deactivate button12");
2284 Cmd_AddCommand(CF_CLIENT, "+button13", IN_Button13Down, "activate button13 (behavior depends on mod)");
2285 Cmd_AddCommand(CF_CLIENT, "-button13", IN_Button13Up, "deactivate button13");
2286 Cmd_AddCommand(CF_CLIENT, "+button14", IN_Button14Down, "activate button14 (behavior depends on mod)");
2287 Cmd_AddCommand(CF_CLIENT, "-button14", IN_Button14Up, "deactivate button14");
2288 Cmd_AddCommand(CF_CLIENT, "+button15", IN_Button15Down, "activate button15 (behavior depends on mod)");
2289 Cmd_AddCommand(CF_CLIENT, "-button15", IN_Button15Up, "deactivate button15");
2290 Cmd_AddCommand(CF_CLIENT, "+button16", IN_Button16Down, "activate button16 (behavior depends on mod)");
2291 Cmd_AddCommand(CF_CLIENT, "-button16", IN_Button16Up, "deactivate button16");
2293 // LadyHavoc: added bestweapon command
2294 Cmd_AddCommand(CF_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)");
2295 Cmd_AddCommand(CF_CLIENT, "register_bestweapon", IN_BestWeapon_Register_f, "(for QC usage only) change weapon parameters to be used by bestweapon; stuffcmd this in ClientConnect");
2297 Cvar_RegisterVariable(&cl_movecliptokeyboard);
2298 Cvar_RegisterVariable(&cl_movement);
2299 Cvar_RegisterVariable(&cl_movement_replay);
2300 Cvar_RegisterVariable(&cl_movement_nettimeout);
2301 Cvar_RegisterVariable(&cl_movement_minping);
2302 Cvar_RegisterVariable(&cl_movement_track_canjump);
2303 Cvar_RegisterVariable(&cl_movement_maxspeed);
2304 Cvar_RegisterVariable(&cl_movement_maxairspeed);
2305 Cvar_RegisterVariable(&cl_movement_stopspeed);
2306 Cvar_RegisterVariable(&cl_movement_friction);
2307 Cvar_RegisterVariable(&cl_movement_wallfriction);
2308 Cvar_RegisterVariable(&cl_movement_waterfriction);
2309 Cvar_RegisterVariable(&cl_movement_edgefriction);
2310 Cvar_RegisterVariable(&cl_movement_stepheight);
2311 Cvar_RegisterVariable(&cl_movement_accelerate);
2312 Cvar_RegisterVariable(&cl_movement_airaccelerate);
2313 Cvar_RegisterVariable(&cl_movement_wateraccelerate);
2314 Cvar_RegisterVariable(&cl_movement_jumpvelocity);
2315 Cvar_RegisterVariable(&cl_movement_airaccel_qw);
2316 Cvar_RegisterVariable(&cl_movement_airaccel_sideways_friction);
2317 Cvar_RegisterVariable(&cl_nopred);
2319 Cvar_RegisterVariable(&in_pitch_min);
2320 Cvar_RegisterVariable(&in_pitch_max);
2321 Cvar_RegisterVariable(&m_filter);
2322 Cvar_RegisterVariable(&m_accelerate);
2323 Cvar_RegisterVariable(&m_accelerate_minspeed);
2324 Cvar_RegisterVariable(&m_accelerate_maxspeed);
2325 Cvar_RegisterVariable(&m_accelerate_filter);
2326 Cvar_RegisterVariable(&m_accelerate_power);
2327 Cvar_RegisterVariable(&m_accelerate_power_offset);
2328 Cvar_RegisterVariable(&m_accelerate_power_senscap);
2329 Cvar_RegisterVariable(&m_accelerate_power_strength);
2330 Cvar_RegisterVariable(&m_accelerate_natural_offset);
2331 Cvar_RegisterVariable(&m_accelerate_natural_accelsenscap);
2332 Cvar_RegisterVariable(&m_accelerate_natural_strength);
2334 Cvar_RegisterVariable(&cl_netfps);
2335 Cvar_RegisterVariable(&cl_netrepeatinput);
2336 Cvar_RegisterVariable(&cl_netimmediatebuttons);
2338 Cvar_RegisterVariable(&cl_nodelta);
2340 Cvar_RegisterVariable(&cl_csqc_generatemousemoveevents);