cl_input.c

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