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