cl_input.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20 // cl.input.c  -- builds an intended movement command to send to the server
  21
  22 // Quake is a trademark of Id Software, Inc., (c) 1996 Id Software, Inc. All
  23 // rights reserved.
  24
  25 #include "quakedef.h"
  26 #include "csprogs.h"
  27 #include "thread.h"
  28
  29 /*
  30 ===============================================================================
  31
  32 KEY BUTTONS
  33
  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.
  38
  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
  41 the release.
  42
  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
  46
  47 ===============================================================================
  48 */
  49
  50
  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;
  58 //even more
  59 kbutton_t       in_button9, in_button10, in_button11, in_button12, in_button13, in_button14, in_button15, in_button16;
  60
  61 int                     in_impulse;
  62
  63
  64
  65 static void KeyDown (cmd_state_t *cmd, kbutton_t *b)
  66 {
  67         int k;
  68         const char *c;
  69
  70         c = Cmd_Argv(cmd, 1);
  71         if (c[0])
  72                 k = atoi(c);
  73         else
  74                 k = -1;         // typed manually at the console for continuous down
  75
  76         if (k == b->down[0] || k == b->down[1])
  77                 return;         // repeating key
  78
  79         if (!b->down[0])
  80                 b->down[0] = k;
  81         else if (!b->down[1])
  82                 b->down[1] = k;
  83         else
  84         {
  85                 Con_Print("Three keys down for a button!\n");
  86                 return;
  87         }
  88
  89         if (b->state & 1)
  90                 return;         // still down
  91         b->state |= 1 + 2;      // down + impulse down
  92 }
  93
  94 static void KeyUp (cmd_state_t *cmd, kbutton_t *b)
  95 {
  96         int k;
  97         const char *c;
  98
  99         c = Cmd_Argv(cmd, 1);
 100         if (c[0])
 101                 k = atoi(c);
 102         else
 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
 106                 return;
 107         }
 108
 109         if (b->down[0] == k)
 110                 b->down[0] = 0;
 111         else if (b->down[1] == k)
 112                 b->down[1] = 0;
 113         else
 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
 117
 118         if (!(b->state & 1))
 119                 return;         // still up (this should not happen)
 120         b->state &= ~1;         // now up
 121         b->state |= 4;          // impulse up
 122 }
 123
 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)
 128 {
 129         KeyUp(cmd, &in_mlook);
 130         if ( !(in_mlook.state&1) && lookspring.value)
 131                 V_StartPitchDrift_f(cmd);
 132 }
 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);}
 153
 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);}
 158
 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);}
 161
 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);}
 164
 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);}
 178
 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);}
 195
 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);}
 198
 199 static void IN_Impulse(cmd_state_t *cmd) {in_impulse=atoi(Cmd_Argv(cmd, 1));}
 200
 201 in_bestweapon_info_t in_bestweapon_info[IN_BESTWEAPON_MAX];
 202
 203 static void IN_BestWeapon_Register(const char *name, int impulse, int weaponbit, int activeweaponcode, int ammostat, int ammomin)
 204 {
 205         int i;
 206         for(i = 0; i < IN_BESTWEAPON_MAX && in_bestweapon_info[i].impulse; ++i)
 207                 if(in_bestweapon_info[i].impulse == impulse)
 208                         break;
 209         if(i >= IN_BESTWEAPON_MAX)
 210         {
 211                 Con_Printf("no slot left for weapon definition; increase IN_BESTWEAPON_MAX\n");
 212                 return; // sorry
 213         }
 214         dp_strlcpy(in_bestweapon_info[i].name, name, sizeof(in_bestweapon_info[i].name));
 215         in_bestweapon_info[i].impulse = impulse;
 216         if(weaponbit != -1)
 217                 in_bestweapon_info[i].weaponbit = weaponbit;
 218         if(activeweaponcode != -1)
 219                 in_bestweapon_info[i].activeweaponcode = activeweaponcode;
 220         if(ammostat != -1)
 221                 in_bestweapon_info[i].ammostat = ammostat;
 222         if(ammomin != -1)
 223                 in_bestweapon_info[i].ammomin = ammomin;
 224 }
 225
 226 void IN_BestWeapon_ResetData (void)
 227 {
 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
 242 }
 243
 244 static void IN_BestWeapon_Register_f(cmd_state_t *cmd)
 245 {
 246         if(Cmd_Argc(cmd) == 7)
 247         {
 248                 IN_BestWeapon_Register(
 249                         Cmd_Argv(cmd, 1),
 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))
 255                 );
 256         }
 257         else if(Cmd_Argc(cmd) == 2 && !strcmp(Cmd_Argv(cmd, 1), "clear"))
 258         {
 259                 memset(in_bestweapon_info, 0, sizeof(in_bestweapon_info));
 260         }
 261         else if(Cmd_Argc(cmd) == 2 && !strcmp(Cmd_Argv(cmd, 1), "quake"))
 262         {
 263                 IN_BestWeapon_ResetData();
 264         }
 265         else
 266         {
 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));
 268         }
 269 }
 270
 271 static void IN_BestWeapon_f(cmd_state_t *cmd)
 272 {
 273         int i, n;
 274         const char *t;
 275         if (Cmd_Argc(cmd) < 2)
 276         {
 277                 Con_Printf("bestweapon requires 1 or more parameters\n");
 278                 return;
 279         }
 280         for (i = 1;i < Cmd_Argc(cmd);i++)
 281         {
 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++)
 285                 {
 286                         if (!strcmp(in_bestweapon_info[n].name, t))
 287                         {
 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))
 291                                 {
 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;
 295                                         return;
 296                                 }
 297                                 break;
 298                         }
 299                 }
 300                 // if we couldn't identify the weapon we just ignore it and continue checking for other weapons
 301         }
 302         // if we couldn't find any of the weapons, there's nothing more we can do...
 303 }
 304
 305 /*
 306 ===============
 307 CL_KeyState
 308
 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
 313 ===============
 314 */
 315 float CL_KeyState (kbutton_t *key)
 316 {
 317         float           val;
 318         qbool   impulsedown, impulseup, down;
 319
 320         impulsedown = (key->state & 2) != 0;
 321         impulseup = (key->state & 4) != 0;
 322         down = (key->state & 1) != 0;
 323         val = 0;
 324
 325         if (impulsedown && !impulseup)
 326         {
 327                 if (down)
 328                         val = 0.5;      // pressed and held this frame
 329                 else
 330                         val = 0;        //      I_Error ();
 331         }
 332         if (impulseup && !impulsedown)
 333         {
 334                 if (down)
 335                         val = 0;        //      I_Error ();
 336                 else
 337                         val = 0;        // released this frame
 338         }
 339         if (!impulsedown && !impulseup)
 340         {
 341                 if (down)
 342                         val = 1.0;      // held the entire frame
 343                 else
 344                         val = 0;        // up the entire frame
 345         }
 346         if (impulsedown && impulseup)
 347         {
 348                 if (down)
 349                         val = 0.75;     // released and re-pressed this frame
 350                 else
 351                         val = 0.25;     // pressed and released this frame
 352         }
 353
 354         key->state &= 1;                // clear impulses
 355
 356         return val;
 357 }
 358
 359
 360
 361
 362 //==========================================================================
 363
 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"};
 368
 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"};
 371
 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"};
 374
 375 cvar_t cl_anglespeedkey = {CF_CLIENT | CF_ARCHIVE, "cl_anglespeedkey","1.5","how much +speed multiplies keyboard turning speed"};
 376
 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)"};
 397
 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)"};
 400
 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"};
 413
 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)"};
 417
 418 cvar_t cl_nodelta = {CF_CLIENT, "cl_nodelta", "0", "disables delta compression of non-player entities in QW network protocol"};
 419
 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"};
 421
 422 extern cvar_t v_flipped;
 423
 424 /*
 425 ================
 426 CL_AdjustAngles
 427
 428 Moves the local angle positions
 429 ================
 430 */
 431 static void CL_AdjustAngles (void)
 432 {
 433         float   speed;
 434         float   up, down;
 435
 436         if (in_speed.state & 1)
 437                 speed = cl.realframetime * cl_anglespeedkey.value;
 438         else
 439                 speed = cl.realframetime;
 440
 441         if (!(in_strafe.state & 1))
 442         {
 443                 cl.viewangles[YAW] -= speed*cl_yawspeed.value*CL_KeyState (&in_right);
 444                 cl.viewangles[YAW] += speed*cl_yawspeed.value*CL_KeyState (&in_left);
 445         }
 446         if (in_klook.state & 1)
 447         {
 448                 V_StopPitchDrift ();
 449                 cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * CL_KeyState (&in_forward);
 450                 cl.viewangles[PITCH] += speed*cl_pitchspeed.value * CL_KeyState (&in_back);
 451         }
 452
 453         up = CL_KeyState (&in_lookup);
 454         down = CL_KeyState(&in_lookdown);
 455
 456         cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * up;
 457         cl.viewangles[PITCH] += speed*cl_pitchspeed.value * down;
 458
 459         if (up || down)
 460                 V_StopPitchDrift ();
 461
 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);
 472 }
 473
 474 int cl_ignoremousemoves = 2;
 475
 476 /*
 477 ================
 478 CL_Input
 479
 480 Send the intended movement message to the server
 481 ================
 482 */
 483 void CL_Input (void)
 484 {
 485         float mx, my;
 486         static float old_mouse_x = 0, old_mouse_y = 0;
 487
 488         // clamp before the move to prevent starting with bad angles
 489         CL_AdjustAngles ();
 490
 491         if(v_flipped.integer)
 492                 cl.viewangles[YAW] = -cl.viewangles[YAW];
 493
 494         // reset some of the command fields
 495         cl.cmd.forwardmove = 0;
 496         cl.cmd.sidemove = 0;
 497         cl.cmd.upmove = 0;
 498
 499         // get basic movement from keyboard
 500         if (in_strafe.state & 1)
 501         {
 502                 cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_right);
 503                 cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_left);
 504         }
 505
 506         cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_moveright);
 507         cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_moveleft);
 508
 509         cl.cmd.upmove += cl_upspeed.value * CL_KeyState (&in_up);
 510         cl.cmd.upmove -= cl_upspeed.value * CL_KeyState (&in_down);
 511
 512         if (! (in_klook.state & 1) )
 513         {
 514                 cl.cmd.forwardmove += cl_forwardspeed.value * CL_KeyState (&in_forward);
 515                 cl.cmd.forwardmove -= cl_backspeed.value * CL_KeyState (&in_back);
 516         }
 517
 518         // adjust for speed key
 519         if (in_speed.state & 1)
 520         {
 521                 cl.cmd.forwardmove *= cl_movespeedkey.value;
 522                 cl.cmd.sidemove *= cl_movespeedkey.value;
 523                 cl.cmd.upmove *= cl_movespeedkey.value;
 524         }
 525
 526         // allow mice or other external controllers to add to the move
 527         IN_Move ();
 528
 529         // send mouse move to csqc
 530         if (CLVM_prog->loaded && cl_csqc_generatemousemoveevents.integer)
 531         {
 532                 if (cl.csqc_wantsmousemove)
 533                 {
 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)
 537                         {
 538                                 CL_VM_InputEvent(3, in_windowmouse_x * vid_conwidth.value / vid.mode.width, in_windowmouse_y * vid_conheight.value / vid.mode.height);
 539                                 oldwindowmouse[0] = in_windowmouse_x;
 540                                 oldwindowmouse[1] = in_windowmouse_y;
 541                         }
 542                 }
 543                 else
 544                 {
 545                         if (in_mouse_x || in_mouse_y)
 546                                 CL_VM_InputEvent(2, in_mouse_x, in_mouse_y);
 547                 }
 548         }
 549
 550         // apply m_accelerate if it is on
 551         if(m_accelerate.value > 0)
 552         {
 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;
 556                 float f, mi, ma;
 557                 if(m_accelerate_filter.value > 0)
 558                         f = bound(0, cl.realframetime / m_accelerate_filter.value, 1);
 559                 else
 560                         f = 1;
 561                 averagespeed = speed * f + averagespeed * (1 - f);
 562
 563                 // Note: this check is technically unnecessary, as everything in here cancels out if it is zero.
 564                 if (m_accelerate.value != 1.0f)
 565                 {
 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.
 569
 570                         mi = max(1, m_accelerate_minspeed.value);
 571                         ma = max(m_accelerate_minspeed.value + 1, m_accelerate_maxspeed.value);
 572
 573                         if(averagespeed <= mi)
 574                         {
 575                                 f = 1;
 576                         }
 577                         else if(averagespeed >= ma)
 578                         {
 579                                 f = m_accelerate.value;
 580                         }
 581                         else
 582                         {
 583                                 f = averagespeed;
 584                                 f = (f - mi) / (ma - mi) * (m_accelerate.value - 1) + 1;
 585                         }
 586                         in_mouse_x *= f;
 587                         in_mouse_y *= f;
 588                 }
 589
 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)
 592                 {
 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)
 602                         {
 603                                 if (m_accelerate_power.value > 1.0f)
 604                                 {
 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;
 608                                 }
 609                                 else
 610                                 {
 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.
 615                                 }
 616                         }
 617                         else
 618                         {
 619                                 // The limit of the then-branch for adjusted_speed -> 0.
 620                                 // accelsens += 0.0f;
 621                         }
 622                         if (m_accelerate_power_senscap.value > 0.0f && accelsens > m_accelerate_power_senscap.value * inv_sensitivity)
 623                         {
 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;
 627                         }
 628
 629                         in_mouse_x *= accelsens;
 630                         in_mouse_y *= accelsens;
 631                 }
 632
 633                 if (m_accelerate_natural_strength.value > 0.0f && m_accelerate_natural_accelsenscap.value >= 0.0f)
 634                 {
 635                         float accelsens = 1.0f;
 636                         float adjusted_speed_pxms = (averagespeed * 0.001f - m_accelerate_natural_offset.value);
 637
 638                         if (adjusted_speed_pxms > 0 && m_accelerate_natural_accelsenscap.value != 1.0f)
 639                         {
 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) )));
 645                         }
 646
 647                         in_mouse_x *= accelsens;
 648                         in_mouse_y *= accelsens;
 649                 }
 650         }
 651
 652         // apply m_filter if it is on
 653         mx = in_mouse_x;
 654         my = in_mouse_y;
 655         if (m_filter.integer)
 656         {
 657                 in_mouse_x = (mx + old_mouse_x) * 0.5;
 658                 in_mouse_y = (my + old_mouse_y) * 0.5;
 659         }
 660         old_mouse_x = mx;
 661         old_mouse_y = my;
 662
 663         // ignore a mouse move if mouse was activated/deactivated this frame
 664         if (cl_ignoremousemoves)
 665         {
 666                 cl_ignoremousemoves--;
 667                 in_mouse_x = old_mouse_x = 0;
 668                 in_mouse_y = old_mouse_y = 0;
 669         }
 670
 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)
 673         {
 674                 float modulatedsensitivity = sensitivity.value * cl.sensitivityscale;
 675                 if (in_strafe.state & 1)
 676                 {
 677                         // strafing mode, all looking is movement
 678                         V_StopPitchDrift();
 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;
 682                         else
 683                                 cl.cmd.forwardmove -= m_forward.value * in_mouse_y * modulatedsensitivity;
 684                 }
 685                 else if ((in_mlook.state & 1) || freelook.integer)
 686                 {
 687                         // mouselook, lookstrafe causes turning to become strafing
 688                         V_StopPitchDrift();
 689                         if (lookstrafe.integer)
 690                                 cl.cmd.sidemove += m_side.value * in_mouse_x * modulatedsensitivity;
 691                         else
 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;
 694                 }
 695                 else
 696                 {
 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;
 700                 }
 701         }
 702         else // don't pitch drift when csqc is controlling the mouse
 703         {
 704                 // mouse interacting with the scene, mostly stationary view
 705                 V_StopPitchDrift();
 706                 // update prydon cursor
 707                 cl.cmd.cursor_screen[0] = in_windowmouse_x * 2.0 / vid.mode.width - 1.0;
 708                 cl.cmd.cursor_screen[1] = in_windowmouse_y * 2.0 / vid.mode.height - 1.0;
 709         }
 710
 711         if(v_flipped.integer)
 712         {
 713                 cl.viewangles[YAW] = -cl.viewangles[YAW];
 714                 cl.cmd.sidemove = -cl.cmd.sidemove;
 715         }
 716
 717         // clamp after the move to prevent rendering with bad angles
 718         CL_AdjustAngles ();
 719
 720         if(cl_movecliptokeyboard.integer)
 721         {
 722                 vec_t f = 1;
 723                 if (in_speed.state & 1)
 724                         f *= cl_movespeedkey.value;
 725                 if(cl_movecliptokeyboard.integer == 2)
 726                 {
 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)
 732                         {
 733                                 vec_t wishspeed = sqrt(wishvel_x * wishvel_x + wishvel_y * wishvel_y);
 734                                 if(wishvel_x >= 2 * wishvel_y)
 735                                 {
 736                                         // pure X motion
 737                                         if(cl.cmd.forwardmove > 0)
 738                                                 cl.cmd.forwardmove = wishspeed;
 739                                         else
 740                                                 cl.cmd.forwardmove = -wishspeed;
 741                                         cl.cmd.sidemove = 0;
 742                                 }
 743                                 else if(wishvel_y >= 2 * wishvel_x)
 744                                 {
 745                                         // pure Y motion
 746                                         cl.cmd.forwardmove = 0;
 747                                         if(cl.cmd.sidemove > 0)
 748                                                 cl.cmd.sidemove = wishspeed;
 749                                         else
 750                                                 cl.cmd.sidemove = -wishspeed;
 751                                 }
 752                                 else
 753                                 {
 754                                         // diagonal
 755                                         if(cl.cmd.forwardmove > 0)
 756                                                 cl.cmd.forwardmove = 0.70710678118654752440 * wishspeed;
 757                                         else
 758                                                 cl.cmd.forwardmove = -0.70710678118654752440 * wishspeed;
 759                                         if(cl.cmd.sidemove > 0)
 760                                                 cl.cmd.sidemove = 0.70710678118654752440 * wishspeed;
 761                                         else
 762                                                 cl.cmd.sidemove = -0.70710678118654752440 * wishspeed;
 763                                 }
 764                         }
 765                 }
 766                 else if(cl_movecliptokeyboard.integer)
 767                 {
 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;
 773                         else
 774                                 cl.cmd.sidemove = 0;
 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;
 779                         else
 780                                 cl.cmd.forwardmove = 0;
 781                 }
 782         }
 783 }
 784
 785 #include "cl_collision.h"
 786
 787 static void CL_UpdatePrydonCursor(void)
 788 {
 789         vec3_t temp;
 790
 791         if (cl_prydoncursor.integer <= 0)
 792                 VectorClear(cl.cmd.cursor_screen);
 793
 794         /*
 795         if (cl.cmd.cursor_screen[0] < -1)
 796         {
 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;
 799         }
 800         if (cl.cmd.cursor_screen[0] > 1)
 801         {
 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;
 804         }
 805         if (cl.cmd.cursor_screen[1] < -1)
 806         {
 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;
 809         }
 810         if (cl.cmd.cursor_screen[1] > 1)
 811         {
 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;
 814         }
 815         */
 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;
 819
 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)
 827         {
 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;
 832         }
 833         else
 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);
 835 }
 836
 837 #define NUMOFFSETS 27
 838 static vec3_t offsets[NUMOFFSETS] =
 839 {
 840 // 1 no nudge (just return the original if this test passes)
 841         { 0.000,  0.000,  0.000},
 842 // 6 simple nudges
 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},
 859 };
 860
 861 static qbool CL_ClientMovement_Unstick(cl_clientmovement_state_t *s)
 862 {
 863         int i;
 864         vec3_t neworigin;
 865         for (i = 0;i < NUMOFFSETS;i++)
 866         {
 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)
 869                 {
 870                         VectorCopy(neworigin, s->origin);
 871                         return true;
 872                 }
 873         }
 874         // if all offsets failed, give up
 875         return false;
 876 }
 877
 878 static void CL_ClientMovement_UpdateStatus(cl_clientmovement_state_t *s)
 879 {
 880         vec_t f;
 881         vec3_t origin1, origin2;
 882         trace_t trace;
 883
 884         // make sure player is not stuck
 885         CL_ClientMovement_Unstick(s);
 886
 887         // set crouched
 888         if (s->cmd.crouch)
 889         {
 890                 // wants to crouch, this always works..
 891                 if (!s->crouched)
 892                         s->crouched = true;
 893         }
 894         else
 895         {
 896                 // wants to stand, if currently crouching we need to check for a
 897                 // low ceiling first
 898                 if (s->crouched)
 899                 {
 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)
 902                                 s->crouched = false;
 903                 }
 904         }
 905         if (s->crouched)
 906         {
 907                 VectorCopy(cl.playercrouchmins, s->mins);
 908                 VectorCopy(cl.playercrouchmaxs, s->maxs);
 909         }
 910         else
 911         {
 912                 VectorCopy(cl.playerstandmins, s->mins);
 913                 VectorCopy(cl.playerstandmaxs, s->maxs);
 914         }
 915
 916         // set onground
 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)
 921         {
 922                 s->onground = true;
 923
 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);
 928         }
 929         else
 930                 s->onground = false;
 931
 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;
 936         if (s->watertype)
 937         {
 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)
 941                 {
 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;
 946                 }
 947         }
 948
 949         // water jump prediction
 950         if (s->onground || s->velocity[2] <= 0 || s->waterjumptime <= 0)
 951                 s->waterjumptime = 0;
 952 }
 953
 954 static void CL_ClientMovement_Move(cl_clientmovement_state_t *s)
 955 {
 956         int bump;
 957         double t;
 958         vec_t f;
 959         vec3_t neworigin;
 960         vec3_t currentorigin2;
 961         vec3_t neworigin2;
 962         vec3_t primalvelocity;
 963         trace_t trace;
 964         trace_t trace2;
 965         trace_t trace3;
 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++)
 969         {
 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)
 973                 {
 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)
 980                         {
 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)
 988                                 {
 989                                         trace = trace2;
 990                                         VectorCopy(trace3.endpos, trace.endpos);
 991                                 }
 992                         }
 993                 }
 994
 995                 // check if it moved at all
 996                 if (trace.fraction >= 0.001)
 997                         VectorCopy(trace.endpos, s->origin);
 998
 999                 // check if it moved all the way
