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         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 (cl.csqc_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.width, in_windowmouse_y * vid_conheight.value / vid.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.width - 1.0;
 708                 cl.cmd.cursor_screen[1] = in_windowmouse_y * 2.0 / vid.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 = (cls.demoplayback ? 1.0f : host_timescale.value) / bound(10.0f, cl_netfps.value, 1000.0f);
1542                 cl.movevars_timescale = (cls.demoplayback ? 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;
1781         qbool quemove;
1782         qbool important;
1783
1784         // if playing a demo, do nothing
1785         if (!cls.netcon)
1786                 return;
1787
1788         // we don't que moves during a lag spike (potential network timeout)
1789         quemove = host.realtime - cl.last_received_message < cl_movement_nettimeout.value;
1790
1791         // we build up cl.cmd and then decide whether to send or not
1792         // we store this into cl.movecmd[0] for prediction each frame even if we
1793         // do not send, to make sure that prediction is instant
1794         cl.cmd.time = cl.time;
1795         cl.cmd.sequence = cls.netcon->outgoing_unreliable_sequence;
1796
1797         // set button bits
1798         // LadyHavoc: added 6 new buttons and use and chat buttons, and prydon cursor active button
1799         bits = 0;
1800         if (in_attack.state   & 3) bits |=   1;
1801         if (in_jump.state     & 3) bits |=   2;
1802         if (in_button3.state  & 3) bits |=   4;
1803         if (in_button4.state  & 3) bits |=   8;
1804         if (in_button5.state  & 3) bits |=  16;
1805         if (in_button6.state  & 3) bits |=  32;
1806         if (in_button7.state  & 3) bits |=  64;
1807         if (in_button8.state  & 3) bits |= 128;
1808         if (in_use.state      & 3) bits |= 256;
1809         if (key_dest != key_game || key_consoleactive) bits |= 512;
1810         if (cl_prydoncursor.integer > 0) bits |= 1024;
1811         if (in_button9.state  & 3)  bits |=   2048;
1812         if (in_button10.state  & 3) bits |=   4096;
1813         if (in_button11.state  & 3) bits |=   8192;
1814         if (in_button12.state  & 3) bits |=  16384;
1815         if (in_button13.state  & 3) bits |=  32768;
1816         if (in_button14.state  & 3) bits |=  65536;
1817         if (in_button15.state  & 3) bits |= 131072;
1818         if (in_button16.state  & 3) bits |= 262144;
1819         // button bits 19-31 unused currently
1820         // rotate/zoom view serverside if PRYDON_CLIENTCURSOR cursor is at edge of screen
1821         if(cl_prydoncursor.integer > 0)
1822         {
1823                 if (cl.cmd.cursor_screen[0] <= -1) bits |= 8;
1824                 if (cl.cmd.cursor_screen[0] >=  1) bits |= 16;
1825                 if (cl.cmd.cursor_screen[1] <= -1) bits |= 32;
1826                 if (cl.cmd.cursor_screen[1] >=  1) bits |= 64;
1827         }
1828
1829         // set buttons and impulse
1830         cl.cmd.buttons = bits;
1831         cl.cmd.impulse = in_impulse;
1832
1833         // set viewangles
1834         VectorCopy(cl.viewangles, cl.cmd.viewangles);
1835
1836         // bones_was_here: previously cl.cmd.frametime was floored to nearest millisec
1837         // this meant the smoothest async movement required integer millisec
1838         // client and server frame times (eg 125fps)
1839         cl.cmd.frametime = bound(0.0, cl.cmd.time - cl.movecmd[1].time, 0.255);
1840         // ridiculous value rejection (matches qw)
1841         if (cl.cmd.frametime > 0.25)
1842                 cl.cmd.frametime = 0.1;
1843         cl.cmd.msec = (unsigned char)floor(cl.cmd.frametime * 1000);
1844
1845         switch(cls.protocol)
1846         {
1847         case PROTOCOL_QUAKEWORLD:
1848                 // quakeworld uses a different cvar with opposite meaning, for compatibility
1849                 cl.cmd.predicted = cl_nopred.integer == 0;
1850                 break;
1851         case PROTOCOL_DARKPLACES6:
1852         case PROTOCOL_DARKPLACES7:
1853         case PROTOCOL_DARKPLACES8:
1854                 cl.cmd.predicted = cl_movement.integer != 0;
1855                 break;
1856         default:
1857                 cl.cmd.predicted = false;
1858                 break;
1859         }
1860
1861         // movement is set by input code (forwardmove/sidemove/upmove)
1862         // always dump the first two moves, because they may contain leftover inputs from the last level
1863         if (cl.cmd.sequence <= 2)
1864                 cl.cmd.forwardmove = cl.cmd.sidemove = cl.cmd.upmove = cl.cmd.impulse = cl.cmd.buttons = 0;
1865
1866         cl.cmd.jump = (cl.cmd.buttons & 2) != 0;
1867         cl.cmd.crouch = 0;
1868         switch (cls.protocol)
1869         {
1870         case PROTOCOL_QUAKEWORLD:
1871         case PROTOCOL_QUAKE:
1872         case PROTOCOL_QUAKEDP:
1873         case PROTOCOL_NEHAHRAMOVIE:
1874         case PROTOCOL_NEHAHRABJP:
1875         case PROTOCOL_NEHAHRABJP2:
1876         case PROTOCOL_NEHAHRABJP3:
1877         case PROTOCOL_DARKPLACES1:
1878         case PROTOCOL_DARKPLACES2:
1879         case PROTOCOL_DARKPLACES3:
1880         case PROTOCOL_DARKPLACES4:
1881         case PROTOCOL_DARKPLACES5:
1882                 break;
1883         case PROTOCOL_DARKPLACES6:
1884         case PROTOCOL_DARKPLACES7:
1885         case PROTOCOL_DARKPLACES8:
1886                 // FIXME: cl.cmd.buttons & 16 is +button5, Nexuiz/Xonotic specific
1887                 cl.cmd.crouch = (cl.cmd.buttons & 16) != 0;
1888                 break;
1889         case PROTOCOL_UNKNOWN:
1890                 break;
1891         }
1892
1893         if (quemove)
1894                 cl.movecmd[0] = cl.cmd;
1895
1896         // don't predict more than 200fps
1897         if (cl.timesincepacket >= 0.005)
1898                 cl.movement_replay = true; // redo the prediction
1899
1900         // now decide whether to actually send this move
1901         // (otherwise it is only for prediction)
1902
1903         // do not send 0ms packets because they mess up physics
1904         if(cl.cmd.msec == 0 && cl.time > cl.oldtime && (cls.protocol == PROTOCOL_QUAKEWORLD || cls.signon == SIGNONS))
1905                 return;
1906
1907         // don't send too often or else network connections can get clogged by a
1908         // high renderer framerate
1909         packettime = 1.0f / bound(10.0f, cl_netfps.value, 1000.0f);
1910         if (cl.movevars_timescale && cl.movevars_ticrate)
1911         {
1912                 // try to ensure at least 1 packet per server frame
1913                 // and apply soft limit of 2, hard limit < 4 (packettime reduced further below)
1914                 float maxtic = cl.movevars_ticrate / cl.movevars_timescale;
1915                 packettime = bound(maxtic * 0.5f, packettime, maxtic);
1916         }
1917         // bones_was_here: reduce packettime to (largest multiple of realframetime) <= packettime
1918         // prevents packet rates lower than cl_netfps or server frame rate
1919         // eg: cl_netfps 60 and cl_maxfps 250 would otherwise send only 50 netfps
1920         // with this line that config sends 62.5 netfps
1921         // (this causes it to emit packets at a steady beat)
1922         packettime = floor(packettime / (float)cl.realframetime) * (float)cl.realframetime;
1923
1924         // always send if buttons changed or an impulse is pending
1925         // even if it violates the rate limit!
1926         important = (cl.cmd.impulse || (cl_netimmediatebuttons.integer && cl.cmd.buttons != cl.movecmd[1].buttons));
1927
1928         // don't send too often (cl_netfps), allowing a small margin for float error
1929         // bones_was_here: accumulate realframetime to prevent low packet rates
1930         // previously with cl_maxfps == cl_netfps it did not send every frame as
1931         // host.realtime - cl.lastpackettime was often well below (or above) packettime
1932         if (!important && cl.timesincepacket < packettime * 0.99999f)
1933         {
1934                 cl.timesincepacket += cl.realframetime;
1935                 return;
1936         }
1937
1938         // don't choke the connection with packets (obey rate limit)
1939         // it is important that this check be last, because it adds a new
1940         // frame to the shownetgraph output and any cancelation after this
1941         // will produce a nasty spike-like look to the netgraph
1942         // we also still send if it is important
1943         if (!NetConn_CanSend(cls.netcon) && !important)
1944                 return;
1945
1946         // reset the packet timing accumulator
1947         cl.timesincepacket = cl.realframetime;
1948
1949         buf.maxsize = sizeof(data);
1950         buf.cursize = 0;
1951         buf.data = data;
1952
1953         // send the movement message
1954         // PROTOCOL_QUAKE        clc_move = 16 bytes total
1955         // PROTOCOL_QUAKEDP      clc_move = 16 bytes total
1956         // PROTOCOL_NEHAHRAMOVIE clc_move = 16 bytes total
1957         // PROTOCOL_DARKPLACES1  clc_move = 19 bytes total
1958         // PROTOCOL_DARKPLACES2  clc_move = 25 bytes total
1959         // PROTOCOL_DARKPLACES3  clc_move = 25 bytes total
1960         // PROTOCOL_DARKPLACES4  clc_move = 19 bytes total
1961         // PROTOCOL_DARKPLACES5  clc_move = 19 bytes total
1962         // PROTOCOL_DARKPLACES6  clc_move = 52 bytes total
1963         // PROTOCOL_DARKPLACES7  clc_move = 56 bytes total per move (can be up to 16 moves)
1964         // PROTOCOL_DARKPLACES8  clc_move = 56 bytes total per move (can be up to 16 moves)
1965         // PROTOCOL_QUAKEWORLD   clc_move = 34 bytes total (typically, but can reach 43 bytes, or even 49 bytes with roll)
1966
1967         // set prydon cursor info
1968         CL_UpdatePrydonCursor();
1969
1970         if (cls.protocol == PROTOCOL_QUAKEWORLD || cls.signon == SIGNONS)
1971         {
1972                 switch (cls.protocol)
1973                 {
1974                 case PROTOCOL_QUAKEWORLD:
1975                         MSG_WriteByte(&buf, qw_clc_move);
1976                         // save the position for a checksum byte
1977                         checksumindex = buf.cursize;
1978                         MSG_WriteByte(&buf, 0);
1979                         // packet loss percentage
1980                         for (j = 0, packetloss = 0;j < NETGRAPH_PACKETS;j++)
1981                                 if (cls.netcon->incoming_netgraph[j].unreliablebytes == NETGRAPH_LOSTPACKET)
1982                                         packetloss++;
1983                         packetloss = packetloss * 100 / NETGRAPH_PACKETS;
1984                         MSG_WriteByte(&buf, packetloss);
1985                         // write most recent 3 moves
1986                         QW_MSG_WriteDeltaUsercmd(&buf, &nullcmd, &cl.movecmd[2]);
1987                         QW_MSG_WriteDeltaUsercmd(&buf, &cl.movecmd[2], &cl.movecmd[1]);
1988                         QW_MSG_WriteDeltaUsercmd(&buf, &cl.movecmd[1], &cl.cmd);
1989                         // calculate the checksum
1990                         buf.data[checksumindex] = COM_BlockSequenceCRCByteQW(buf.data + checksumindex + 1, buf.cursize - checksumindex - 1, cls.netcon->outgoing_unreliable_sequence);
1991                         // if delta compression history overflows, request no delta
1992                         if (cls.netcon->outgoing_unreliable_sequence - cl.qw_validsequence >= QW_UPDATE_BACKUP-1)
1993                                 cl.qw_validsequence = 0;
1994                         // request delta compression if appropriate
1995                         if (cl.qw_validsequence && !cl_nodelta.integer && cls.state == ca_connected && !cls.demorecording)
1996                         {
1997                                 cl.qw_deltasequence[cls.netcon->outgoing_unreliable_sequence & QW_UPDATE_MASK] = cl.qw_validsequence;
1998                                 MSG_WriteByte(&buf, qw_clc_delta);
1999                                 MSG_WriteByte(&buf, cl.qw_validsequence & 255);
2000                         }
2001                         else
2002                                 cl.qw_deltasequence[cls.netcon->outgoing_unreliable_sequence & QW_UPDATE_MASK] = -1;
2003                         break;
2004                 case PROTOCOL_QUAKE:
2005                 case PROTOCOL_QUAKEDP:
2006                 case PROTOCOL_NEHAHRAMOVIE:
2007                 case PROTOCOL_NEHAHRABJP:
2008                 case PROTOCOL_NEHAHRABJP2:
2009                 case PROTOCOL_NEHAHRABJP3:
2010                         // 5 bytes
2011                         MSG_WriteByte (&buf, clc_move);
2012                         MSG_WriteFloat (&buf, cl.cmd.time); // last server packet time
2013                         // 3 bytes (6 bytes in proquake)
2014                         if (cls.proquake_servermod == 1) // MOD_PROQUAKE
2015                         {
2016                                 for (i = 0;i < 3;i++)
2017                                         MSG_WriteAngle16i (&buf, cl.cmd.viewangles[i]);
2018                         }
2019                         else
2020                         {
2021                                 for (i = 0;i < 3;i++)
2022                                         MSG_WriteAngle8i (&buf, cl.cmd.viewangles[i]);
2023                         }
2024                         // 6 bytes
2025                         MSG_WriteCoord16i (&buf, cl.cmd.forwardmove);
2026                         MSG_WriteCoord16i (&buf, cl.cmd.sidemove);
2027                         MSG_WriteCoord16i (&buf, cl.cmd.upmove);
2028                         // 2 bytes
2029                         MSG_WriteByte (&buf, cl.cmd.buttons);
2030                         MSG_WriteByte (&buf, cl.cmd.impulse);
2031                         break;
2032                 case PROTOCOL_DARKPLACES2:
2033                 case PROTOCOL_DARKPLACES3:
2034                         // 5 bytes
2035                         MSG_WriteByte (&buf, clc_move);
2036                         MSG_WriteFloat (&buf, cl.cmd.time); // last server packet time
2037                         // 12 bytes
2038                         for (i = 0;i < 3;i++)
2039                                 MSG_WriteAngle32f (&buf, cl.cmd.viewangles[i]);
2040                         // 6 bytes
2041                         MSG_WriteCoord16i (&buf, cl.cmd.forwardmove);
2042                         MSG_WriteCoord16i (&buf, cl.cmd.sidemove);
2043                         MSG_WriteCoord16i (&buf, cl.cmd.upmove);
2044                         // 2 bytes
2045                         MSG_WriteByte (&buf, cl.cmd.buttons);
2046                         MSG_WriteByte (&buf, cl.cmd.impulse);
2047                         break;
2048                 case PROTOCOL_DARKPLACES1:
2049                 case PROTOCOL_DARKPLACES4:
2050                 case PROTOCOL_DARKPLACES5:
2051                         // 5 bytes
2052                         MSG_WriteByte (&buf, clc_move);
2053                         MSG_WriteFloat (&buf, cl.cmd.time); // last server packet time
2054                         // 6 bytes
2055                         for (i = 0;i < 3;i++)
2056                                 MSG_WriteAngle16i (&buf, cl.cmd.viewangles[i]);
2057                         // 6 bytes
2058                         MSG_WriteCoord16i (&buf, cl.cmd.forwardmove);
2059                         MSG_WriteCoord16i (&buf, cl.cmd.sidemove);
2060                         MSG_WriteCoord16i (&buf, cl.cmd.upmove);
2061                         // 2 bytes
2062                         MSG_WriteByte (&buf, cl.cmd.buttons);
2063                         MSG_WriteByte (&buf, cl.cmd.impulse);
2064                 case PROTOCOL_DARKPLACES6:
2065                 case PROTOCOL_DARKPLACES7:
2066                 case PROTOCOL_DARKPLACES8:
2067                         // set the maxusercmds variable to limit how many should be sent
2068                         maxusercmds = bound(1, cl_netrepeatinput.integer + 1, min(3, CL_MAX_USERCMDS));
2069                         // when movement prediction is off, there's not much point in repeating old input as it will just be ignored
2070                         if (!cl.cmd.predicted)
2071                                 maxusercmds = 1;
2072
2073                         // send the latest moves in order, the old ones will be
2074                         // ignored by the server harmlessly, however if the previous
2075                         // packets were lost these moves will be used
2076                         //
2077                         // this reduces packet loss impact on gameplay.
2078                         for (j = 0, cmd = &cl.movecmd[maxusercmds-1];j < maxusercmds;j++, cmd--)
2079                         {
2080                                 // don't repeat any stale moves
2081                                 if (cmd->sequence && cmd->sequence < cls.servermovesequence)
2082                                         continue;
2083                                 // 5/9 bytes
2084                                 MSG_WriteByte (&buf, clc_move);
2085                                 if (cls.protocol != PROTOCOL_DARKPLACES6)
2086                                         MSG_WriteLong (&buf, cmd->predicted ? cmd->sequence : 0);
2087                                 MSG_WriteFloat (&buf, cmd->time); // last server packet time
2088                                 // 6 bytes
2089                                 for (i = 0;i < 3;i++)
2090                                         MSG_WriteAngle16i (&buf, cmd->viewangles[i]);
2091                                 // 6 bytes
2092                                 MSG_WriteCoord16i (&buf, cmd->forwardmove);
2093                                 MSG_WriteCoord16i (&buf, cmd->sidemove);
2094                                 MSG_WriteCoord16i (&buf, cmd->upmove);
2095                                 // 5 bytes
2096                                 MSG_WriteLong (&buf, cmd->buttons);
2097                                 MSG_WriteByte (&buf, cmd->impulse);
2098                                 // PRYDON_CLIENTCURSOR
2099                                 // 30 bytes
2100                                 MSG_WriteShort (&buf, (short)(cmd->cursor_screen[0] * 32767.0f));
2101                                 MSG_WriteShort (&buf, (short)(cmd->cursor_screen[1] * 32767.0f));
2102                                 MSG_WriteFloat (&buf, cmd->cursor_start[0]);
2103                                 MSG_WriteFloat (&buf, cmd->cursor_start[1]);
2104                                 MSG_WriteFloat (&buf, cmd->cursor_start[2]);
2105                                 MSG_WriteFloat (&buf, cmd->cursor_impact[0]);
2106                                 MSG_WriteFloat (&buf, cmd->cursor_impact[1]);
2107                                 MSG_WriteFloat (&buf, cmd->cursor_impact[2]);
2108                                 MSG_WriteShort (&buf, cmd->cursor_entitynumber);
2109                         }
2110                         break;
2111                 case PROTOCOL_UNKNOWN:
2112                         break;
2113                 }
2114         }
2115
2116         if (cls.protocol != PROTOCOL_QUAKEWORLD && buf.cursize)
2117         {
2118                 // ack entity frame numbers received since the last input was sent
2119                 // (redundent to improve handling of client->server packet loss)
2120                 // if cl_netrepeatinput is 1 and client framerate matches server
2121                 // framerate, this is 10 bytes, if client framerate is lower this
2122                 // will be more...
2123                 unsigned int oldsequence = cl.cmd.sequence;
2124                 unsigned int delta = bound(1, cl_netrepeatinput.integer + 1, 3);
2125                 if (oldsequence > delta)
2126                         oldsequence = oldsequence - delta;
2127                 else
2128                         oldsequence = 1;
2129                 for (i = 0;i < LATESTFRAMENUMS;i++)
2130                 {
2131                         j = (cl.latestframenumsposition + i) % LATESTFRAMENUMS;
2132                         if (cl.latestsendnums[j] >= oldsequence)
2133                         {
2134                                 if (developer_networkentities.integer >= 10)
2135                                         Con_Printf("send clc_ackframe %i\n", cl.latestframenums[j]);
2136                                 MSG_WriteByte(&buf, clc_ackframe);
2137                                 MSG_WriteLong(&buf, cl.latestframenums[j]);
2138                         }
2139                 }
2140         }
2141
2142         // PROTOCOL_DARKPLACES6 = 67 bytes per packet
2143         // PROTOCOL_DARKPLACES7 = 71 bytes per packet
2144
2145         // acknowledge any recently received data blocks
2146         for (i = 0;i < CL_MAX_DOWNLOADACKS && (cls.dp_downloadack[i].start || cls.dp_downloadack[i].size);i++)
2147         {
2148                 MSG_WriteByte(&buf, clc_ackdownloaddata);
2149                 MSG_WriteLong(&buf, cls.dp_downloadack[i].start);
2150                 MSG_WriteShort(&buf, cls.dp_downloadack[i].size);
2151                 cls.dp_downloadack[i].start = 0;
2152                 cls.dp_downloadack[i].size = 0;
2153         }
2154
2155         // send the reliable message (forwarded commands) if there is one
2156         if (buf.cursize || cls.netcon->message.cursize)
2157                 NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol, max(20*(buf.cursize+40), cl_rate.integer), cl_rate_burstsize.integer, false);
2158
2159         if (quemove)
2160         {
2161                 // update the cl.movecmd array which holds the most recent moves,
2162                 // because we now need a new slot for the next input
2163                 for (i = CL_MAX_USERCMDS - 1;i >= 1;i--)
2164                         cl.movecmd[i] = cl.movecmd[i-1];
2165                 cl.movecmd[0].msec = 0;
2166                 cl.movecmd[0].frametime = 0;
2167         }
2168
2169         // clear button 'click' states
2170         in_attack.state  &= ~2;
2171         in_jump.state    &= ~2;
2172         in_button3.state &= ~2;
2173         in_button4.state &= ~2;
2174         in_button5.state &= ~2;
2175         in_button6.state &= ~2;
2176         in_button7.state &= ~2;
2177         in_button8.state &= ~2;
2178         in_use.state     &= ~2;
2179         in_button9.state  &= ~2;
2180         in_button10.state &= ~2;
2181         in_button11.state &= ~2;
2182         in_button12.state &= ~2;
2183         in_button13.state &= ~2;
2184         in_button14.state &= ~2;
2185         in_button15.state &= ~2;
2186         in_button16.state &= ~2;
2187         // clear impulse
2188         in_impulse = 0;
2189
2190         if (cls.netcon->message.overflowed)
2191                 CL_DisconnectEx(true, "Lost connection to server");
2192 }
2193
2194 /*
2195 ============
2196 CL_InitInput
2197 ============
2198 */
2199 void CL_InitInput (void)
2200 {
2201         Cmd_AddCommand(CF_CLIENT, "+moveup",IN_UpDown, "swim upward");
2202         Cmd_AddCommand(CF_CLIENT, "-moveup",IN_UpUp, "stop swimming upward");
2203         Cmd_AddCommand(CF_CLIENT, "+movedown",IN_DownDown, "swim downward");
2204         Cmd_AddCommand(CF_CLIENT, "-movedown",IN_DownUp, "stop swimming downward");
2205         Cmd_AddCommand(CF_CLIENT, "+left",IN_LeftDown, "turn left");
2206         Cmd_AddCommand(CF_CLIENT, "-left",IN_LeftUp, "stop turning left");
2207         Cmd_AddCommand(CF_CLIENT, "+right",IN_RightDown, "turn right");
2208         Cmd_AddCommand(CF_CLIENT, "-right",IN_RightUp, "stop turning right");
2209         Cmd_AddCommand(CF_CLIENT, "+forward",IN_ForwardDown, "move forward");
2210         Cmd_AddCommand(CF_CLIENT, "-forward",IN_ForwardUp, "stop moving forward");
2211         Cmd_AddCommand(CF_CLIENT, "+back",IN_BackDown, "move backward");
2212         Cmd_AddCommand(CF_CLIENT, "-back",IN_BackUp, "stop moving backward");
2213         Cmd_AddCommand(CF_CLIENT, "+lookup", IN_LookupDown, "look upward");
2214         Cmd_AddCommand(CF_CLIENT, "-lookup", IN_LookupUp, "stop looking upward");
2215         Cmd_AddCommand(CF_CLIENT, "+lookdown", IN_LookdownDown, "look downward");
2216         Cmd_AddCommand(CF_CLIENT, "-lookdown", IN_LookdownUp, "stop looking downward");
2217         Cmd_AddCommand(CF_CLIENT, "+strafe", IN_StrafeDown, "activate strafing mode (move instead of turn)");
2218         Cmd_AddCommand(CF_CLIENT, "-strafe", IN_StrafeUp, "deactivate strafing mode");
2219         Cmd_AddCommand(CF_CLIENT, "+moveleft", IN_MoveleftDown, "strafe left");
2220         Cmd_AddCommand(CF_CLIENT, "-moveleft", IN_MoveleftUp, "stop strafing left");
2221         Cmd_AddCommand(CF_CLIENT, "+moveright", IN_MoverightDown, "strafe right");
2222         Cmd_AddCommand(CF_CLIENT, "-moveright", IN_MoverightUp, "stop strafing right");
2223         Cmd_AddCommand(CF_CLIENT, "+speed", IN_SpeedDown, "activate run mode (faster movement and turning)");
2224         Cmd_AddCommand(CF_CLIENT, "-speed", IN_SpeedUp, "deactivate run mode");
2225         Cmd_AddCommand(CF_CLIENT, "+attack", IN_AttackDown, "begin firing");
2226         Cmd_AddCommand(CF_CLIENT, "-attack", IN_AttackUp, "stop firing");
2227         Cmd_AddCommand(CF_CLIENT, "+jump", IN_JumpDown, "jump");
2228         Cmd_AddCommand(CF_CLIENT, "-jump", IN_JumpUp, "end jump (so you can jump again)");
2229         Cmd_AddCommand(CF_CLIENT, "impulse", IN_Impulse, "send an impulse number to server (select weapon, use item, etc)");
2230         Cmd_AddCommand(CF_CLIENT, "+klook", IN_KLookDown, "activate keyboard looking mode, do not recenter view");
2231         Cmd_AddCommand(CF_CLIENT, "-klook", IN_KLookUp, "deactivate keyboard looking mode");
2232         Cmd_AddCommand(CF_CLIENT, "+mlook", IN_MLookDown, "activate mouse looking mode, do not recenter view");
2233         Cmd_AddCommand(CF_CLIENT, "-mlook", IN_MLookUp, "deactivate mouse looking mode");
2234
2235         // LadyHavoc: added lots of buttons
2236         Cmd_AddCommand(CF_CLIENT, "+use", IN_UseDown, "use something (may be used by some mods)");
2237         Cmd_AddCommand(CF_CLIENT, "-use", IN_UseUp, "stop using something");
2238         Cmd_AddCommand(CF_CLIENT, "+button3", IN_Button3Down, "activate button3 (behavior depends on mod)");
2239         Cmd_AddCommand(CF_CLIENT, "-button3", IN_Button3Up, "deactivate button3");
2240         Cmd_AddCommand(CF_CLIENT, "+button4", IN_Button4Down, "activate button4 (behavior depends on mod)");
2241         Cmd_AddCommand(CF_CLIENT, "-button4", IN_Button4Up, "deactivate button4");
2242         Cmd_AddCommand(CF_CLIENT, "+button5", IN_Button5Down, "activate button5 (behavior depends on mod)");
2243         Cmd_AddCommand(CF_CLIENT, "-button5", IN_Button5Up, "deactivate button5");
2244         Cmd_AddCommand(CF_CLIENT, "+button6", IN_Button6Down, "activate button6 (behavior depends on mod)");
2245         Cmd_AddCommand(CF_CLIENT, "-button6", IN_Button6Up, "deactivate button6");
2246         Cmd_AddCommand(CF_CLIENT, "+button7", IN_Button7Down, "activate button7 (behavior depends on mod)");
2247         Cmd_AddCommand(CF_CLIENT, "-button7", IN_Button7Up, "deactivate button7");
2248         Cmd_AddCommand(CF_CLIENT, "+button8", IN_Button8Down, "activate button8 (behavior depends on mod)");
2249         Cmd_AddCommand(CF_CLIENT, "-button8", IN_Button8Up, "deactivate button8");
2250         Cmd_AddCommand(CF_CLIENT, "+button9", IN_Button9Down, "activate button9 (behavior depends on mod)");
2251         Cmd_AddCommand(CF_CLIENT, "-button9", IN_Button9Up, "deactivate button9");
2252         Cmd_AddCommand(CF_CLIENT, "+button10", IN_Button10Down, "activate button10 (behavior depends on mod)");
2253         Cmd_AddCommand(CF_CLIENT, "-button10", IN_Button10Up, "deactivate button10");
2254         Cmd_AddCommand(CF_CLIENT, "+button11", IN_Button11Down, "activate button11 (behavior depends on mod)");
2255         Cmd_AddCommand(CF_CLIENT, "-button11", IN_Button11Up, "deactivate button11");
2256         Cmd_AddCommand(CF_CLIENT, "+button12", IN_Button12Down, "activate button12 (behavior depends on mod)");
2257         Cmd_AddCommand(CF_CLIENT, "-button12", IN_Button12Up, "deactivate button12");
2258         Cmd_AddCommand(CF_CLIENT, "+button13", IN_Button13Down, "activate button13 (behavior depends on mod)");
2259         Cmd_AddCommand(CF_CLIENT, "-button13", IN_Button13Up, "deactivate button13");
2260         Cmd_AddCommand(CF_CLIENT, "+button14", IN_Button14Down, "activate button14 (behavior depends on mod)");
2261         Cmd_AddCommand(CF_CLIENT, "-button14", IN_Button14Up, "deactivate button14");
2262         Cmd_AddCommand(CF_CLIENT, "+button15", IN_Button15Down, "activate button15 (behavior depends on mod)");
2263         Cmd_AddCommand(CF_CLIENT, "-button15", IN_Button15Up, "deactivate button15");
2264         Cmd_AddCommand(CF_CLIENT, "+button16", IN_Button16Down, "activate button16 (behavior depends on mod)");
2265         Cmd_AddCommand(CF_CLIENT, "-button16", IN_Button16Up, "deactivate button16");
2266
2267         // LadyHavoc: added bestweapon command
2268         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)");
2269         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");
2270
2271         Cvar_RegisterVariable(&cl_movecliptokeyboard);
2272         Cvar_RegisterVariable(&cl_movement);
2273         Cvar_RegisterVariable(&cl_movement_replay);
2274         Cvar_RegisterVariable(&cl_movement_nettimeout);
2275         Cvar_RegisterVariable(&cl_movement_minping);
2276         Cvar_RegisterVariable(&cl_movement_track_canjump);
2277         Cvar_RegisterVariable(&cl_movement_maxspeed);
2278         Cvar_RegisterVariable(&cl_movement_maxairspeed);
2279         Cvar_RegisterVariable(&cl_movement_stopspeed);
2280         Cvar_RegisterVariable(&cl_movement_friction);
2281         Cvar_RegisterVariable(&cl_movement_wallfriction);
2282         Cvar_RegisterVariable(&cl_movement_waterfriction);
2283         Cvar_RegisterVariable(&cl_movement_edgefriction);
2284         Cvar_RegisterVariable(&cl_movement_stepheight);
2285         Cvar_RegisterVariable(&cl_movement_accelerate);
2286         Cvar_RegisterVariable(&cl_movement_airaccelerate);
2287         Cvar_RegisterVariable(&cl_movement_wateraccelerate);
2288         Cvar_RegisterVariable(&cl_movement_jumpvelocity);
2289         Cvar_RegisterVariable(&cl_movement_airaccel_qw);
2290         Cvar_RegisterVariable(&cl_movement_airaccel_sideways_friction);
2291         Cvar_RegisterVariable(&cl_nopred);
2292
2293         Cvar_RegisterVariable(&in_pitch_min);
2294         Cvar_RegisterVariable(&in_pitch_max);
2295         Cvar_RegisterVariable(&m_filter);
2296         Cvar_RegisterVariable(&m_accelerate);
2297         Cvar_RegisterVariable(&m_accelerate_minspeed);
2298         Cvar_RegisterVariable(&m_accelerate_maxspeed);
2299         Cvar_RegisterVariable(&m_accelerate_filter);
2300         Cvar_RegisterVariable(&m_accelerate_power);
2301         Cvar_RegisterVariable(&m_accelerate_power_offset);
2302         Cvar_RegisterVariable(&m_accelerate_power_senscap);
2303         Cvar_RegisterVariable(&m_accelerate_power_strength);
2304         Cvar_RegisterVariable(&m_accelerate_natural_offset);
2305         Cvar_RegisterVariable(&m_accelerate_natural_accelsenscap);
2306         Cvar_RegisterVariable(&m_accelerate_natural_strength);
2307
2308         Cvar_RegisterVariable(&cl_netfps);
2309         Cvar_RegisterVariable(&cl_netrepeatinput);
2310         Cvar_RegisterVariable(&cl_netimmediatebuttons);
2311
2312         Cvar_RegisterVariable(&cl_nodelta);
2313
2314         Cvar_RegisterVariable(&cl_csqc_generatemousemoveevents);
2315 }
2316