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 /*
 201 ===============
 202 CL_KeyState
 203
 204 Returns 0.25 if a key was pressed and released during the frame,
 205 0.5 if it was pressed and held
 206 0 if held then released, and
 207 1.0 if held for the entire time
 208 ===============
 209 */
 210 float CL_KeyState (kbutton_t *key)
 211 {
 212         float           val;
 213         qboolean        impulsedown, impulseup, down;
 214
 215         impulsedown = key->state & 2;
 216         impulseup = key->state & 4;
 217         down = key->state & 1;
 218         val = 0;
 219
 220         if (impulsedown && !impulseup)
 221         {
 222                 if (down)
 223                         val = 0.5;      // pressed and held this frame
 224                 else
 225                         val = 0;        //      I_Error ();
 226         }
 227         if (impulseup && !impulsedown)
 228         {
 229                 if (down)
 230                         val = 0;        //      I_Error ();
 231                 else
 232                         val = 0;        // released this frame
 233         }
 234         if (!impulsedown && !impulseup)
 235         {
 236                 if (down)
 237                         val = 1.0;      // held the entire frame
 238                 else
 239                         val = 0;        // up the entire frame
 240         }
 241         if (impulsedown && impulseup)
 242         {
 243                 if (down)
 244                         val = 0.75;     // released and re-pressed this frame
 245                 else
 246                         val = 0.25;     // pressed and released this frame
 247         }
 248
 249         key->state &= 1;                // clear impulses
 250
 251         return val;
 252 }
 253
 254
 255
 256
 257 //==========================================================================
 258
 259 cvar_t cl_upspeed = {CVAR_SAVE, "cl_upspeed","400","vertical movement speed (while swimming or flying)"};
 260 cvar_t cl_forwardspeed = {CVAR_SAVE, "cl_forwardspeed","400","forward movement speed"};
 261 cvar_t cl_backspeed = {CVAR_SAVE, "cl_backspeed","400","backward movement speed"};
 262 cvar_t cl_sidespeed = {CVAR_SAVE, "cl_sidespeed","350","strafe movement speed"};
 263
 264 cvar_t cl_movespeedkey = {CVAR_SAVE, "cl_movespeedkey","2.0","how much +speed multiplies keyboard movement speed"};
 265
 266 cvar_t cl_yawspeed = {CVAR_SAVE, "cl_yawspeed","140","keyboard yaw turning speed"};
 267 cvar_t cl_pitchspeed = {CVAR_SAVE, "cl_pitchspeed","150","keyboard pitch turning speed"};
 268
 269 cvar_t cl_anglespeedkey = {CVAR_SAVE, "cl_anglespeedkey","1.5","how much +speed multiplies keyboard turning speed"};
 270
 271 cvar_t cl_movement = {CVAR_SAVE, "cl_movement", "0", "enables clientside prediction of your player movement"};
 272 cvar_t cl_movement_latency = {0, "cl_movement_latency", "0", "compensates for this much latency (ping time) on quake servers which do not really support prediction, no effect on darkplaces7 protocol servers"};
 273 cvar_t cl_movement_maxspeed = {0, "cl_movement_maxspeed", "320", "how fast you can move (should match sv_maxspeed)"};
 274 cvar_t cl_movement_maxairspeed = {0, "cl_movement_maxairspeed", "30", "how fast you can move while in the air (should match sv_maxairspeed)"};
 275 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)"};
 276 cvar_t cl_movement_friction = {0, "cl_movement_friction", "4", "how fast you slow down (should match sv_friction)"};
 277 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)"};
 278 cvar_t cl_movement_stepheight = {0, "cl_movement_stepheight", "18", "how tall a step you can step in one instant (should match sv_stepheight)"};
 279 cvar_t cl_movement_accelerate = {0, "cl_movement_accelerate", "10", "how fast you accelerate (should match sv_accelerate)"};
 280 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)"};
 281 cvar_t cl_gravity = {0, "cl_gravity", "800", "how much gravity to apply in client physics (should match sv_gravity)"};
 282 cvar_t cl_slowmo = {0, "cl_slowmo", "1", "speed of game time (should match slowmo)"};
 283
 284 cvar_t in_pitch_min = {0, "in_pitch_min", "-90", "how far downward you can aim (quake used -70"}; // quake used -70
 285 cvar_t in_pitch_max = {0, "in_pitch_max", "90", "how far upward you can aim (quake used 80"}; // quake used 80
 286
 287 cvar_t m_filter = {CVAR_SAVE, "m_filter","0", "smoothes mouse movement, less responsive but smoother aiming"};
 288
 289 cvar_t cl_netinputpacketspersecond = {CVAR_SAVE, "cl_netinputpacketspersecond","50", "how many input packets to send to server each second"};
 290
 291 cvar_t cl_nodelta = {0, "cl_nodelta", "0", "disables delta compression of non-player entities in QW network protocol"};
 292
 293
 294 /*
 295 ================
 296 CL_AdjustAngles
 297
 298 Moves the local angle positions
 299 ================
 300 */
 301 void CL_AdjustAngles (void)
 302 {
 303         float   speed;
 304         float   up, down;
 305
 306         if (in_speed.state & 1)
 307                 speed = host_realframetime * cl_anglespeedkey.value;
 308         else
 309                 speed = host_realframetime;
 310
 311         if (!(in_strafe.state & 1))
 312         {
 313                 cl.viewangles[YAW] -= speed*cl_yawspeed.value*CL_KeyState (&in_right);
 314                 cl.viewangles[YAW] += speed*cl_yawspeed.value*CL_KeyState (&in_left);
 315         }
 316         if (in_klook.state & 1)
 317         {
 318                 V_StopPitchDrift ();
 319                 cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * CL_KeyState (&in_forward);
 320                 cl.viewangles[PITCH] += speed*cl_pitchspeed.value * CL_KeyState (&in_back);
 321         }
 322
 323         up = CL_KeyState (&in_lookup);
 324         down = CL_KeyState(&in_lookdown);
 325
 326         cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * up;
 327         cl.viewangles[PITCH] += speed*cl_pitchspeed.value * down;
 328
 329         if (up || down)
 330                 V_StopPitchDrift ();
 331
 332         cl.viewangles[YAW] = ANGLEMOD(cl.viewangles[YAW]);
 333         cl.viewangles[PITCH] = ANGLEMOD(cl.viewangles[PITCH]);
 334         cl.viewangles[ROLL] = ANGLEMOD(cl.viewangles[ROLL]);
 335         if (cl.viewangles[YAW] >= 180)
 336                 cl.viewangles[YAW] -= 360;
 337         if (cl.viewangles[PITCH] >= 180)
 338                 cl.viewangles[PITCH] -= 360;
 339         if (cl.viewangles[ROLL] >= 180)
 340                 cl.viewangles[ROLL] -= 360;
 341
 342         cl.viewangles[PITCH] = bound (in_pitch_min.value, cl.viewangles[PITCH], in_pitch_max.value);
 343         cl.viewangles[ROLL] = bound(-50, cl.viewangles[ROLL], 50);
 344 }
 345
 346 qboolean cl_ignoremousemove = false;
 347
 348 /*
 349 ================
 350 CL_Move
 351
 352 Send the intended movement message to the server
 353 ================
 354 */
 355 void CL_Move (void)
 356 {
 357         vec3_t temp;
 358         float mx, my;
 359         static float old_mouse_x = 0, old_mouse_y = 0;
 360
 361         // clamp before the move to prevent starting with bad angles
 362         CL_AdjustAngles ();
 363
 364         // get basic movement from keyboard
 365         // PRYDON_CLIENTCURSOR needs to survive basemove resets
 366         VectorCopy (cl.cmd.cursor_screen, temp);
 367         memset (&cl.cmd, 0, sizeof(cl.cmd));
 368         VectorCopy (temp, cl.cmd.cursor_screen);
 369
 370         if (in_strafe.state & 1)
 371         {
 372                 cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_right);
 373                 cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_left);
 374         }
 375
 376         cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_moveright);
 377         cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_moveleft);
 378
 379         cl.cmd.upmove += cl_upspeed.value * CL_KeyState (&in_up);
 380         cl.cmd.upmove -= cl_upspeed.value * CL_KeyState (&in_down);
 381
 382         if (! (in_klook.state & 1) )
 383         {
 384                 cl.cmd.forwardmove += cl_forwardspeed.value * CL_KeyState (&in_forward);
 385                 cl.cmd.forwardmove -= cl_backspeed.value * CL_KeyState (&in_back);
 386         }
 387
 388         // adjust for speed key
 389         if (in_speed.state & 1)
 390         {
 391                 cl.cmd.forwardmove *= cl_movespeedkey.value;
 392                 cl.cmd.sidemove *= cl_movespeedkey.value;
 393                 cl.cmd.upmove *= cl_movespeedkey.value;
 394         }
 395
 396         in_mouse_x = 0;
 397         in_mouse_y = 0;
 398
 399         // allow mice or other external controllers to add to the move
 400         IN_Move ();
 401
 402         // ignore a mouse move if mouse was activated/deactivated this frame
 403         if (cl_ignoremousemove)
 404         {
 405                 cl_ignoremousemove = false;
 406                 in_mouse_x = 0;
 407                 in_mouse_y = 0;
 408         }
 409
 410         // apply m_filter if it is on
 411         mx = in_mouse_x;
 412         my = in_mouse_y;
 413         if (m_filter.integer)
 414         {
 415                 in_mouse_x = (mx + old_mouse_x) * 0.5;
 416                 in_mouse_y = (my + old_mouse_y) * 0.5;
 417         }
 418         old_mouse_x = mx;
 419         old_mouse_y = my;
 420
 421         // if not in menu, apply mouse move to viewangles/movement
 422         if (!cl.csqc_wantsmousemove && in_client_mouse)
 423         {
 424                 if (cl_prydoncursor.integer)
 425                 {
 426                         // mouse interacting with the scene, mostly stationary view
 427                         V_StopPitchDrift();
 428                         cl.cmd.cursor_screen[0] += in_mouse_x * sensitivity.value / vid.width;
 429                         cl.cmd.cursor_screen[1] += in_mouse_y * sensitivity.value / vid.height;
 430                 }
 431                 else if (in_strafe.state & 1)
 432                 {
 433                         // strafing mode, all looking is movement
 434                         V_StopPitchDrift();
 435                         cl.cmd.sidemove += m_side.value * in_mouse_x * sensitivity.value;
 436                         if (noclip_anglehack)
 437                                 cl.cmd.upmove -= m_forward.value * in_mouse_y * sensitivity.value;
 438                         else
 439                                 cl.cmd.forwardmove -= m_forward.value * in_mouse_y * sensitivity.value;
 440                 }
 441                 else if ((in_mlook.state & 1) || freelook.integer)
 442                 {
 443                         // mouselook, lookstrafe causes turning to become strafing
 444                         V_StopPitchDrift();
 445                         if (lookstrafe.integer)
 446                                 cl.cmd.sidemove += m_side.value * in_mouse_x * sensitivity.value;
 447                         else
 448                                 cl.viewangles[YAW] -= m_yaw.value * in_mouse_x * sensitivity.value * cl.viewzoom;
 449                         cl.viewangles[PITCH] += m_pitch.value * in_mouse_y * sensitivity.value * cl.viewzoom;
 450                 }
 451                 else
 452                 {
 453                         // non-mouselook, yaw turning and forward/back movement
 454                         cl.viewangles[YAW] -= m_yaw.value * in_mouse_x * sensitivity.value * cl.viewzoom;
 455                         cl.cmd.forwardmove -= m_forward.value * in_mouse_y * sensitivity.value;
 456                 }
 457         }
 458
 459         // clamp after the move to prevent rendering with bad angles
 460         CL_AdjustAngles ();
 461 }
 462
 463 #include "cl_collision.h"
 464
 465 extern void V_CalcRefdef(void);
 466 void CL_UpdatePrydonCursor(void)
 467 {
 468         vec3_t temp, scale;
 469
 470         if (!cl_prydoncursor.integer)
 471                 VectorClear(cl.cmd.cursor_screen);
 472
 473         /*
 474         if (cl.cmd.cursor_screen[0] < -1)
 475         {
 476                 cl.viewangles[YAW] -= m_yaw.value * (cl.cmd.cursor_screen[0] - -1) * vid.width * sensitivity.value * cl.viewzoom;
 477                 cl.cmd.cursor_screen[0] = -1;
 478         }
 479         if (cl.cmd.cursor_screen[0] > 1)
 480         {
 481                 cl.viewangles[YAW] -= m_yaw.value * (cl.cmd.cursor_screen[0] - 1) * vid.width * sensitivity.value * cl.viewzoom;
 482                 cl.cmd.cursor_screen[0] = 1;
 483         }
 484         if (cl.cmd.cursor_screen[1] < -1)
 485         {
 486                 cl.viewangles[PITCH] += m_pitch.value * (cl.cmd.cursor_screen[1] - -1) * vid.height * sensitivity.value * cl.viewzoom;
 487                 cl.cmd.cursor_screen[1] = -1;
 488         }
 489         if (cl.cmd.cursor_screen[1] > 1)
 490         {
 491                 cl.viewangles[PITCH] += m_pitch.value * (cl.cmd.cursor_screen[1] - 1) * vid.height * sensitivity.value * cl.viewzoom;
 492                 cl.cmd.cursor_screen[1] = 1;
 493         }
 494         */
 495         cl.cmd.cursor_screen[0] = bound(-1, cl.cmd.cursor_screen[0], 1);
 496         cl.cmd.cursor_screen[1] = bound(-1, cl.cmd.cursor_screen[1], 1);
 497         cl.cmd.cursor_screen[2] = 1;
 498
 499         scale[0] = -r_refdef.frustum_x;
 500         scale[1] = -r_refdef.frustum_y;
 501         scale[2] = 1;
 502
 503         // trace distance
 504         VectorScale(scale, 1000000, scale);
 505
 506         // calculate current view matrix
 507         V_CalcRefdef();
 508         VectorClear(temp);
 509         Matrix4x4_Transform(&r_refdef.viewentitymatrix, temp, cl.cmd.cursor_start);
 510         VectorSet(temp, cl.cmd.cursor_screen[2] * scale[2], cl.cmd.cursor_screen[0] * scale[0], cl.cmd.cursor_screen[1] * scale[1]);
 511         Matrix4x4_Transform(&r_refdef.viewentitymatrix, temp, cl.cmd.cursor_end);
 512         // trace from view origin to the cursor
 513         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, false);
 514         // makes sparks where cursor is
 515         //CL_SparkShower(cl.cmd.cursor_impact, cl.cmd.cursor_normal, 5, 0);
 516 }
 517
 518 void CL_ClientMovement_InputQW(qw_usercmd_t *cmd)
 519 {
 520         int i;
 521         int n;
 522         // remove stale queue items
 523         n = cl.movement_numqueue;
 524         cl.movement_numqueue = 0;
 525         for (i = 0;i < n;i++)
 526                 if (cl.movement_queue[i].sequence > cls.netcon->qw.incoming_sequence)
 527                         cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
 528         // add to input queue if there is room
 529         if (cl.movement_numqueue < (int)(sizeof(cl.movement_queue)/sizeof(cl.movement_queue[0])) && cl.mtime[0] > cl.mtime[1])
 530         {
 531                 // add to input queue
 532                 cl.movement_queue[cl.movement_numqueue].sequence = cls.netcon->qw.outgoing_sequence;
 533                 cl.movement_queue[cl.movement_numqueue].time = cl.mtime[0] + cl_movement_latency.value / 1000.0;
 534                 cl.movement_queue[cl.movement_numqueue].frametime = cmd->msec * 0.001;
 535                 VectorCopy(cmd->angles, cl.movement_queue[cl.movement_numqueue].viewangles);
 536                 cl.movement_queue[cl.movement_numqueue].move[0] = cmd->forwardmove;
 537                 cl.movement_queue[cl.movement_numqueue].move[1] = cmd->sidemove;
 538                 cl.movement_queue[cl.movement_numqueue].move[2] = cmd->upmove;
 539                 cl.movement_queue[cl.movement_numqueue].jump = (cmd->buttons & 2) != 0;
 540                 cl.movement_queue[cl.movement_numqueue].crouch = false;
 541                 cl.movement_numqueue++;
 542         }
 543         cl.movement_replay = true;
 544 }
 545
 546 void CL_ClientMovement_Input(qboolean buttonjump, qboolean buttoncrouch)
 547 {
 548         int i;
 549         int n;
 550         // remove stale queue items
 551         n = cl.movement_numqueue;
 552         cl.movement_numqueue = 0;
 553         if (cl.servermovesequence)
 554         {
 555                 for (i = 0;i < n;i++)
 556                         if (cl.movement_queue[i].sequence > cl.servermovesequence)
 557                                 cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
 558         }
 559         else
 560         {
 561                 double simulatedtime = cl.mtime[0] + cl_movement_latency.value / 1000.0;
 562                 for (i = 0;i < n;i++)
 563                         if (cl.movement_queue[i].time >= cl.mtime[0] && cl.movement_queue[i].time <= simulatedtime)
 564                                 cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
 565         }
 566         // add to input queue if there is room
 567         if (cl.movement_numqueue < (int)(sizeof(cl.movement_queue)/sizeof(cl.movement_queue[0])) && cl.mtime[0] > cl.mtime[1])
 568         {
 569                 // add to input queue
 570                 cl.movement_queue[cl.movement_numqueue].sequence = cl.movesequence;
 571                 cl.movement_queue[cl.movement_numqueue].time = cl.mtime[0] + cl_movement_latency.value / 1000.0;
 572                 cl.movement_queue[cl.movement_numqueue].frametime = cl.mtime[0] - cl.mtime[1];
 573                 VectorCopy(cl.viewangles, cl.movement_queue[cl.movement_numqueue].viewangles);
 574                 cl.movement_queue[cl.movement_numqueue].move[0] = cl.cmd.forwardmove;
 575                 cl.movement_queue[cl.movement_numqueue].move[1] = cl.cmd.sidemove;
 576                 cl.movement_queue[cl.movement_numqueue].move[2] = cl.cmd.upmove;
 577                 cl.movement_queue[cl.movement_numqueue].jump = buttonjump;
 578                 cl.movement_queue[cl.movement_numqueue].crouch = buttoncrouch;
 579                 cl.movement_numqueue++;
 580         }
 581         cl.movement_replay = true;
 582 }
 583
 584 void CL_ClientMovement_Replay(void)
 585 {
 586         int i;
 587         int bump;
 588         int contents;
 589         int crouch;
 590         int onground;
 591         float movevars_gravity;
 592         float movevars_stopspeed;
 593         float movevars_maxspeed;
 594         float movevars_spectatormaxspeed;
 595         float movevars_accelerate;
 596         float movevars_airaccelerate;
 597         float movevars_wateraccelerate;
 598         float movevars_friction;
 599         float movevars_waterfriction;
 600         float movevars_entgravity;
 601         float movevars_jumpvelocity;
 602         float movevars_edgefriction;
 603         float movevars_maxairspeed;
 604         float movevars_stepheight;
 605         double edgefriction;
 606         double frametime;
 607         double t;
 608         vec_t wishspeed;
 609         vec_t addspeed;
 610         vec_t accelspeed;
 611         vec_t f;
 612         vec_t *playermins;
 613         vec_t *playermaxs;
 614         vec3_t currentorigin;
 615         vec3_t currentvelocity;
 616         vec3_t forward;
 617         vec3_t right;
 618         vec3_t up;
 619         vec3_t wishvel;
 620         vec3_t wishdir;
 621         vec3_t neworigin;
 622         vec3_t currentorigin2;
 623         vec3_t neworigin2;
 624         vec3_t yawangles;
 625         trace_t trace;
 626         trace_t trace2;
 627         trace_t trace3;
 628
 629
 630         if (!cl.movement_replay)
 631                 return;
 632         cl.movement_replay = false;
 633
 634         if (cls.protocol == PROTOCOL_QUAKEWORLD)
 635         {
 636                 movevars_gravity = cl.qw_movevars_gravity;
 637                 movevars_stopspeed = cl.qw_movevars_stopspeed;
 638                 movevars_maxspeed = cl.qw_movevars_maxspeed;
 639                 movevars_spectatormaxspeed = cl.qw_movevars_spectatormaxspeed;
 640                 movevars_accelerate = cl.qw_movevars_accelerate;
 641                 movevars_airaccelerate = cl.qw_movevars_airaccelerate;
 642                 movevars_wateraccelerate = cl.qw_movevars_wateraccelerate;
 643                 movevars_friction = cl.qw_movevars_friction;
 644                 movevars_waterfriction = cl.qw_movevars_waterfriction;
 645                 movevars_entgravity = cl.qw_movevars_entgravity;
 646                 movevars_jumpvelocity = cl_movement_jumpvelocity.value;
 647                 movevars_edgefriction = cl_movement_edgefriction.value;
 648                 movevars_maxairspeed = cl_movement_maxairspeed.value;
 649                 movevars_stepheight = cl_movement_stepheight.value;
 650         }
 651         else
 652         {
 653                 movevars_gravity = sv_gravity.value;
 654                 movevars_stopspeed = cl_movement_stopspeed.value;
 655                 movevars_maxspeed = cl_movement_maxspeed.value;
 656                 movevars_spectatormaxspeed = cl_movement_maxspeed.value;
 657                 movevars_accelerate = cl_movement_accelerate.value;
 658                 movevars_airaccelerate = cl_movement_accelerate.value;
 659                 movevars_wateraccelerate = cl_movement_accelerate.value;
 660                 movevars_friction = cl_movement_friction.value;
 661                 movevars_waterfriction = cl_movement_friction.value;
 662                 movevars_entgravity = 1;
 663                 movevars_jumpvelocity = cl_movement_jumpvelocity.value;
 664                 movevars_edgefriction = cl_movement_edgefriction.value;
 665                 movevars_maxairspeed = cl_movement_maxairspeed.value;
 666                 movevars_stepheight = cl_movement_stepheight.value;
 667         }
 668
 669         // fetch current starting values
 670         VectorCopy(cl_entities[cl.playerentity].state_current.origin, currentorigin);
 671         VectorCopy(cl.mvelocity[0], currentvelocity);
 672         // FIXME: try minor nudges in various directions if startsolid to find a
 673         // safe place to start the walk (due to network compression in some
 674         // protocols this starts in solid)
 675         //currentorigin[2] += (1.0 / 32.0); // slight nudge to get out of the floor
 676         crouch = false; // this will be updated on first move
 677
 678         // check if onground
 679         VectorSet(currentorigin2, currentorigin[0], currentorigin[1], currentorigin[2] + 1);
 680         VectorSet(neworigin2, currentorigin[0], currentorigin[1], currentorigin[2] - 1);
 681         trace = CL_TraceBox(currentorigin2, cl_playercrouchmins, cl_playercrouchmaxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
 682         onground = trace.fraction < 1 && trace.plane.normal[2] > 0.7;
 683         //Con_Printf("%f: ", cl.mtime[0]);
 684
 685         // replay the input queue to predict current location
 686         // note: this relies on the fact there's always one queue item at the end
 687
 688         for (i = 0;cl.movement && i < cl.movement_numqueue;i++)
 689         {
 690                 client_movementqueue_t *q = cl.movement_queue + bound(0, i, cl.movement_numqueue - 1);
 691                 frametime = q->frametime;
 692                 //Con_Printf(" %f", frametime);
 693                 //if (frametime > 0)
 694                 {
 695                         if (q->crouch)
 696                         {
 697                                 // wants to crouch, this always works...
 698                                 if (!crouch)
 699                                         crouch = true;
 700                         }
 701                         else
 702                         {
 703                                 // wants to stand, if currently crouching we need to check for a
 704                                 // low ceiling first
 705                                 if (crouch)
 706                                 {
 707                                         trace = CL_TraceBox(currentorigin, cl_playerstandmins, cl_playerstandmaxs, currentorigin, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
 708                                         if (!trace.startsolid)
 709                                                 crouch = false;
 710                                 }
 711                         }
 712                         if (crouch)
 713                         {
 714                                 playermins = cl_playercrouchmins;
 715                                 playermaxs = cl_playercrouchmaxs;
 716                         }
 717                         else
 718                         {
 719                                 playermins = cl_playerstandmins;
 720                                 playermaxs = cl_playerstandmaxs;
 721                         }
 722                         // change velocity according to q->viewangles and q->move
 723                         contents = CL_PointSuperContents(currentorigin);
 724                         if (contents & SUPERCONTENTS_LIQUIDSMASK)
 725                         {
 726                                 // swim
 727                                 AngleVectors(q->viewangles, forward, right, up);
 728                                 VectorSet(up, 0, 0, 1);
 729                                 VectorMAMAM(q->move[0], forward, q->move[1], right, q->move[2], up, wishvel);
 730                                 wishspeed = VectorLength(wishvel);
 731                                 if (wishspeed)
 732                                         VectorScale(wishvel, 1 / wishspeed, wishdir);
 733                                 else
 734                                         VectorSet( wishdir, 0.0, 0.0, 0.0 );
 735                                 wishspeed = min(wishspeed, movevars_maxspeed) * 0.6;
 736                                 if (crouch)
 737                                         wishspeed *= 0.5;
 738                                 VectorScale(currentvelocity, (1 - frametime * movevars_waterfriction), currentvelocity);
 739                                 f = wishspeed - DotProduct(currentvelocity, wishdir);
 740                                 if (f > 0)
 741                                 {
 742                                         f = min(f, movevars_wateraccelerate * frametime * wishspeed);
 743                                         VectorMA(currentvelocity, f, wishdir, currentvelocity);
 744                                 }
 745                                 if (q->jump)
 746                                 {
 747                                         if (contents & SUPERCONTENTS_LAVA)
 748                                                 currentvelocity[2] =  50;
 749                                         else if (contents & SUPERCONTENTS_SLIME)
 750                                                 currentvelocity[2] =  80;
 751                                         else
 752                                         {
 753                                                 if (gamemode == GAME_NEXUIZ)
 754                                                         currentvelocity[2] = 200;
 755                                                 else
 756                                                         currentvelocity[2] = 100;
 757                                         }
 758                                 }
 759                         }
 760                         else
 761                         {
 762                                 // walk
 763                                 if (onground && q->jump)
 764                                 {
 765                                         currentvelocity[2] += movevars_jumpvelocity;
 766                                         onground = false;
 767                                 }
 768                                 VectorSet(yawangles, 0, q->viewangles[1], 0);
 769                                 AngleVectors(yawangles, forward, right, up);
 770                                 VectorMAM(q->move[0], forward, q->move[1], right, wishvel);
 771                                 wishspeed = VectorLength(wishvel);
 772                                 if (wishspeed)
 773                                         VectorScale(wishvel, 1 / wishspeed, wishdir);
 774                                 else
 775                                         VectorSet( wishdir, 0.0, 0.0, 0.0 );
 776                                 wishspeed = min(wishspeed, movevars_maxspeed);
 777                                 if (crouch)
 778                                         wishspeed *= 0.5;
 779                                 // check if onground
 780                                 if (onground)
 781                                 {
 782                                         // apply ground friction
 783                                         f = sqrt(currentvelocity[0] * currentvelocity[0] + currentvelocity[1] * currentvelocity[1]);
 784                                         edgefriction = 1;
 785                                         if (f > 0)
 786                                         {
 787                                                 VectorSet(currentorigin2, currentorigin[0] + currentvelocity[0]*(16/f), currentorigin[1] + currentvelocity[1]*(16/f), currentorigin[2] + playermins[2]);
 788                                                 VectorSet(neworigin2, currentorigin2[0], currentorigin2[1], currentorigin2[2] - 34);
 789                                                 trace = CL_TraceBox(currentorigin2, vec3_origin, vec3_origin, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
 790                                                 if (trace.fraction == 1)
 791                                                         edgefriction = movevars_edgefriction;
 792                                         }
 793                                         // apply friction
 794                                         f = 1 - frametime * edgefriction * ((f < movevars_stopspeed) ? (movevars_stopspeed / f) : 1) * movevars_friction;
 795                                         f = max(f, 0);
 796                                         VectorScale(currentvelocity, f, currentvelocity);
 797                                 }
 798                                 else
 799                                 {
 800                                         // apply air speed limit
 801                                         wishspeed = min(wishspeed, movevars_maxairspeed);
 802                                 }
 803                                 if (gamemode == GAME_NEXUIZ)
 804                                         addspeed = wishspeed;
 805                                 else
 806                                         addspeed = wishspeed - DotProduct(currentvelocity, wishdir);
 807                                 if (addspeed > 0)
 808                                 {
 809                                         accelspeed = min(movevars_accelerate * frametime * wishspeed, addspeed);
 810                                         VectorMA(currentvelocity, accelspeed, wishdir, currentvelocity);
 811                                 }
 812                                 currentvelocity[2] -= cl_gravity.value * frametime;
 813                         }
 814                 }
 815                 //if (i < cl.movement_numqueue - 1 || (cl_movement.integer & 4))
 816                 {
 817                         if (crouch)
 818                         {
 819                                 playermins = cl_playercrouchmins;
 820                                 playermaxs = cl_playercrouchmaxs;
 821                         }
 822                         else
 823                         {
 824                                 playermins = cl_playerstandmins;
 825                                 playermaxs = cl_playerstandmaxs;
 826                         }
 827                         onground = false;
 828                         for (bump = 0, t = frametime;bump < 8 && VectorLength2(currentvelocity) > 0;bump++)
 829                         {
 830                                 VectorMA(currentorigin, t, currentvelocity, neworigin);
 831                                 trace = CL_TraceBox(currentorigin, playermins, playermaxs, neworigin, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
 832                                 if (trace.fraction < 1 && trace.plane.normal[2] == 0)
 833                                 {
 834                                         // may be a step or wall, try stepping up
 835                                         // first move forward at a higher level
 836                                         VectorSet(currentorigin2, currentorigin[0], currentorigin[1], currentorigin[2] + movevars_stepheight);
 837                                         VectorSet(neworigin2, neworigin[0], neworigin[1], currentorigin[2] + movevars_stepheight);
 838                                         trace2 = CL_TraceBox(currentorigin2, playermins, playermaxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
 839                                         // then move down from there
 840                                         VectorCopy(trace2.endpos, currentorigin2);
 841                                         VectorSet(neworigin2, trace2.endpos[0], trace2.endpos[1], currentorigin[2]);
 842                                         trace3 = CL_TraceBox(currentorigin2, playermins, playermaxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
 843                                         //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]);
 844                                         // accept the new trace if it made some progress
 845                                         if (fabs(trace3.endpos[0] - trace.endpos[0]) >= 0.03125 || fabs(trace3.endpos[1] - trace.endpos[1]) >= 0.03125)
 846                                         {
 847                                                 trace = trace2;
 848                                                 VectorCopy(trace3.endpos, trace.endpos);
 849                                         }
 850                                 }
 851                                 if (trace.fraction == 1)
 852                                 {
 853                                         VectorCopy(trace.endpos, currentorigin);
 854                                         break;
 855                                 }
 856                                 if (trace.plane.normal[2] > 0.7)
 857                                         onground = true;
 858                                 t *= 1 - trace.fraction;
 859                                 if (trace.fraction >= 0.001)
 860                                         VectorCopy(trace.endpos, currentorigin);
 861                                 f = DotProduct(currentvelocity, trace.plane.normal);
 862                                 VectorMA(currentvelocity, -f, trace.plane.normal, currentvelocity);
 863                         }
 864                 }
 865         }
 866         // store replay location
 867         VectorCopy(cl.movement_origin, cl.movement_oldorigin);
 868         VectorCopy(currentorigin, cl.movement_origin);
 869         VectorCopy(currentvelocity, cl.movement_velocity);
 870         //VectorCopy(currentorigin, cl_entities[cl.playerentity].state_current.origin);
 871         //VectorSet(cl_entities[cl.playerentity].state_current.angles, 0, cl.viewangles[1], 0);
 872 }
 873
 874 void QW_MSG_WriteDeltaUsercmd(sizebuf_t *buf, qw_usercmd_t *from, qw_usercmd_t *to)
 875 {
 876         int bits;
 877
 878         bits = 0;
 879         if (to->angles[0] != from->angles[0])
 880                 bits |= QW_CM_ANGLE1;
 881         if (to->angles[1] != from->angles[1])
 882                 bits |= QW_CM_ANGLE2;
 883         if (to->angles[2] != from->angles[2])
 884                 bits |= QW_CM_ANGLE3;
 885         if (to->forwardmove != from->forwardmove)
 886                 bits |= QW_CM_FORWARD;
 887         if (to->sidemove != from->sidemove)
 888                 bits |= QW_CM_SIDE;
 889         if (to->upmove != from->upmove)
 890                 bits |= QW_CM_UP;
 891         if (to->buttons != from->buttons)
 892                 bits |= QW_CM_BUTTONS;
 893         if (to->impulse != from->impulse)
 894                 bits |= QW_CM_IMPULSE;
 895
 896         MSG_WriteByte(buf, bits);
 897         if (bits & QW_CM_ANGLE1)
 898                 MSG_WriteAngle16i(buf, to->angles[0]);
 899         if (bits & QW_CM_ANGLE2)
 900                 MSG_WriteAngle16i(buf, to->angles[1]);
 901         if (bits & QW_CM_ANGLE3)
 902                 MSG_WriteAngle16i(buf, to->angles[2]);
 903         if (bits & QW_CM_FORWARD)
 904                 MSG_WriteShort(buf, to->forwardmove);
 905         if (bits & QW_CM_SIDE)
 906                 MSG_WriteShort(buf, to->sidemove);
 907         if (bits & QW_CM_UP)
 908                 MSG_WriteShort(buf, to->upmove);
 909         if (bits & QW_CM_BUTTONS)
 910                 MSG_WriteByte(buf, to->buttons);
 911         if (bits & QW_CM_IMPULSE)
 912                 MSG_WriteByte(buf, to->impulse);
 913         MSG_WriteByte(buf, to->msec);
 914 }
 915
 916 /*
 917 ==============
 918 CL_SendMove
 919 ==============
 920 */
 921 extern cvar_t cl_netinputpacketspersecond;
 922 void CL_SendMove(void)
 923 {
 924         int i;
 925         int bits;
 926         int impulse;
 927         sizebuf_t buf;
 928         unsigned char data[128];
 929         static double lastsendtime = 0;
 930 #define MOVEAVERAGING 0
 931 #if MOVEAVERAGING
 932         static float accumforwardmove = 0, accumsidemove = 0, accumupmove = 0, accumtotal = 0; // accumulation
 933 #endif
 934         float forwardmove, sidemove, upmove;
 935
 936         // if playing a demo, do nothing
 937         if (!cls.netcon)
 938                 return;
 939
 940 #if MOVEAVERAGING
 941         // accumulate changes between messages
 942         accumforwardmove += cl.cmd.forwardmove;
 943         accumsidemove += cl.cmd.sidemove;
 944         accumupmove += cl.cmd.upmove;
 945         accumtotal++;
 946 #endif
 947
 948         if (cl_movement.integer && cls.signon == SIGNONS && cls.protocol != PROTOCOL_QUAKEWORLD)
 949         {
 950                 if (!cl.movement_needupdate)
 951                         return;
 952                 cl.movement_needupdate = false;
 953                 cl.movement = cl.stats[STAT_HEALTH] > 0 && !cl.intermission;
 954         }
 955         else
 956         {
 957                 cl.movement = false;
 958                 if (realtime < lastsendtime + 1.0 / bound(10, cl_netinputpacketspersecond.value, 100))
 959                         return;
 960                 // don't let it fall behind if CL_SendMove hasn't been called recently
 961                 // (such is the case when framerate is too low for instance)
 962                 lastsendtime = max(lastsendtime + 1.0 / bound(10, cl_netinputpacketspersecond.value, 100), realtime);
 963         }
 964 #if MOVEAVERAGING
 965         // average the accumulated changes
 966         accumtotal = 1.0f / accumtotal;
 967         forwardmove = accumforwardmove * accumtotal;
 968         sidemove = accumsidemove * accumtotal;
 969         upmove = accumupmove * accumtotal;
 970         accumforwardmove = 0;
 971         accumsidemove = 0;
 972         accumupmove = 0;
 973         accumtotal = 0;
 974 #else
 975         // use the latest values
 976         forwardmove = cl.cmd.forwardmove;
 977         sidemove = cl.cmd.sidemove;
 978         upmove = cl.cmd.upmove;
 979 #endif
 980
 981         if (cls.signon == SIGNONS)
 982                 CL_UpdatePrydonCursor();
 983
 984         buf.maxsize = 128;
 985         buf.cursize = 0;
 986         buf.data = data;
 987
 988         // set button bits
 989         // LordHavoc: added 6 new buttons and use and chat buttons, and prydon cursor active button
 990         bits = 0;
 991         if (in_attack.state   & 3) bits |=   1;in_attack.state  &= ~2;
 992         if (in_jump.state     & 3) bits |=   2;in_jump.state    &= ~2;
 993         if (in_button3.state  & 3) bits |=   4;in_button3.state &= ~2;
 994         if (in_button4.state  & 3) bits |=   8;in_button4.state &= ~2;
 995         if (in_button5.state  & 3) bits |=  16;in_button5.state &= ~2;
 996         if (in_button6.state  & 3) bits |=  32;in_button6.state &= ~2;
 997         if (in_button7.state  & 3) bits |=  64;in_button7.state &= ~2;
 998         if (in_button8.state  & 3) bits |= 128;in_button8.state &= ~2;
 999         if (in_use.state      & 3) bits |= 256;in_use.state     &= ~2;
1000         if (key_dest != key_game || key_consoleactive) bits |= 512;
1001         if (cl_prydoncursor.integer) bits |= 1024;
1002         if (in_button9.state  & 3)  bits |=   2048;in_button9.state  &= ~2;
1003         if (in_button10.state  & 3) bits |=   4096;in_button10.state &= ~2;
1004         if (in_button11.state  & 3) bits |=   8192;in_button11.state &= ~2;
1005         if (in_button12.state  & 3) bits |=  16384;in_button12.state &= ~2;
1006         if (in_button13.state  & 3) bits |=  32768;in_button13.state &= ~2;
1007         if (in_button14.state  & 3) bits |=  65536;in_button14.state &= ~2;
1008         if (in_button15.state  & 3) bits |= 131072;in_button15.state &= ~2;
1009         if (in_button16.state  & 3) bits |= 262144;in_button16.state &= ~2;
1010         // button bits 19-31 unused currently
1011         // rotate/zoom view serverside if PRYDON_CLIENTCURSOR cursor is at edge of screen
1012         if (cl.cmd.cursor_screen[0] <= -1) bits |= 8;
1013         if (cl.cmd.cursor_screen[0] >=  1) bits |= 16;
1014         if (cl.cmd.cursor_screen[1] <= -1) bits |= 32;
1015         if (cl.cmd.cursor_screen[1] >=  1) bits |= 64;
1016
1017         impulse = in_impulse;
1018         in_impulse = 0;
1019
1020         csqc_buttons = bits;
1021
1022         if (cls.signon == SIGNONS)
1023         {
1024                 // always dump the first two messages, because they may contain leftover inputs from the last level
1025                 if (++cl.movemessages >= 2)
1026                 {
1027                         // send the movement message
1028                         // PROTOCOL_QUAKE        clc_move = 16 bytes total
1029                         // PROTOCOL_QUAKEDP      clc_move = 16 bytes total
1030                         // PROTOCOL_NEHAHRAMOVIE clc_move = 16 bytes total
1031                         // PROTOCOL_DARKPLACES1  clc_move = 19 bytes total
1032                         // PROTOCOL_DARKPLACES2  clc_move = 25 bytes total
1033                         // PROTOCOL_DARKPLACES3  clc_move = 25 bytes total
1034                         // PROTOCOL_DARKPLACES4  clc_move = 19 bytes total
1035                         // PROTOCOL_DARKPLACES5  clc_move = 19 bytes total
1036                         // PROTOCOL_DARKPLACES6  clc_move = 52 bytes total
1037                         // PROTOCOL_DARKPLACES7  clc_move = 56 bytes total
1038                         // PROTOCOL_QUAKEWORLD   clc_move = 34 bytes total (typically, but can reach 43 bytes, or even 49 bytes with roll)
1039                         if (cls.protocol == PROTOCOL_QUAKEWORLD)
1040                         {
1041                                 int checksumindex;
1042                                 double msectime;
1043                                 static double oldmsectime;
1044                                 qw_usercmd_t *cmd, *oldcmd;
1045                                 qw_usercmd_t nullcmd;
1046
1047                                 //Con_Printf("code qw_clc_move\n");
1048
1049                                 i = cls.netcon->qw.outgoing_sequence & QW_UPDATE_MASK;
1050                                 cmd = &cl.qw_moves[i];
1051                                 memset(&nullcmd, 0, sizeof(nullcmd));
1052                                 memset(cmd, 0, sizeof(*cmd));
1053                                 cmd->buttons = bits;
1054                                 cmd->impulse = impulse;
1055                                 cmd->forwardmove = (short)bound(-32768, forwardmove, 32767);
1056                                 cmd->sidemove = (short)bound(-32768, sidemove, 32767);
1057                                 cmd->upmove = (short)bound(-32768, upmove, 32767);
1058                                 VectorCopy(cl.viewangles, cmd->angles);
1059                                 msectime = realtime * 1000;
1060                                 cmd->msec = (unsigned char)bound(0, msectime - oldmsectime, 255);
1061                                 // ridiculous value rejection (matches qw)
1062                                 if (cmd->msec > 250)
1063                                         cmd->msec = 100;
1064                                 oldmsectime = msectime;
1065
1066                                 CL_ClientMovement_InputQW(cmd);
1067
1068                                 MSG_WriteByte(&buf, qw_clc_move);
1069                                 // save the position for a checksum byte
1070                                 checksumindex = buf.cursize;
1071                                 MSG_WriteByte(&buf, 0);
1072                                 // packet loss percentage
1073                                 // FIXME: netgraph stuff
1074                                 MSG_WriteByte(&buf, 0);
1075                                 // write most recent 3 moves
1076                                 i = (cls.netcon->qw.outgoing_sequence-2) & QW_UPDATE_MASK;
1077                                 cmd = &cl.qw_moves[i];
1078                                 QW_MSG_WriteDeltaUsercmd(&buf, &nullcmd, cmd);
1079                                 oldcmd = cmd;
1080                                 i = (cls.netcon->qw.outgoing_sequence-1) & QW_UPDATE_MASK;
1081                                 cmd = &cl.qw_moves[i];
1082                                 QW_MSG_WriteDeltaUsercmd(&buf, oldcmd, cmd);
1083                                 oldcmd = cmd;
1084                                 i = cls.netcon->qw.outgoing_sequence & QW_UPDATE_MASK;
1085                                 cmd = &cl.qw_moves[i];
1086                                 QW_MSG_WriteDeltaUsercmd(&buf, oldcmd, cmd);
1087                                 // calculate the checksum
1088                                 buf.data[checksumindex] = COM_BlockSequenceCRCByteQW(buf.data + checksumindex + 1, buf.cursize - checksumindex - 1, cls.netcon->qw.outgoing_sequence);
1089                                 // if delta compression history overflows, request no delta
1090                                 if (cls.netcon->qw.outgoing_sequence - cl.qw_validsequence >= QW_UPDATE_BACKUP-1)
1091                                         cl.qw_validsequence = 0;
1092                                 // request delta compression if appropriate
1093                                 if (cl.qw_validsequence && !cl_nodelta.integer && cls.state == ca_connected && !cls.demorecording)
1094                                 {
1095                                         cl.qw_deltasequence[cls.netcon->qw.outgoing_sequence & QW_UPDATE_MASK] = cl.qw_validsequence;
1096                                         MSG_WriteByte(&buf, qw_clc_delta);
1097                                         MSG_WriteByte(&buf, cl.qw_validsequence & 255);
1098                                 }
1099                                 else
1100                                         cl.qw_deltasequence[cls.netcon->qw.outgoing_sequence & QW_UPDATE_MASK] = -1;
1101                         }
1102                         else if (cls.protocol == PROTOCOL_QUAKE || cls.protocol == PROTOCOL_QUAKEDP || cls.protocol == PROTOCOL_NEHAHRAMOVIE)
1103                         {
1104                                 // 5 bytes
1105                                 MSG_WriteByte (&buf, clc_move);
1106                                 MSG_WriteFloat (&buf, cl.mtime[0]);     // so server can get ping times
1107                                 // 3 bytes
1108                                 for (i = 0;i < 3;i++)
1109                                         MSG_WriteAngle8i (&buf, cl.viewangles[i]);
1110                                 // 6 bytes
1111                                 MSG_WriteCoord16i (&buf, forwardmove);
1112                                 MSG_WriteCoord16i (&buf, sidemove);
1113                                 MSG_WriteCoord16i (&buf, upmove);
1114                                 // 2 bytes
1115                                 MSG_WriteByte (&buf, bits);
1116                                 MSG_WriteByte (&buf, impulse);
1117
1118                                 CL_ClientMovement_Input((bits & 2) != 0, false);
1119                         }
1120                         else if (cls.protocol == PROTOCOL_DARKPLACES2 || cls.protocol == PROTOCOL_DARKPLACES3)
1121                         {
1122                                 // 5 bytes
1123                                 MSG_WriteByte (&buf, clc_move);
1124                                 MSG_WriteFloat (&buf, cl.mtime[0]);     // so server can get ping times
1125                                 // 12 bytes
1126                                 for (i = 0;i < 3;i++)
1127                                         MSG_WriteAngle32f (&buf, cl.viewangles[i]);
1128                                 // 6 bytes
1129                                 MSG_WriteCoord16i (&buf, forwardmove);
1130                                 MSG_WriteCoord16i (&buf, sidemove);
1131                                 MSG_WriteCoord16i (&buf, upmove);
1132                                 // 2 bytes
1133                                 MSG_WriteByte (&buf, bits);
1134                                 MSG_WriteByte (&buf, impulse);
1135
1136                                 CL_ClientMovement_Input((bits & 2) != 0, false);
1137                         }
1138                         else if (cls.protocol == PROTOCOL_DARKPLACES1 || cls.protocol == PROTOCOL_DARKPLACES4 || cls.protocol == PROTOCOL_DARKPLACES5)
1139                         {
1140                                 // 5 bytes
1141                                 MSG_WriteByte (&buf, clc_move);
1142                                 MSG_WriteFloat (&buf, cl.mtime[0]);     // so server can get ping times
1143                                 // 6 bytes
1144                                 for (i = 0;i < 3;i++)
1145                                         MSG_WriteAngle16i (&buf, cl.viewangles[i]);
1146                                 // 6 bytes
1147                                 MSG_WriteCoord16i (&buf, forwardmove);
1148                                 MSG_WriteCoord16i (&buf, sidemove);
1149                                 MSG_WriteCoord16i (&buf, upmove);
1150                                 // 2 bytes
1151                                 MSG_WriteByte (&buf, bits);
1152                                 MSG_WriteByte (&buf, impulse);
1153
1154                                 CL_ClientMovement_Input((bits & 2) != 0, false);
1155                         }
1156                         else
1157                         {
1158                                 // 5 bytes
1159                                 MSG_WriteByte (&buf, clc_move);
1160                                 if (cls.protocol != PROTOCOL_DARKPLACES6)
1161                                 {
1162                                         if (cl_movement.integer)
1163                                         {
1164                                                 cl.movesequence++;
1165                                                 MSG_WriteLong (&buf, cl.movesequence);
1166                                         }
1167                                         else
1168                                                 MSG_WriteLong (&buf, 0);
1169                                 }
1170                                 MSG_WriteFloat (&buf, cl.mtime[0]);     // so server can get ping times
1171                                 // 6 bytes
1172                                 for (i = 0;i < 3;i++)
1173                                         MSG_WriteAngle16i (&buf, cl.viewangles[i]);
1174                                 // 6 bytes
1175                                 MSG_WriteCoord16i (&buf, forwardmove);
1176                                 MSG_WriteCoord16i (&buf, sidemove);
1177                                 MSG_WriteCoord16i (&buf, upmove);
1178                                 // 5 bytes
1179                                 MSG_WriteLong (&buf, bits);
1180                                 MSG_WriteByte (&buf, impulse);
1181                                 // PRYDON_CLIENTCURSOR
1182                                 // 30 bytes
1183                                 MSG_WriteShort (&buf, cl.cmd.cursor_screen[0] * 32767.0f);
1184                                 MSG_WriteShort (&buf, cl.cmd.cursor_screen[1] * 32767.0f);
1185                                 MSG_WriteFloat (&buf, cl.cmd.cursor_start[0]);
1186                                 MSG_WriteFloat (&buf, cl.cmd.cursor_start[1]);
1187                                 MSG_WriteFloat (&buf, cl.cmd.cursor_start[2]);
1188                                 MSG_WriteFloat (&buf, cl.cmd.cursor_impact[0]);
1189                                 MSG_WriteFloat (&buf, cl.cmd.cursor_impact[1]);
1190                                 MSG_WriteFloat (&buf, cl.cmd.cursor_impact[2]);
1191                                 MSG_WriteShort (&buf, cl.cmd.cursor_entitynumber);
1192
1193                                 // FIXME: bits & 16 is +button5, Nexuiz specific
1194                                 CL_ClientMovement_Input((bits & 2) != 0, (bits & 16) != 0);
1195                         }
1196                 }
1197
1198                 if (cls.protocol != PROTOCOL_QUAKEWORLD)
1199                 {
1200                         // ack the last few frame numbers
1201                         // (redundent to improve handling of client->server packet loss)
1202                         // for LATESTFRAMENUMS == 3 case this is 15 bytes
1203                         for (i = 0;i < LATESTFRAMENUMS;i++)
1204                         {
1205                                 if (cl.latestframenums[i] > 0)
1206                                 {
1207                                         if (developer_networkentities.integer >= 1)
1208                                                 Con_Printf("send clc_ackframe %i\n", cl.latestframenums[i]);
1209                                         MSG_WriteByte(&buf, clc_ackframe);
1210                                         MSG_WriteLong(&buf, cl.latestframenums[i]);
1211                                 }
1212                         }
1213                 }
1214
1215                 // PROTOCOL_DARKPLACES6 = 67 bytes per packet
1216                 // PROTOCOL_DARKPLACES7 = 71 bytes per packet
1217         }
1218
1219         // send the reliable message (forwarded commands) if there is one
1220         NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol);
1221
1222         if (cls.netcon->message.overflowed)
1223         {
1224                 Con_Print("CL_SendMove: lost server connection\n");
1225                 CL_Disconnect();
1226                 Host_ShutdownServer();
1227         }
1228 }
1229
1230 /*
1231 ============
1232 CL_InitInput
1233 ============
1234 */
1235 void CL_InitInput (void)
1236 {
1237         Cmd_AddCommand ("+moveup",IN_UpDown, "swim upward");
1238         Cmd_AddCommand ("-moveup",IN_UpUp, "stop swimming upward");
1239         Cmd_AddCommand ("+movedown",IN_DownDown, "swim downward");
1240         Cmd_AddCommand ("-movedown",IN_DownUp, "stop swimming downward");
1241         Cmd_AddCommand ("+left",IN_LeftDown, "turn left");
1242         Cmd_AddCommand ("-left",IN_LeftUp, "stop turning left");
1243         Cmd_AddCommand ("+right",IN_RightDown, "turn right");
1244         Cmd_AddCommand ("-right",IN_RightUp, "stop turning right");
1245         Cmd_AddCommand ("+forward",IN_ForwardDown, "move forward");
1246         Cmd_AddCommand ("-forward",IN_ForwardUp, "stop moving forward");
1247         Cmd_AddCommand ("+back",IN_BackDown, "move backward");
1248         Cmd_AddCommand ("-back",IN_BackUp, "stop moving backward");
1249         Cmd_AddCommand ("+lookup", IN_LookupDown, "look upward");
1250         Cmd_AddCommand ("-lookup", IN_LookupUp, "stop looking upward");
1251         Cmd_AddCommand ("+lookdown", IN_LookdownDown, "look downward");
1252         Cmd_AddCommand ("-lookdown", IN_LookdownUp, "stop looking downward");
1253         Cmd_AddCommand ("+strafe", IN_StrafeDown, "activate strafing mode (move instead of turn)\n");
1254         Cmd_AddCommand ("-strafe", IN_StrafeUp, "deactivate strafing mode");
1255         Cmd_AddCommand ("+moveleft", IN_MoveleftDown, "strafe left");
1256         Cmd_AddCommand ("-moveleft", IN_MoveleftUp, "stop strafing left");
1257         Cmd_AddCommand ("+moveright", IN_MoverightDown, "strafe right");
1258         Cmd_AddCommand ("-moveright", IN_MoverightUp, "stop strafing right");
1259         Cmd_AddCommand ("+speed", IN_SpeedDown, "activate run mode (faster movement and turning)");
1260         Cmd_AddCommand ("-speed", IN_SpeedUp, "deactivate run mode");
1261         Cmd_AddCommand ("+attack", IN_AttackDown, "begin firing");
1262         Cmd_AddCommand ("-attack", IN_AttackUp, "stop firing");
1263         Cmd_AddCommand ("+jump", IN_JumpDown, "jump");
1264         Cmd_AddCommand ("-jump", IN_JumpUp, "end jump (so you can jump again)");
1265         Cmd_AddCommand ("impulse", IN_Impulse, "send an impulse number to server (select weapon, use item, etc)");
1266         Cmd_AddCommand ("+klook", IN_KLookDown, "activate keyboard looking mode, do not recenter view");
1267         Cmd_AddCommand ("-klook", IN_KLookUp, "deactivate keyboard looking mode");
1268         Cmd_AddCommand ("+mlook", IN_MLookDown, "activate mouse looking mode, do not recenter view");
1269         Cmd_AddCommand ("-mlook", IN_MLookUp, "deactivate mouse looking mode");
1270
1271         // LordHavoc: added use button
1272         Cmd_AddCommand ("+use", IN_UseDown, "use something (may be used by some mods)");
1273         Cmd_AddCommand ("-use", IN_UseUp, "stop using something");
1274
1275         // LordHavoc: added 6 new buttons
1276         Cmd_AddCommand ("+button3", IN_Button3Down, "activate button3 (behavior depends on mod)");
1277         Cmd_AddCommand ("-button3", IN_Button3Up, "deactivate button3");
1278         Cmd_AddCommand ("+button4", IN_Button4Down, "activate button4 (behavior depends on mod)");
1279         Cmd_AddCommand ("-button4", IN_Button4Up, "deactivate button4");
1280         Cmd_AddCommand ("+button5", IN_Button5Down, "activate button5 (behavior depends on mod)");
1281         Cmd_AddCommand ("-button5", IN_Button5Up, "deactivate button5");
1282         Cmd_AddCommand ("+button6", IN_Button6Down, "activate button6 (behavior depends on mod)");
1283         Cmd_AddCommand ("-button6", IN_Button6Up, "deactivate button6");
1284         Cmd_AddCommand ("+button7", IN_Button7Down, "activate button7 (behavior depends on mod)");
1285         Cmd_AddCommand ("-button7", IN_Button7Up, "deactivate button7");
1286         Cmd_AddCommand ("+button8", IN_Button8Down, "activate button8 (behavior depends on mod)");
1287         Cmd_AddCommand ("-button8", IN_Button8Up, "deactivate button8");
1288         Cmd_AddCommand ("+button9", IN_Button9Down, "activate button9 (behavior depends on mod)");
1289         Cmd_AddCommand ("-button9", IN_Button9Up, "deactivate button9");
1290         Cmd_AddCommand ("+button10", IN_Button10Down, "activate button10 (behavior depends on mod)");
1291         Cmd_AddCommand ("-button10", IN_Button10Up, "deactivate button10");
1292         Cmd_AddCommand ("+button11", IN_Button11Down, "activate button11 (behavior depends on mod)");
1293         Cmd_AddCommand ("-button11", IN_Button11Up, "deactivate button11");
1294         Cmd_AddCommand ("+button12", IN_Button12Down, "activate button12 (behavior depends on mod)");
1295         Cmd_AddCommand ("-button12", IN_Button12Up, "deactivate button12");
1296         Cmd_AddCommand ("+button13", IN_Button13Down, "activate button13 (behavior depends on mod)");
1297         Cmd_AddCommand ("-button13", IN_Button13Up, "deactivate button13");
1298         Cmd_AddCommand ("+button14", IN_Button14Down, "activate button14 (behavior depends on mod)");
1299         Cmd_AddCommand ("-button14", IN_Button14Up, "deactivate button14");
1300         Cmd_AddCommand ("+button15", IN_Button15Down, "activate button15 (behavior depends on mod)");
1301         Cmd_AddCommand ("-button15", IN_Button15Up, "deactivate button15");
1302         Cmd_AddCommand ("+button16", IN_Button16Down, "activate button16 (behavior depends on mod)");
1303         Cmd_AddCommand ("-button16", IN_Button16Up, "deactivate button16");
1304
1305         Cvar_RegisterVariable(&cl_movement);
1306         Cvar_RegisterVariable(&cl_movement_latency);
1307         Cvar_RegisterVariable(&cl_movement_maxspeed);
1308         Cvar_RegisterVariable(&cl_movement_maxairspeed);
1309         Cvar_RegisterVariable(&cl_movement_stopspeed);
1310         Cvar_RegisterVariable(&cl_movement_friction);
1311         Cvar_RegisterVariable(&cl_movement_edgefriction);
1312         Cvar_RegisterVariable(&cl_movement_stepheight);
1313         Cvar_RegisterVariable(&cl_movement_accelerate);
1314         Cvar_RegisterVariable(&cl_movement_jumpvelocity);
1315         Cvar_RegisterVariable(&cl_gravity);
1316         Cvar_RegisterVariable(&cl_slowmo);
1317
1318         Cvar_RegisterVariable(&in_pitch_min);
1319         Cvar_RegisterVariable(&in_pitch_max);
1320         Cvar_RegisterVariable(&m_filter);
1321
1322         Cvar_RegisterVariable(&cl_netinputpacketspersecond);
1323
1324         Cvar_RegisterVariable(&cl_nodelta);
1325 }
1326