1000                 if (trace.fraction == 1)
1001                         break;
1002
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)
1008                         s->onground = true;
1009
1010                 t -= t * trace.fraction;
1011
1012                 f = DotProduct(s->velocity, trace.plane.normal);
1013                 VectorMA(s->velocity, -f, trace.plane.normal, s->velocity);
1014         }
1015         if (s->waterjumptime > 0)
1016                 VectorCopy(primalvelocity, s->velocity);
1017 }
1018
1019
1020 static void CL_ClientMovement_Physics_Swim(cl_clientmovement_state_t *s)
1021 {
1022         vec_t wishspeed;
1023         vec_t f;
1024         vec3_t wishvel;
1025         vec3_t wishdir;
1026
1027         // water jump only in certain situations
1028         // this mimics quakeworld code
1029         if (s->cmd.jump && s->waterlevel == 2 && s->velocity[2] >= -180)
1030         {
1031                 vec3_t forward;
1032                 vec3_t yawangles;
1033                 vec3_t spot;
1034                 VectorSet(yawangles, 0, s->cmd.viewangles[1], 0);
1035                 AngleVectors(yawangles, forward, NULL, NULL);
1036                 VectorMA(s->origin, 24, forward, spot);
1037                 spot[2] += 8;
1038                 if (CL_TracePoint(spot, MOVE_NOMONSTERS, s->self, 0, 0, 0, true, false, NULL, false).startsolid)
1039                 {
1040                         spot[2] += 24;
1041                         if (!CL_TracePoint(spot, MOVE_NOMONSTERS, s->self, 0, 0, 0, true, false, NULL, false).startsolid)
1042                         {
1043                                 VectorScale(forward, 50, s->velocity);
1044                                 s->velocity[2] = 310;
1045                                 s->waterjumptime = 2;
1046                                 s->onground = false;
1047                                 s->cmd.canjump = false;
1048                         }
1049                 }
1050         }
1051
1052         if (!(s->cmd.forwardmove*s->cmd.forwardmove + s->cmd.sidemove*s->cmd.sidemove + s->cmd.upmove*s->cmd.upmove))
1053         {
1054                 // drift towards bottom
1055                 VectorSet(wishvel, 0, 0, -60);
1056         }
1057         else
1058         {
1059                 // swim
1060                 vec3_t forward;
1061                 vec3_t right;
1062                 vec3_t up;
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);
1067         }
1068
1069         // split wishvel into wishspeed and wishdir
1070         VectorCopy(wishvel, wishdir);
1071         wishspeed = VectorNormalizeLength(wishdir);
1072         wishspeed = min(wishspeed, cl.movevars_maxspeed) * 0.7;
1073
1074         if (s->crouched)
1075                 wishspeed *= 0.5;
1076
1077         if (s->waterjumptime <= 0)
1078         {
1079                 // water friction
1080                 f = 1 - s->cmd.frametime * cl.movevars_waterfriction * (cls.protocol == PROTOCOL_QUAKEWORLD ? s->waterlevel : 1);
1081                 f = bound(0, f, 1);
1082                 VectorScale(s->velocity, f, s->velocity);
1083
1084                 // water acceleration
1085                 f = wishspeed - DotProduct(s->velocity, wishdir);
1086                 if (f > 0)
1087                 {
1088                         f = min(cl.movevars_wateraccelerate * s->cmd.frametime * wishspeed, f);
1089                         VectorMA(s->velocity, f, wishdir, s->velocity);
1090                 }
1091
1092                 // holding jump button swims upward slowly
1093                 if (s->cmd.jump)
1094                 {
1095                         if (s->watertype & SUPERCONTENTS_LAVA)
1096                                 s->velocity[2] =  50;
1097                         else if (s->watertype & SUPERCONTENTS_SLIME)
1098                                 s->velocity[2] =  80;
1099                         else
1100                         {
1101                                 if (IS_NEXUIZ_DERIVED(gamemode))
1102                                         s->velocity[2] = 200;
1103                                 else
1104                                         s->velocity[2] = 100;
1105                         }
1106                 }
1107         }
1108
1109         CL_ClientMovement_Move(s);
1110 }
1111
1112 static vec_t CL_IsMoveInDirection(vec_t forward, vec_t side, vec_t angle)
1113 {
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;
1118         if(angle >  1)
1119                 return 0;
1120         if(angle < -1)
1121                 return 0;
1122         return 1 - fabs(angle);
1123 }
1124
1125 static vec_t CL_GeomLerp(vec_t a, vec_t lerp, vec_t b)
1126 {
1127         if(a == 0)
1128         {
1129                 if(lerp < 1)
1130                         return 0;
1131                 else
1132                         return b;
1133         }
1134         if(b == 0)
1135         {
1136                 if(lerp > 0)
1137                         return 0;
1138                 else
1139                         return a;
1140         }
1141         return a * pow(fabs(b / a), lerp);
1142 }
1143
1144 static void CL_ClientMovement_Physics_CPM_PM_Aircontrol(cl_clientmovement_state_t *s, vec3_t wishdir, vec_t wishspeed)
1145 {
1146         vec_t zspeed, speed, dot, k;
1147
1148 #if 0
1149         // this doesn't play well with analog input
1150         if(s->cmd.forwardmove == 0 || s->cmd.sidemove != 0)
1151                 return;
1152         k = 32;
1153 #else
1154         k = 32 * (2 * CL_IsMoveInDirection(s->cmd.forwardmove, s->cmd.sidemove, 0) - 1);
1155         if(k <= 0)
1156                 return;
1157 #endif
1158
1159         k *= bound(0, wishspeed / cl.movevars_maxairspeed, 1);
1160
1161         zspeed = s->velocity[2];
1162         s->velocity[2] = 0;
1163         speed = VectorNormalizeLength(s->velocity);
1164
1165         dot = DotProduct(s->velocity, wishdir);
1166
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);
1173         }
1174
1175         VectorScale(s->velocity, speed, s->velocity);
1176         s->velocity[2] = zspeed;
1177 }
1178
1179 static float CL_ClientMovement_Physics_AdjustAirAccelQW(float accelqw, float factor)
1180 {
1181         return
1182                 (accelqw < 0 ? -1 : +1)
1183                 *
1184                 bound(0.000001, 1 - (1 - fabs(accelqw)) * factor, 1);
1185 }
1186
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)
1188 {
1189         vec_t vel_straight;
1190         vec_t vel_z;
1191         vec3_t vel_perpend;
1192         vec_t step;
1193         vec3_t vel_xy;
1194         vec_t vel_xy_current;
1195         vec_t vel_xy_backward, vel_xy_forward;
1196         vec_t speedclamp;
1197
1198         if(stretchfactor > 0)
1199                 speedclamp = stretchfactor;
1200         else if(accelqw < 0)
1201                 speedclamp = 1;
1202         else
1203                 speedclamp = -1; // no clamping
1204
1205         if(accelqw < 0)
1206                 accelqw = -accelqw;
1207
1208         if(cl.moveflags & MOVEFLAG_Q2AIRACCELERATE)
1209                 wishspeed0 = wishspeed; // don't need to emulate this Q1 bug
1210
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);
1215
1216         step = accel * s->cmd.frametime * wishspeed0;
1217
1218         vel_xy_current  = VectorLength(vel_xy);
1219         if(speedlimit > 0)
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
1225
1226         vel_straight    = vel_straight   + bound(0, wishspeed - vel_straight,   step) * accelqw + step * (1 - accelqw);
1227
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"
1230         {
1231                 vec_t f, fmin;
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);
1234                 // assume: fmin > 1
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
1239                 if(fmin <= 0)
1240                         VectorScale(vel_perpend, f, vel_perpend);
1241                 else
1242                 {
1243                         fmin = sqrt(fmin);
1244                         VectorScale(vel_perpend, max(fmin, f), vel_perpend);
1245                 }
1246         }
1247         else
1248                 VectorScale(vel_perpend, max(0, 1 - s->cmd.frametime * wishspeed * sidefric), vel_perpend);
1249
1250         VectorMA(vel_perpend, vel_straight, wishdir, s->velocity);
1251
1252         if(speedclamp >= 0)
1253         {
1254                 vec_t vel_xy_preclamp;
1255                 vel_xy_preclamp = VectorLength(s->velocity);
1256                 if(vel_xy_preclamp > 0) // prevent division by zero
1257                 {
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);
1261                 }
1262         }
1263
1264         s->velocity[2] += vel_z;
1265 }
1266
1267 static void CL_ClientMovement_Physics_PM_AirAccelerate(cl_clientmovement_state_t *s, vec3_t wishdir, vec_t wishspeed)
1268 {
1269     vec3_t curvel, wishvel, acceldir, curdir;
1270     float addspeed, accelspeed, curspeed;
1271     float dot;
1272
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;
1278
1279     if( !wishspeed )
1280         return;
1281
1282     VectorCopy( s->velocity, curvel );
1283     curvel[2] = 0;
1284     curspeed = VectorLength( curvel );
1285
1286     if( wishspeed > curspeed * 1.01f )
1287     {
1288         float faccelspeed = curspeed + airforwardaccel * cl.movevars_maxairspeed * s->cmd.frametime;
1289         if( faccelspeed < wishspeed )
1290             wishspeed = faccelspeed;
1291     }
1292     else
1293     {
1294         float f = ( bunnytopspeed - curspeed ) / ( bunnytopspeed - cl.movevars_maxairspeed );
1295         if( f < 0 )
1296             f = 0;
1297         wishspeed = max( curspeed, cl.movevars_maxairspeed ) + bunnyaccel * f * cl.movevars_maxairspeed * s->cmd.frametime;
1298     }
1299     VectorScale( wishdir, wishspeed, wishvel );
1300     VectorSubtract( wishvel, curvel, acceldir );
1301     addspeed = VectorNormalizeLength( acceldir );
1302
1303     accelspeed = turnaccel * cl.movevars_maxairspeed /* wishspeed */ * s->cmd.frametime;
1304     if( accelspeed > addspeed )
1305         accelspeed = addspeed;
1306
1307     if( backtosideratio < 1.0f )
1308     {
1309         VectorNormalize2( curvel, curdir );
1310         dot = DotProduct( acceldir, curdir );
1311         if( dot < 0 )
1312             VectorMA( acceldir, -( 1.0f - backtosideratio ) * dot, curdir, acceldir );
1313     }
1314
1315     VectorMA( s->velocity, accelspeed, acceldir, s->velocity );
1316 }
1317
1318 static void CL_ClientMovement_Physics_CheckJump(cl_clientmovement_state_t *s)
1319 {
1320         // jump if on ground with jump button pressed but only if it has been
1321         // released at least once since the last jump
1322         if (s->cmd.jump)
1323         {
1324                 if (s->onground && (s->cmd.canjump || !cl_movement_track_canjump.integer))
1325                 {
1326                         s->velocity[2] += cl.movevars_jumpvelocity;
1327                         s->onground = false;
1328                         s->cmd.canjump = false;
1329                 }
1330         }
1331         else
1332                 s->cmd.canjump = true;
1333 }
1334
1335 static void CL_ClientMovement_Physics_Walk(cl_clientmovement_state_t *s)
1336 {
1337         vec_t friction;
1338         vec_t wishspeed;
1339         vec_t addspeed;
1340         vec_t accelspeed;
1341         vec_t speed;
1342         vec_t gravity;
1343         vec3_t forward;
1344         vec3_t right;
1345         vec3_t up;
1346         vec3_t wishvel;
1347         vec3_t wishdir;
1348         vec3_t yawangles;
1349         trace_t trace;
1350
1351         CL_ClientMovement_Physics_CheckJump(s);
1352
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);
1357
1358         // split wishvel into wishspeed and wishdir
1359         VectorCopy(wishvel, wishdir);
1360         wishspeed = VectorNormalizeLength(wishdir);
1361
1362         // check if onground
1363         if (s->onground)
1364         {
1365                 wishspeed = min(wishspeed, cl.movevars_maxspeed);
1366                 if (s->crouched)
1367                         wishspeed *= 0.5;
1368
1369                 // apply edge friction
1370                 speed = VectorLength2(s->velocity);
1371                 if (speed > 0)
1372                 {
1373                         friction = cl.movevars_friction;
1374                         if (cl.movevars_edgefriction != 1)
1375                         {
1376                                 vec3_t neworigin2;
1377                                 vec3_t neworigin3;
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);
1385                                 else
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;
1389                         }
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);
1394                 }
1395                 addspeed = wishspeed - DotProduct(s->velocity, wishdir);
1396                 if (addspeed > 0)
1397                 {
1398                         accelspeed = min(cl.movevars_accelerate * s->cmd.frametime * wishspeed, addspeed);
1399                         VectorMA(s->velocity, accelspeed, wishdir, s->velocity);
1400                 }
1401                 gravity = cl.movevars_gravity * cl.movevars_entgravity * s->cmd.frametime;
1402                 if(!(cl.moveflags & MOVEFLAG_NOGRAVITYONGROUND))
1403                 {
1404                         if(cl.moveflags & MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE)
1405                                 s->velocity[2] -= gravity * 0.5f;
1406                         else
1407                                 s->velocity[2] -= gravity;
1408                 }
1409                 if (cls.protocol == PROTOCOL_QUAKEWORLD)
1410                         s->velocity[2] = 0;
1411                 if (VectorLength2(s->velocity))
1412                         CL_ClientMovement_Move(s);
1413                 if(!(cl.moveflags & MOVEFLAG_NOGRAVITYONGROUND) || !s->onground)
1414                 {
1415                         if(cl.moveflags & MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE)
1416                                 s->velocity[2] -= gravity * 0.5f;
1417                 }
1418         }
1419         else
1420         {
1421                 if (s->waterjumptime <= 0)
1422                 {
1423                         // apply air speed limit
1424                         vec_t accel, wishspeed0, wishspeed2, accelqw, strafity;
1425                         qbool accelerating;
1426
1427                         accelqw = cl.movevars_airaccel_qw;
1428                         wishspeed0 = wishspeed;
1429                         wishspeed = min(wishspeed, cl.movevars_maxairspeed);
1430                         if (s->crouched)
1431                                 wishspeed *= 0.5;
1432                         accel = cl.movevars_airaccelerate;
1433
1434                         accelerating = (DotProduct(s->velocity, wishdir) > 0);
1435                         wishspeed2 = wishspeed;
1436
1437                         // CPM: air control
1438                         if(cl.movevars_airstopaccelerate != 0)
1439                         {
1440                                 vec3_t curdir;
1441                                 curdir[0] = s->velocity[0];
1442                                 curdir[1] = s->velocity[1];
1443                                 curdir[2] = 0;
1444                                 VectorNormalize(curdir);
1445                                 accel = accel + (cl.movevars_airstopaccelerate - accel) * max(0, -DotProduct(curdir, wishdir));
1446                         }
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)
1453                                 accelqw =
1454                                         (((strafity > 0.5 ? cl.movevars_airstrafeaccel_qw : cl.movevars_airaccel_qw) >= 0) ? +1 : -1)
1455                                         *
1456                                         (1 - CL_GeomLerp(1 - fabs(cl.movevars_airaccel_qw), strafity, 1 - fabs(cl.movevars_airstrafeaccel_qw)));
1457                         // !CPM
1458
1459                         if(cl.movevars_warsowbunny_turnaccel && accelerating && s->cmd.sidemove == 0 && s->cmd.forwardmove != 0)
1460                                 CL_ClientMovement_Physics_PM_AirAccelerate(s, wishdir, wishspeed2);
1461                         else
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);
1463
1464                         if(cl.movevars_aircontrol)
1465                                 CL_ClientMovement_Physics_CPM_PM_Aircontrol(s, wishdir, wishspeed2);
1466                 }
1467                 gravity = cl.movevars_gravity * cl.movevars_entgravity * s->cmd.frametime;
1468                 if(cl.moveflags & MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE)
1469                         s->velocity[2] -= gravity * 0.5f;
1470                 else
1471                         s->velocity[2] -= gravity;
1472                 CL_ClientMovement_Move(s);
1473                 if(!(cl.moveflags & MOVEFLAG_NOGRAVITYONGROUND) || !s->onground)
1474                 {
1475                         if(cl.moveflags & MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE)
1476                                 s->velocity[2] -= gravity * 0.5f;
1477                 }
1478         }
1479 }
1480
1481 static void CL_ClientMovement_PlayerMove(cl_clientmovement_state_t *s)
1482 {
1483         //Con_Printf(" %f", frametime);
1484         if (!s->cmd.jump)
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);
1490         else
1491                 CL_ClientMovement_Physics_Walk(s);
1492 }
1493
1494 extern cvar_t host_timescale;
1495 void CL_UpdateMoveVars(void)
1496 {
1497         if (cls.protocol == PROTOCOL_QUAKEWORLD)
1498         {
1499                 cl.moveflags = 0;
1500         }
1501         else if (cl.stats[STAT_MOVEVARS_TICRATE])
1502         {
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];
1537         }
1538         else
1539         {
1540                 cl.moveflags = 0;
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;
1574         }
1575
1576         if(!(cl.moveflags & MOVEFLAG_VALID))
1577         {
1578                 if(gamemode == GAME_NEXUIZ)  // Legacy hack to work with old servers of Nexuiz.
1579                         cl.moveflags = MOVEFLAG_Q2AIRACCELERATE;
1580         }
1581
1582         if(cl.movevars_aircontrol_power <= 0)
1583                 cl.movevars_aircontrol_power = 2; // CPMA default
1584 }
1585
1586 void CL_ClientMovement_PlayerMove_Frame(cl_clientmovement_state_t *s)
1587 {
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)
1591         {
1592                 if (s->cmd.frametime > 0.05)
1593                 {
1594                         s->cmd.frametime /= 2;
1595                         CL_ClientMovement_PlayerMove(s);
1596                 }
1597                 CL_ClientMovement_PlayerMove(s);
1598         }
1599         else
1600         {
1601                 // we REALLY need this handling to happen, even if the move is not executed
1602                 if (!s->cmd.jump)
1603                         s->cmd.canjump = true;
1604         }
1605 }
1606
1607 void CL_ClientMovement_Replay(void)
1608 {
1609         int i;
1610         double totalmovemsec;
1611         cl_clientmovement_state_t s;
1612
1613         VectorCopy(cl.mvelocity[0], cl.movement_velocity);
1614
1615         if (cl.movement_predicted && !cl.movement_replay)
1616                 return;
1617
1618         if (!cl_movement_replay.integer)
1619                 return;
1620
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]);
1627
1628         totalmovemsec = 0;
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)
1635         {
1636                 //Con_Printf("%ims\n", cl.movecmd[0].msec);
1637
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
1640
1641                 // find how many are still valid
1642                 for (i = 0;i < CL_MAX_USERCMDS;i++)
1643                         if (cl.movecmd[i].sequence <= cls.servermovesequence)
1644                                 break;
1645                 // now walk them in oldest to newest order
1646                 for (i--;i >= 0;i--)
1647                 {
1648                         s.cmd = cl.movecmd[i];
1649                         if (i < CL_MAX_USERCMDS - 1)
1650                                 s.cmd.canjump = cl.movecmd[i+1].canjump;
1651
1652                         CL_ClientMovement_PlayerMove_Frame(&s);
1653
1654                         cl.movecmd[i].canjump = s.cmd.canjump;
1655                 }
1656                 //Con_Printf("\n");
1657                 CL_ClientMovement_UpdateStatus(&s);
1658         }
1659         else
1660         {
1661                 // get the first movement queue entry to know whether to crouch and such
1662                 s.cmd = cl.movecmd[0];
1663         }
1664
1665         if (!cls.demoplayback) // for bob, speedometer
1666         {
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);
1671         }
1672
1673         // update the onground flag if appropriate
1674         if (cl.movement_predicted)
1675         {
1676                 // when predicted we simply set the flag according to the UpdateStatus
1677                 cl.onground = s.onground;
1678         }
1679         else
1680         {
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)
1687                 //
1688                 // such onground inconsistencies can cause jittery gun bobbing and
1689                 // stair smoothing, so we set onground if UpdateStatus says so
1690                 if (s.onground)
1691                         cl.onground = true;
1692         }
1693 }
1694
1695 static void QW_MSG_WriteDeltaUsercmd(sizebuf_t *buf, usercmd_t *from, usercmd_t *to)
1696 {
1697         int bits;
1698
1699         bits = 0;
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)
1709                 bits |= QW_CM_SIDE;
1710         if (to->upmove != from->upmove)
1711                 bits |= QW_CM_UP;
1712         if (to->buttons != from->buttons)
1713                 bits |= QW_CM_BUTTONS;
1714         if (to->impulse != from->impulse)
1715                 bits |= QW_CM_IMPULSE;
1716
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);
1735 }
1736
1737 void CL_NewFrameReceived(int num)
1738 {
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;
1744 }
1745
1746 void CL_RotateMoves(const matrix4x4_t *m)
1747 {
1748         // rotate viewangles in all previous moves
1749         vec3_t v;
1750         vec3_t f, r, u;
1751         int i;
1752         for (i = 0;i < CL_MAX_USERCMDS;i++)
1753         {
1754                 if (cl.movecmd[i].sequence > cls.servermovesequence)
1755                 {
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);
1761                 }
1762         }
1763 }
1764
1765 /*
1766 ==============
1767 CL_SendMove
1768 ==============
1769 */
1770 usercmd_t nullcmd; // for delta compression of qw moves
1771 void CL_SendMove(void)
1772 {
1773         int i, j, packetloss;
1774         int checksumindex;
1775         int bits;
1776         int maxusercmds;
1777         usercmd_t *cmd;
1778         sizebuf_t buf;
1779         unsigned char data[1024];
1780         float packettime, sv_frametime, lag, frames_per_tic;
1781         qbool opportune_moment;
1782         qbool quemove;
1783         qbool important;
1784
1785         // if playing a demo, do nothing
1786         if (!cls.netcon)
1787                 return;
1788
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;
1791
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;
1797
1798         // set button bits
1799         // LadyHavoc: added 6 new buttons and use and chat buttons, and prydon cursor active button
1800         bits = 0;
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)
1823         {
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;
1828         }
1829
1830         // set buttons and impulse
1831         cl.cmd.buttons = bits;
1832         cl.cmd.impulse = in_impulse;
1833
1834         // set viewangles
1835         VectorCopy(cl.viewangles, cl.cmd.viewangles);
1836
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);
1845
1846         switch(cls.protocol)
1847         {
1848         case PROTOCOL_QUAKEWORLD:
1849                 // quakeworld uses a different cvar with opposite meaning, for compatibility
1850                 cl.cmd.predicted = cl_nopred.integer == 0;
1851                 break;
1852         case PROTOCOL_DARKPLACES6:
1853         case PROTOCOL_DARKPLACES7:
1854         case PROTOCOL_DARKPLACES8:
1855                 cl.cmd.predicted = cl_movement.integer != 0;
1856                 break;
1857         default:
1858                 cl.cmd.predicted = false;
1859                 break;
1860         }
1861
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;
1866
1867         cl.cmd.jump = (cl.cmd.buttons & 2) != 0;
1868         cl.cmd.crouch = 0;
1869         switch (cls.protocol)
1870         {
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:
1883                 break;
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;
1889                 break;
1890         case PROTOCOL_UNKNOWN:
1891                 break;
1892         }
1893
1894         if (quemove)
1895                 cl.movecmd[0] = cl.cmd;
1896
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.
1900          */
1901         cl.timesincepacket += cl.realframetime;
1902
1903         // don't predict more than 256fps
1904         if (cl.timesincepacket >= 1/256)
1905                 cl.movement_replay = true; // redo the prediction
1906
1907         // now decide whether to actually send this move
1908         // (otherwise it is only for prediction)
1909
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))
1912                 return;
1913
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)
1918         {
1919                 packettime = bound(cl.movevars_ticrate * 0.5f, packettime, cl.movevars_ticrate);
1920                 sv_frametime = cl.movevars_ticrate;
1921         }
1922         else // fallback, may be affected by server->client network problems
1923                 sv_frametime = (cl.mtime[0] - cl.mtime[1]) / cl.movevars_timescale;
1924
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));
1928
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
1934
1935         // Two methods for deciding when to send
1936         if (!important)
1937         {
1938                 // Traditional time interval, now used as fallback
1939                 if (sv_frametime <= 0 || lag > sv_frametime || lag < 0) // unknown ticrate || lag/PL || still connecting
1940                 {
1941                         if (cl.timesincepacket < packettime * 0.99999f)
1942                         {
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);
1944                                 return;
1945                         }
1946                 }
1947                 // Server-synchronised, for better pings
1948                 // Sends at least once per server frame
1949                 else // cl.opt_inputs_since_update is usable
1950                 {
1951                         if (!opportune_moment || cl.opt_inputs_since_update >= sv_frametime / packettime)
1952                         {
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);
1954                                 return;
1955                         }
1956                 }
1957         }
1958
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)
1965                 return;
1966
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);
1968
1969         if (opportune_moment) // this check is needed for optimal timing especially with cl_netimmediatebuttons
1970                 ++cl.opt_inputs_since_update;
1971
1972         // reset the packet timing accumulator
1973         cl.timesincepacket = 0;
1974
1975         buf.maxsize = sizeof(data);
1976         buf.cursize = 0;
1977         buf.data = data;
1978
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)
1992
1993         // set prydon cursor info
1994         CL_UpdatePrydonCursor();
1995
1996         if (cls.protocol == PROTOCOL_QUAKEWORLD || cls.signon == SIGNONS)
1997         {
1998                 switch (cls.protocol)
1999                 {
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)
2008                                         packetloss++;
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)
2022                         {
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);
2026                         }
2027                         else
2028                                 cl.qw_deltasequence[cls.netcon->outgoing_unreliable_sequence & QW_UPDATE_MASK] = -1;
2029                         break;
2030                 case PROTOCOL_QUAKE:
2031                 case PROTOCOL_QUAKEDP:
2032                 case PROTOCOL_NEHAHRAMOVIE:
2033                 case PROTOCOL_NEHAHRABJP:
2034                 case PROTOCOL_NEHAHRABJP2:
2035                 case PROTOCOL_NEHAHRABJP3:
2036                         // 5 bytes
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
2041                         {
2042                                 for (i = 0;i < 3;i++)
2043                                         MSG_WriteAngle16i (&buf, cl.cmd.viewangles[i]);
2044                         }
2045                         else
2046                         {
2047                                 for (i = 0;i < 3;i++)
2048                                         MSG_WriteAngle8i (&buf, cl.cmd.viewangles[i]);
2049                         }
2050                         // 6 bytes
2051                         MSG_WriteCoord16i (&buf, cl.cmd.forwardmove);
2052                         MSG_WriteCoord16i (&buf, cl.cmd.sidemove);
2053                         MSG_WriteCoord16i (&buf, cl.cmd.upmove);
2054                         // 2 bytes
2055                         MSG_WriteByte (&buf, cl.cmd.buttons);
2056                         MSG_WriteByte (&buf, cl.cmd.impulse);
2057                         break;
2058                 case PROTOCOL_DARKPLACES2:
2059                 case PROTOCOL_DARKPLACES3:
2060                         // 5 bytes
2061                         MSG_WriteByte (&buf, clc_move);
2062                         MSG_WriteFloat (&buf, cl.cmd.time); // last server packet time
2063                         // 12 bytes
2064                         for (i = 0;i < 3;i++)
2065                                 MSG_WriteAngle32f (&buf, cl.cmd.viewangles[i]);
2066                         // 6 bytes
2067                         MSG_WriteCoord16i (&buf, cl.cmd.forwardmove);
2068                         MSG_WriteCoord16i (&buf, cl.cmd.sidemove);
2069                         MSG_WriteCoord16i (&buf, cl.cmd.upmove);
2070                         // 2 bytes
2071                         MSG_WriteByte (&buf, cl.cmd.buttons);
2072                         MSG_WriteByte (&buf, cl.cmd.impulse);
2073                         break;
2074                 case PROTOCOL_DARKPLACES1:
2075                 case PROTOCOL_DARKPLACES4:
2076                 case PROTOCOL_DARKPLACES5:
2077                         // 5 bytes
2078                         MSG_WriteByte (&buf, clc_move);
2079                         MSG_WriteFloat (&buf, cl.cmd.time); // last server packet time
2080                         // 6 bytes
2081                         for (i = 0;i < 3;i++)
2082                                 MSG_WriteAngle16i (&buf, cl.cmd.viewangles[i]);
2083                         // 6 bytes
2084                         MSG_WriteCoord16i (&buf, cl.cmd.forwardmove);
2085                         MSG_WriteCoord16i (&buf, cl.cmd.sidemove);
2086                         MSG_WriteCoord16i (&buf, cl.cmd.upmove);
2087                         // 2 bytes
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)
2097                                 maxusercmds = 1;
2098
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
2102                         //
2103                         // this reduces packet loss impact on gameplay.
2104                         for (j = 0, cmd = &cl.movecmd[maxusercmds-1];j < maxusercmds;j++, cmd--)
2105                         {
2106                                 // don't repeat any stale moves
2107                                 if (cmd->sequence && cmd->sequence < cls.servermovesequence)
2108                                         continue;
2109                                 // 5/9 bytes
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
2114                                 // 6 bytes
2115                                 for (i = 0;i < 3;i++)
2116                                         MSG_WriteAngle16i (&buf, cmd->viewangles[i]);
2117                                 // 6 bytes
2118                                 MSG_WriteCoord16i (&buf, cmd->forwardmove);
2119                                 MSG_WriteCoord16i (&buf, cmd->sidemove);
2120                                 MSG_WriteCoord16i (&buf, cmd->upmove);
2121                                 // 5 bytes
2122                                 MSG_WriteLong (&buf, cmd->buttons);
2123                                 MSG_WriteByte (&buf, cmd->impulse);
2124                                 // PRYDON_CLIENTCURSOR
2125                                 // 30 bytes
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);
2135                         }
2136                         break;
2137                 case PROTOCOL_UNKNOWN:
2138                         break;
2139                 }
2140         }
2141
2142         if (cls.protocol != PROTOCOL_QUAKEWORLD && buf.cursize)
2143         {
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
2148                 // will be more...
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;
2153                 else
2154                         oldsequence = 1;
2155                 for (i = 0;i < LATESTFRAMENUMS;i++)
2156                 {
2157                         j = (cl.latestframenumsposition + i) % LATESTFRAMENUMS;
2158                         if (cl.latestsendnums[j] >= oldsequence)
2159                         {
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]);
2164                         }
2165                 }
2166         }
2167
2168         // PROTOCOL_DARKPLACES6 = 67 bytes per packet
2169         // PROTOCOL_DARKPLACES7 = 71 bytes per packet
2170
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++)
2173         {
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;
2179         }
2180
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);
2184
2185         if (quemove)
2186         {
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;
2193         }
2194
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;
2204         in_use.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;
2213         // clear impulse
2214         in_impulse = 0;
2215
2216         if (cls.netcon->message.overflowed)
2217                 CL_DisconnectEx(true, "Lost connection to server");
2218 }
2219
2220 /*
2221 ============
2222 CL_InitInput
2223 ============
2224 */
2225 void CL_InitInput (void)
2226 {
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");
2260
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");
2292
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");
2296
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);
2318
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);
2333
2334         Cvar_RegisterVariable(&cl_netfps);
2335         Cvar_RegisterVariable(&cl_netrepeatinput);
2336         Cvar_RegisterVariable(&cl_netimmediatebuttons);
2337
2338         Cvar_RegisterVariable(&cl_nodelta);
2339
2340         Cvar_RegisterVariable(&cl_csqc_generatemousemoveevents);
2341 }
2342