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