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
  27 /*
  28 ===============================================================================
  29
  30 KEY BUTTONS
  31
  32 Continuous button event tracking is complicated by the fact that two different
  33 input sources (say, mouse button 1 and the control key) can both press the
  34 same button, but the button should only be released when both of the
  35 pressing key have been released.
  36
  37 When a key event issues a button command (+forward, +attack, etc), it appends
  38 its key number as a parameter to the command so it can be matched up with
  39 the release.
  40
  41 state bit 0 is the current state of the key
  42 state bit 1 is edge triggered on the up to down transition
  43 state bit 2 is edge triggered on the down to up transition
  44
  45 ===============================================================================
  46 */
  47
  48
  49 kbutton_t       in_mlook, in_klook;
  50 kbutton_t       in_left, in_right, in_forward, in_back;
  51 kbutton_t       in_lookup, in_lookdown, in_moveleft, in_moveright;
  52 kbutton_t       in_strafe, in_speed, in_use, in_jump, in_attack;
  53 kbutton_t       in_up, in_down;
  54 // LordHavoc: added 6 new buttons
  55 kbutton_t       in_button3, in_button4, in_button5, in_button6, in_button7, in_button8;
  56
  57 int                     in_impulse;
  58
  59
  60 void KeyDown (kbutton_t *b)
  61 {
  62         int             k;
  63         char    *c;
  64
  65         c = Cmd_Argv(1);
  66         if (c[0])
  67                 k = atoi(c);
  68         else
  69                 k = -1;         // typed manually at the console for continuous down
  70
  71         if (k == b->down[0] || k == b->down[1])
  72                 return;         // repeating key
  73
  74         if (!b->down[0])
  75                 b->down[0] = k;
  76         else if (!b->down[1])
  77                 b->down[1] = k;
  78         else
  79         {
  80                 Con_Printf ("Three keys down for a button!\n");
  81                 return;
  82         }
  83
  84         if (b->state & 1)
  85                 return;         // still down
  86         b->state |= 1 + 2;      // down + impulse down
  87 }
  88
  89 void KeyUp (kbutton_t *b)
  90 {
  91         int             k;
  92         char    *c;
  93
  94         c = Cmd_Argv(1);
  95         if (c[0])
  96                 k = atoi(c);
  97         else
  98         { // typed manually at the console, assume for unsticking, so clear all
  99                 b->down[0] = b->down[1] = 0;
 100                 b->state = 4;   // impulse up
 101                 return;
 102         }
 103
 104         if (b->down[0] == k)
 105                 b->down[0] = 0;
 106         else if (b->down[1] == k)
 107                 b->down[1] = 0;
 108         else
 109                 return;         // key up without coresponding down (menu pass through)
 110         if (b->down[0] || b->down[1])
 111                 return;         // some other key is still holding it down
 112
 113         if (!(b->state & 1))
 114                 return;         // still up (this should not happen)
 115         b->state &= ~1;         // now up
 116         b->state |= 4;          // impulse up
 117 }
 118
 119 void IN_KLookDown (void) {KeyDown(&in_klook);}
 120 void IN_KLookUp (void) {KeyUp(&in_klook);}
 121 void IN_MLookDown (void) {KeyDown(&in_mlook);}
 122 void IN_MLookUp (void) {
 123 KeyUp(&in_mlook);
 124 if ( !(in_mlook.state&1) &&  lookspring.value)
 125         V_StartPitchDrift();
 126 }
 127 void IN_UpDown(void) {KeyDown(&in_up);}
 128 void IN_UpUp(void) {KeyUp(&in_up);}
 129 void IN_DownDown(void) {KeyDown(&in_down);}
 130 void IN_DownUp(void) {KeyUp(&in_down);}
 131 void IN_LeftDown(void) {KeyDown(&in_left);}
 132 void IN_LeftUp(void) {KeyUp(&in_left);}
 133 void IN_RightDown(void) {KeyDown(&in_right);}
 134 void IN_RightUp(void) {KeyUp(&in_right);}
 135 void IN_ForwardDown(void) {KeyDown(&in_forward);}
 136 void IN_ForwardUp(void) {KeyUp(&in_forward);}
 137 void IN_BackDown(void) {KeyDown(&in_back);}
 138 void IN_BackUp(void) {KeyUp(&in_back);}
 139 void IN_LookupDown(void) {KeyDown(&in_lookup);}
 140 void IN_LookupUp(void) {KeyUp(&in_lookup);}
 141 void IN_LookdownDown(void) {KeyDown(&in_lookdown);}
 142 void IN_LookdownUp(void) {KeyUp(&in_lookdown);}
 143 void IN_MoveleftDown(void) {KeyDown(&in_moveleft);}
 144 void IN_MoveleftUp(void) {KeyUp(&in_moveleft);}
 145 void IN_MoverightDown(void) {KeyDown(&in_moveright);}
 146 void IN_MoverightUp(void) {KeyUp(&in_moveright);}
 147
 148 void IN_SpeedDown(void) {KeyDown(&in_speed);}
 149 void IN_SpeedUp(void) {KeyUp(&in_speed);}
 150 void IN_StrafeDown(void) {KeyDown(&in_strafe);}
 151 void IN_StrafeUp(void) {KeyUp(&in_strafe);}
 152
 153 void IN_AttackDown(void) {KeyDown(&in_attack);}
 154 void IN_AttackUp(void) {KeyUp(&in_attack);}
 155
 156 // LordHavoc: added 6 new buttons
 157 void IN_Button3Down(void) {KeyDown(&in_button3);} void IN_Button3Up(void) {KeyUp(&in_button3);}
 158 void IN_Button4Down(void) {KeyDown(&in_button4);} void IN_Button4Up(void) {KeyUp(&in_button4);}
 159 void IN_Button5Down(void) {KeyDown(&in_button5);} void IN_Button5Up(void) {KeyUp(&in_button5);}
 160 void IN_Button6Down(void) {KeyDown(&in_button6);} void IN_Button6Up(void) {KeyUp(&in_button6);}
 161 void IN_Button7Down(void) {KeyDown(&in_button7);} void IN_Button7Up(void) {KeyUp(&in_button7);}
 162 void IN_Button8Down(void) {KeyDown(&in_button8);} void IN_Button8Up(void) {KeyUp(&in_button8);}
 163
 164 void IN_UseDown (void) {KeyDown(&in_use);}
 165 void IN_UseUp (void) {KeyUp(&in_use);}
 166 void IN_JumpDown (void) {KeyDown(&in_jump);}
 167 void IN_JumpUp (void) {KeyUp(&in_jump);}
 168
 169 void IN_Impulse (void) {in_impulse=atoi(Cmd_Argv(1));}
 170
 171 /*
 172 ===============
 173 CL_KeyState
 174
 175 Returns 0.25 if a key was pressed and released during the frame,
 176 0.5 if it was pressed and held
 177 0 if held then released, and
 178 1.0 if held for the entire time
 179 ===============
 180 */
 181 float CL_KeyState (kbutton_t *key)
 182 {
 183         float           val;
 184         qboolean        impulsedown, impulseup, down;
 185
 186         impulsedown = key->state & 2;
 187         impulseup = key->state & 4;
 188         down = key->state & 1;
 189         val = 0;
 190
 191         if (impulsedown && !impulseup)
 192         {
 193                 if (down)
 194                         val = 0.5;      // pressed and held this frame
 195                 else
 196                         val = 0;        //      I_Error ();
 197         }
 198         if (impulseup && !impulsedown)
 199         {
 200                 if (down)
 201                         val = 0;        //      I_Error ();
 202                 else
 203                         val = 0;        // released this frame
 204         }
 205         if (!impulsedown && !impulseup)
 206         {
 207                 if (down)
 208                         val = 1.0;      // held the entire frame
 209                 else
 210                         val = 0;        // up the entire frame
 211         }
 212         if (impulsedown && impulseup)
 213         {
 214                 if (down)
 215                         val = 0.75;     // released and re-pressed this frame
 216                 else
 217                         val = 0.25;     // pressed and released this frame
 218         }
 219
 220         key->state &= 1;                // clear impulses
 221
 222         return val;
 223 }
 224
 225
 226
 227
 228 //==========================================================================
 229
 230 cvar_t cl_upspeed = {CVAR_SAVE, "cl_upspeed","400"};
 231 cvar_t cl_forwardspeed = {CVAR_SAVE, "cl_forwardspeed","400"};
 232 cvar_t cl_backspeed = {CVAR_SAVE, "cl_backspeed","400"};
 233 cvar_t cl_sidespeed = {CVAR_SAVE, "cl_sidespeed","350"};
 234
 235 cvar_t cl_movespeedkey = {CVAR_SAVE, "cl_movespeedkey","2.0"};
 236
 237 cvar_t cl_yawspeed = {CVAR_SAVE, "cl_yawspeed","140"};
 238 cvar_t cl_pitchspeed = {CVAR_SAVE, "cl_pitchspeed","150"};
 239
 240 cvar_t cl_anglespeedkey = {CVAR_SAVE, "cl_anglespeedkey","1.5"};
 241
 242
 243 /*
 244 ================
 245 CL_AdjustAngles
 246
 247 Moves the local angle positions
 248 ================
 249 */
 250 void CL_AdjustAngles (void)
 251 {
 252         float   speed;
 253         float   up, down;
 254
 255         if (in_speed.state & 1)
 256                 speed = cl.frametime * cl_anglespeedkey.value;
 257         else
 258                 speed = cl.frametime;
 259
 260         if (!(in_strafe.state & 1))
 261         {
 262                 cl.viewangles[YAW] -= speed*cl_yawspeed.value*CL_KeyState (&in_right);
 263                 cl.viewangles[YAW] += speed*cl_yawspeed.value*CL_KeyState (&in_left);
 264         }
 265         if (in_klook.state & 1)
 266         {
 267                 V_StopPitchDrift ();
 268                 cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * CL_KeyState (&in_forward);
 269                 cl.viewangles[PITCH] += speed*cl_pitchspeed.value * CL_KeyState (&in_back);
 270         }
 271
 272         up = CL_KeyState (&in_lookup);
 273         down = CL_KeyState(&in_lookdown);
 274
 275         cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * up;
 276         cl.viewangles[PITCH] += speed*cl_pitchspeed.value * down;
 277
 278         if (up || down)
 279                 V_StopPitchDrift ();
 280
 281         cl.viewangles[YAW] = ANGLEMOD(cl.viewangles[YAW]);
 282         cl.viewangles[PITCH] = ANGLEMOD(cl.viewangles[PITCH]);
 283         cl.viewangles[ROLL] = ANGLEMOD(cl.viewangles[ROLL]);
 284
 285         cl.viewangles[PITCH] = bound (in_pitch_min.value, cl.viewangles[PITCH], in_pitch_max.value);
 286         cl.viewangles[ROLL] = bound(-50, cl.viewangles[ROLL], 50);
 287 }
 288
 289 /*
 290 ================
 291 CL_BaseMove
 292
 293 Send the intended movement message to the server
 294 ================
 295 */
 296 void CL_BaseMove (usercmd_t *cmd)
 297 {
 298         if (cls.signon != SIGNONS)
 299                 return;
 300
 301         CL_AdjustAngles ();
 302
 303         memset (cmd, 0, sizeof(*cmd));
 304
 305         if (in_strafe.state & 1)
 306         {
 307                 cmd->sidemove += cl_sidespeed.value * CL_KeyState (&in_right);
 308                 cmd->sidemove -= cl_sidespeed.value * CL_KeyState (&in_left);
 309         }
 310
 311         cmd->sidemove += cl_sidespeed.value * CL_KeyState (&in_moveright);
 312         cmd->sidemove -= cl_sidespeed.value * CL_KeyState (&in_moveleft);
 313
 314         cmd->upmove += cl_upspeed.value * CL_KeyState (&in_up);
 315         cmd->upmove -= cl_upspeed.value * CL_KeyState (&in_down);
 316
 317         if (! (in_klook.state & 1) )
 318         {
 319                 cmd->forwardmove += cl_forwardspeed.value * CL_KeyState (&in_forward);
 320                 cmd->forwardmove -= cl_backspeed.value * CL_KeyState (&in_back);
 321         }
 322
 323 //
 324 // adjust for speed key
 325 //
 326         if (in_speed.state & 1)
 327         {
 328                 cmd->forwardmove *= cl_movespeedkey.value;
 329                 cmd->sidemove *= cl_movespeedkey.value;
 330                 cmd->upmove *= cl_movespeedkey.value;
 331         }
 332 }
 333
 334
 335
 336 /*
 337 ==============
 338 CL_SendMove
 339 ==============
 340 */
 341 void CL_SendMove (usercmd_t *cmd)
 342 {
 343         int             i;
 344         int             bits;
 345         sizebuf_t       buf;
 346         qbyte   data[128];
 347         static double lastmovetime;
 348         static float forwardmove, sidemove, upmove, total; // accumulation
 349
 350         forwardmove += cmd->forwardmove;
 351         sidemove += cmd->sidemove;
 352         upmove += cmd->upmove;
 353         total++;
 354         // LordHavoc: cap outgoing movement messages to sys_ticrate
 355         if ((cl.maxclients > 1) && (realtime - lastmovetime < sys_ticrate.value))
 356                 return;
 357         lastmovetime = realtime;
 358         // average what has happened during this time
 359         total = 1.0f / total;
 360         forwardmove *= total;
 361         sidemove *= total;
 362         upmove *= total;
 363         total = 0;
 364
 365         buf.maxsize = 128;
 366         buf.cursize = 0;
 367         buf.data = data;
 368
 369         cl.cmd = *cmd;
 370
 371 //
 372 // send the movement message
 373 //
 374     MSG_WriteByte (&buf, clc_move);
 375
 376         MSG_WriteFloat (&buf, cl.mtime[0]);     // so server can get ping times
 377
 378         if (dpprotocol == DPPROTOCOL_VERSION2)
 379         {
 380                 for (i = 0;i < 3;i++)
 381                         MSG_WriteFloat (&buf, cl.viewangles[i]);
 382         }
 383         else if (dpprotocol == DPPROTOCOL_VERSION1)
 384         {
 385                 for (i=0 ; i<3 ; i++)
 386                         MSG_WritePreciseAngle (&buf, cl.viewangles[i]);
 387         }
 388         else
 389         {
 390                 for (i=0 ; i<3 ; i++)
 391                         MSG_WriteAngle (&buf, cl.viewangles[i]);
 392         }
 393
 394     MSG_WriteShort (&buf, forwardmove);
 395     MSG_WriteShort (&buf, sidemove);
 396     MSG_WriteShort (&buf, upmove);
 397
 398         forwardmove = sidemove = upmove = 0;
 399 //
 400 // send button bits
 401 //
 402         bits = 0;
 403
 404         if ( in_attack.state & 3 )
 405                 bits |= 1;
 406         in_attack.state &= ~2;
 407
 408         if (in_jump.state & 3)
 409                 bits |= 2;
 410         in_jump.state &= ~2;
 411         // LordHavoc: added 6 new buttons
 412         if (in_button3.state & 3) bits |=   4;in_button3.state &= ~2;
 413         if (in_button4.state & 3) bits |=   8;in_button4.state &= ~2;
 414         if (in_button5.state & 3) bits |=  16;in_button5.state &= ~2;
 415         if (in_button6.state & 3) bits |=  32;in_button6.state &= ~2;
 416         if (in_button7.state & 3) bits |=  64;in_button7.state &= ~2;
 417         if (in_button8.state & 3) bits |= 128;in_button8.state &= ~2;
 418
 419     MSG_WriteByte (&buf, bits);
 420
 421     MSG_WriteByte (&buf, in_impulse);
 422         in_impulse = 0;
 423
 424         // LordHavoc: should we ack this on receipt instead?  would waste net bandwidth though
 425         i = EntityFrame_MostRecentlyRecievedFrameNum(&cl.entitydatabase);
 426         if (i > 0)
 427         {
 428                 MSG_WriteByte (&buf, clc_ackentities);
 429                 MSG_WriteLong (&buf, i);
 430         }
 431
 432 //
 433 // deliver the message
 434 //
 435         if (cls.demoplayback)
 436                 return;
 437
 438 //
 439 // always dump the first two messages, because they may contain leftover inputs from the last level
 440 //
 441         if (++cl.movemessages <= 2)
 442                 return;
 443
 444         if (NET_SendUnreliableMessage (cls.netcon, &buf) == -1)
 445         {
 446                 Con_Printf ("CL_SendMove: lost server connection\n");
 447                 CL_Disconnect ();
 448         }
 449 }
 450
 451 /*
 452 ============
 453 CL_InitInput
 454 ============
 455 */
 456 void CL_InitInput (void)
 457 {
 458         Cmd_AddCommand ("+moveup",IN_UpDown);
 459         Cmd_AddCommand ("-moveup",IN_UpUp);
 460         Cmd_AddCommand ("+movedown",IN_DownDown);
 461         Cmd_AddCommand ("-movedown",IN_DownUp);
 462         Cmd_AddCommand ("+left",IN_LeftDown);
 463         Cmd_AddCommand ("-left",IN_LeftUp);
 464         Cmd_AddCommand ("+right",IN_RightDown);
 465         Cmd_AddCommand ("-right",IN_RightUp);
 466         Cmd_AddCommand ("+forward",IN_ForwardDown);
 467         Cmd_AddCommand ("-forward",IN_ForwardUp);
 468         Cmd_AddCommand ("+back",IN_BackDown);
 469         Cmd_AddCommand ("-back",IN_BackUp);
 470         Cmd_AddCommand ("+lookup", IN_LookupDown);
 471         Cmd_AddCommand ("-lookup", IN_LookupUp);
 472         Cmd_AddCommand ("+lookdown", IN_LookdownDown);
 473         Cmd_AddCommand ("-lookdown", IN_LookdownUp);
 474         Cmd_AddCommand ("+strafe", IN_StrafeDown);
 475         Cmd_AddCommand ("-strafe", IN_StrafeUp);
 476         Cmd_AddCommand ("+moveleft", IN_MoveleftDown);
 477         Cmd_AddCommand ("-moveleft", IN_MoveleftUp);
 478         Cmd_AddCommand ("+moveright", IN_MoverightDown);
 479         Cmd_AddCommand ("-moveright", IN_MoverightUp);
 480         Cmd_AddCommand ("+speed", IN_SpeedDown);
 481         Cmd_AddCommand ("-speed", IN_SpeedUp);
 482         Cmd_AddCommand ("+attack", IN_AttackDown);
 483         Cmd_AddCommand ("-attack", IN_AttackUp);
 484         Cmd_AddCommand ("+use", IN_UseDown);
 485         Cmd_AddCommand ("-use", IN_UseUp);
 486         Cmd_AddCommand ("+jump", IN_JumpDown);
 487         Cmd_AddCommand ("-jump", IN_JumpUp);
 488         Cmd_AddCommand ("impulse", IN_Impulse);
 489         Cmd_AddCommand ("+klook", IN_KLookDown);
 490         Cmd_AddCommand ("-klook", IN_KLookUp);
 491         Cmd_AddCommand ("+mlook", IN_MLookDown);
 492         Cmd_AddCommand ("-mlook", IN_MLookUp);
 493
 494         // LordHavoc: added 6 new buttons
 495         Cmd_AddCommand ("+button3", IN_Button3Down);
 496         Cmd_AddCommand ("-button3", IN_Button3Up);
 497         Cmd_AddCommand ("+button4", IN_Button4Down);
 498         Cmd_AddCommand ("-button4", IN_Button4Up);
 499         Cmd_AddCommand ("+button5", IN_Button5Down);
 500         Cmd_AddCommand ("-button5", IN_Button5Up);
 501         Cmd_AddCommand ("+button6", IN_Button6Down);
 502         Cmd_AddCommand ("-button6", IN_Button6Up);
 503         Cmd_AddCommand ("+button7", IN_Button7Down);
 504         Cmd_AddCommand ("-button7", IN_Button7Up);
 505         Cmd_AddCommand ("+button8", IN_Button8Down);
 506         Cmd_AddCommand ("-button8", IN_Button8Up);
 507 }