#include "client.h"

Functions
void	KeyDown (kbutton_t *b)

void	KeyUp (kbutton_t *b)

void	IN_KLookDown (void)

void	IN_KLookUp (void)

void	IN_UpDown (void)

void	IN_UpUp (void)

void	IN_DownDown (void)

void	IN_DownUp (void)

void	IN_LeftDown (void)

void	IN_LeftUp (void)

void	IN_RightDown (void)

void	IN_RightUp (void)

void	IN_ForwardDown (void)

void	IN_ForwardUp (void)

void	IN_BackDown (void)

void	IN_BackUp (void)

void	IN_LookupDown (void)

void	IN_LookupUp (void)

void	IN_LookdownDown (void)

void	IN_LookdownUp (void)

void	IN_MoveleftDown (void)

void	IN_MoveleftUp (void)

void	IN_MoverightDown (void)

void	IN_MoverightUp (void)

void	IN_SpeedDown (void)

void	IN_SpeedUp (void)

void	IN_StrafeDown (void)

void	IN_StrafeUp (void)

void	IN_AttackDown (void)

void	IN_AttackUp (void)

void	IN_UseDown (void)

void	IN_UseUp (void)

void	IN_Impulse (void)

float	CL_KeyState (kbutton_t *key)

void	CL_AdjustAngles (void)

void	CL_BaseMove (usercmd_t *cmd)

void	CL_ClampPitch (void)

void	CL_FinishMove (usercmd_t *cmd)

usercmd_t	CL_CreateCmd (void)

void	IN_CenterView (void)

void	CL_InitInput (void)

void	CL_SendCmd (void)

Variables
cvar_t *	cl_nodelta

unsigned	sys_frame_time

unsigned	frame_msec

unsigned	old_sys_frame_time

kbutton_t	in_klook

kbutton_t	in_left

kbutton_t	in_right

kbutton_t	in_forward

kbutton_t	in_back

kbutton_t	in_lookup

kbutton_t	in_lookdown

kbutton_t	in_moveleft

kbutton_t	in_moveright

kbutton_t	in_strafe

kbutton_t	in_speed

kbutton_t	in_use

kbutton_t	in_attack

kbutton_t	in_up

kbutton_t	in_down

int	in_impulse

cvar_t *	cl_upspeed

cvar_t *	cl_forwardspeed

cvar_t *	cl_sidespeed

cvar_t *	cl_yawspeed

cvar_t *	cl_pitchspeed

cvar_t *	cl_run

cvar_t *	cl_anglespeedkey

Function Documentation

◆ CL_AdjustAngles()

void CL_AdjustAngles ( void )

Definition at line 241 of file cl_input.c.

 {
     float   speed;
     float   up, down;
     
     if (in_speed.state & 1)
         speed = cls.frametime * cl_anglespeedkey->value;
     else
         speed = cls.frametime;
  
     if (!(in_strafe.state & 1))
     {
         cl.viewangles[YAW] -= speed*cl_yawspeed->value*CL_KeyState (&in_right);
         cl.viewangles[YAW] += speed*cl_yawspeed->value*CL_KeyState (&in_left);
     }
     if (in_klook.state & 1)
     {
         cl.viewangles[PITCH] -= speed*cl_pitchspeed->value * CL_KeyState (&in_forward);
         cl.viewangles[PITCH] += speed*cl_pitchspeed->value * CL_KeyState (&in_back);
     }
     
     up = CL_KeyState (&in_lookup);
     down = CL_KeyState(&in_lookdown);
     
     cl.viewangles[PITCH] -= speed*cl_pitchspeed->value * up;
     cl.viewangles[PITCH] += speed*cl_pitchspeed->value * down;
 }

Referenced by CL_BaseMove().

◆ CL_BaseMove()

void CL_BaseMove ( usercmd_t * cmd )

Definition at line 276 of file cl_input.c.

 {   
     CL_AdjustAngles ();
     
     memset (cmd, 0, sizeof(*cmd));
     
     VectorCopy (cl.viewangles, cmd->angles);
     if (in_strafe.state & 1)
     {
         cmd->sidemove += cl_sidespeed->value * CL_KeyState (&in_right);
         cmd->sidemove -= cl_sidespeed->value * CL_KeyState (&in_left);
     }
  
     cmd->sidemove += cl_sidespeed->value * CL_KeyState (&in_moveright);
     cmd->sidemove -= cl_sidespeed->value * CL_KeyState (&in_moveleft);
  
     cmd->upmove += cl_upspeed->value * CL_KeyState (&in_up);
     cmd->upmove -= cl_upspeed->value * CL_KeyState (&in_down);
  
     if (! (in_klook.state & 1) )
     {   
         cmd->forwardmove += cl_forwardspeed->value * CL_KeyState (&in_forward);
         cmd->forwardmove -= cl_forwardspeed->value * CL_KeyState (&in_back);
     }   
  
 //
 // adjust for speed key / running
 //
     if ( (in_speed.state & 1) ^ (int)(cl_run->value) )
     {
         cmd->forwardmove *= 2;
         cmd->sidemove *= 2;
         cmd->upmove *= 2;
     }   
 }

Referenced by CL_CreateCmd().

◆ CL_ClampPitch()

void CL_ClampPitch ( void )

Definition at line 312 of file cl_input.c.

 {
     float   pitch;
  
     pitch = SHORT2ANGLE(cl.frame.playerstate.pmove.delta_angles[PITCH]);
     if (pitch > 180)
         pitch -= 360;
  
     if (cl.viewangles[PITCH] + pitch < -360)
         cl.viewangles[PITCH] += 360; // wrapped
     if (cl.viewangles[PITCH] + pitch > 360)
         cl.viewangles[PITCH] -= 360; // wrapped
  
     if (cl.viewangles[PITCH] + pitch > 89)
         cl.viewangles[PITCH] = 89 - pitch;
     if (cl.viewangles[PITCH] + pitch < -89)
         cl.viewangles[PITCH] = -89 - pitch;
 }

Referenced by CL_FinishMove().

◆ CL_CreateCmd()

usercmd_t CL_CreateCmd ( void )

Definition at line 377 of file cl_input.c.

 {
     usercmd_t   cmd;
  
     frame_msec = sys_frame_time - old_sys_frame_time;
     if (frame_msec < 1)
         frame_msec = 1;
     if (frame_msec > 200)
         frame_msec = 200;
     
     // get basic movement from keyboard
     CL_BaseMove (&cmd);
  
     // allow mice or other external controllers to add to the move
     IN_Move (&cmd);
  
     CL_FinishMove (&cmd);
  
     old_sys_frame_time = sys_frame_time;
  
 //cmd.impulse = cls.framecount;
  
     return cmd;
 }

Referenced by CL_SendCmd().

◆ CL_FinishMove()

void CL_FinishMove ( usercmd_t * cmd )

Definition at line 336 of file cl_input.c.

 {
     int     ms;
     int     i;
  
 //
 // figure button bits
 //  
     if ( in_attack.state & 3 )
         cmd->buttons |= BUTTON_ATTACK;
     in_attack.state &= ~2;
     
     if (in_use.state & 3)
         cmd->buttons |= BUTTON_USE;
     in_use.state &= ~2;
  
     if (anykeydown && cls.key_dest == key_game)
         cmd->buttons |= BUTTON_ANY;
  
     // send milliseconds of time to apply the move
     ms = cls.frametime * 1000;
     if (ms > 250)
         ms = 100;       // time was unreasonable
     cmd->msec = ms;
  
     CL_ClampPitch ();
     for (i=0 ; i<3 ; i++)
         cmd->angles[i] = ANGLE2SHORT(cl.viewangles[i]);
  
     cmd->impulse = in_impulse;
     in_impulse = 0;
  
 // send the ambient light level at the player's current position
     cmd->lightlevel = (byte)cl_lightlevel->value;
 }

Referenced by CL_CreateCmd().

◆ CL_InitInput()

void CL_InitInput ( void )

Definition at line 413 of file cl_input.c.

 {
     Cmd_AddCommand ("centerview",IN_CenterView);
  
     Cmd_AddCommand ("+moveup",IN_UpDown);
     Cmd_AddCommand ("-moveup",IN_UpUp);
     Cmd_AddCommand ("+movedown",IN_DownDown);
     Cmd_AddCommand ("-movedown",IN_DownUp);
     Cmd_AddCommand ("+left",IN_LeftDown);
     Cmd_AddCommand ("-left",IN_LeftUp);
     Cmd_AddCommand ("+right",IN_RightDown);
     Cmd_AddCommand ("-right",IN_RightUp);
     Cmd_AddCommand ("+forward",IN_ForwardDown);
     Cmd_AddCommand ("-forward",IN_ForwardUp);
     Cmd_AddCommand ("+back",IN_BackDown);
     Cmd_AddCommand ("-back",IN_BackUp);
     Cmd_AddCommand ("+lookup", IN_LookupDown);
     Cmd_AddCommand ("-lookup", IN_LookupUp);
     Cmd_AddCommand ("+lookdown", IN_LookdownDown);
     Cmd_AddCommand ("-lookdown", IN_LookdownUp);
     Cmd_AddCommand ("+strafe", IN_StrafeDown);
     Cmd_AddCommand ("-strafe", IN_StrafeUp);
     Cmd_AddCommand ("+moveleft", IN_MoveleftDown);
     Cmd_AddCommand ("-moveleft", IN_MoveleftUp);
     Cmd_AddCommand ("+moveright", IN_MoverightDown);
     Cmd_AddCommand ("-moveright", IN_MoverightUp);
     Cmd_AddCommand ("+speed", IN_SpeedDown);
     Cmd_AddCommand ("-speed", IN_SpeedUp);
     Cmd_AddCommand ("+attack", IN_AttackDown);
     Cmd_AddCommand ("-attack", IN_AttackUp);
     Cmd_AddCommand ("+use", IN_UseDown);
     Cmd_AddCommand ("-use", IN_UseUp);
     Cmd_AddCommand ("impulse", IN_Impulse);
     Cmd_AddCommand ("+klook", IN_KLookDown);
     Cmd_AddCommand ("-klook", IN_KLookUp);
  
     cl_nodelta = Cvar_Get ("cl_nodelta", "0", 0);
 }

Referenced by CL_InitLocal().

◆ CL_KeyState()

float CL_KeyState ( kbutton_t * key )

Definition at line 185 of file cl_input.c.

 {
     float       val;
     int         msec;
  
     key->state &= 1;        // clear impulses
  
     msec = key->msec;
     key->msec = 0;
  
     if (key->state)
     {   // still down
         msec += sys_frame_time - key->downtime;
         key->downtime = sys_frame_time;
     }
  
 #if 0
     if (msec)
     {
         Com_Printf ("%i ", msec);
     }
 #endif
  
     val = (float)msec / frame_msec;
     if (val < 0)
         val = 0;
     if (val > 1)
         val = 1;
  
     return val;
 }

Referenced by CL_AdjustAngles(), and CL_BaseMove().

◆ CL_SendCmd()

void CL_SendCmd ( void )

Definition at line 459 of file cl_input.c.

 {
     sizebuf_t   buf;
     byte        data[128];
     int         i;
     usercmd_t   *cmd, *oldcmd;
     usercmd_t   nullcmd;
     int         checksumIndex;
  
     // build a command even if not connected
  
     // save this command off for prediction
     i = cls.netchan.outgoing_sequence & (CMD_BACKUP-1);
     cmd = &cl.cmds[i];
     cl.cmd_time[i] = cls.realtime;  // for netgraph ping calculation
  
     *cmd = CL_CreateCmd ();
  
     cl.cmd = *cmd;
  
     if (cls.state == ca_disconnected || cls.state == ca_connecting)
         return;
  
     if ( cls.state == ca_connected)
     {
         if (cls.netchan.message.cursize || curtime - cls.netchan.last_sent > 1000 )
             Netchan_Transmit (&cls.netchan, 0, buf.data);   
         return;
     }
  
     // send a userinfo update if needed
     if (userinfo_modified)
     {
         CL_FixUpGender();
         userinfo_modified = false;
         MSG_WriteByte (&cls.netchan.message, clc_userinfo);
         MSG_WriteString (&cls.netchan.message, Cvar_Userinfo() );
     }
  
     SZ_Init (&buf, data, sizeof(data));
  
     if (cmd->buttons && cl.cinematictime > 0 && !cl.attractloop 
         && cls.realtime - cl.cinematictime > 1000)
     {   // skip the rest of the cinematic
         SCR_FinishCinematic ();
     }
  
     // begin a client move command
     MSG_WriteByte (&buf, clc_move);
  
     // save the position for a checksum byte
     checksumIndex = buf.cursize;
     MSG_WriteByte (&buf, 0);
  
     // let the server know what the last frame we
     // got was, so the next message can be delta compressed
     if (cl_nodelta->value || !cl.frame.valid || cls.demowaiting)
         MSG_WriteLong (&buf, -1);   // no compression
     else
         MSG_WriteLong (&buf, cl.frame.serverframe);
  
     // send this and the previous cmds in the message, so
     // if the last packet was dropped, it can be recovered
     i = (cls.netchan.outgoing_sequence-2) & (CMD_BACKUP-1);
     cmd = &cl.cmds[i];
     memset (&nullcmd, 0, sizeof(nullcmd));
     MSG_WriteDeltaUsercmd (&buf, &nullcmd, cmd);
     oldcmd = cmd;
  
     i = (cls.netchan.outgoing_sequence-1) & (CMD_BACKUP-1);
     cmd = &cl.cmds[i];
     MSG_WriteDeltaUsercmd (&buf, oldcmd, cmd);
     oldcmd = cmd;
  
     i = (cls.netchan.outgoing_sequence) & (CMD_BACKUP-1);
     cmd = &cl.cmds[i];
     MSG_WriteDeltaUsercmd (&buf, oldcmd, cmd);
  
     // calculate a checksum over the move commands
     buf.data[checksumIndex] = COM_BlockSequenceCRCByte(
         buf.data + checksumIndex + 1, buf.cursize - checksumIndex - 1,
         cls.netchan.outgoing_sequence);
  
     //
     // deliver the message
     //
     Netchan_Transmit (&cls.netchan, buf.cursize, buf.data); 
 }

Referenced by CL_SendCommand().

◆ IN_AttackDown()

void IN_AttackDown ( void )

Definition at line 170 of file cl_input.c.

170 {KeyDown(&in_attack);}

Referenced by CL_InitInput().

◆ IN_AttackUp()

void IN_AttackUp ( void )

Definition at line 171 of file cl_input.c.

171 {KeyUp(&in_attack);}

Referenced by CL_InitInput().

◆ IN_BackDown()

void IN_BackDown ( void )

Definition at line 154 of file cl_input.c.

154 {KeyDown(&in_back);}

Referenced by CL_InitInput().

◆ IN_BackUp()

void IN_BackUp ( void )

Definition at line 155 of file cl_input.c.

155 {KeyUp(&in_back);}

Referenced by CL_InitInput().

◆ IN_CenterView()

void IN_CenterView ( void )

Definition at line 403 of file cl_input.c.

 {
     cl.viewangles[PITCH] = -SHORT2ANGLE(cl.frame.playerstate.pmove.delta_angles[PITCH]);
 }

Referenced by CL_InitInput(), and IN_MLookUp().

◆ IN_DownDown()

void IN_DownDown ( void )

Definition at line 146 of file cl_input.c.

146 {KeyDown(&in_down);}

Referenced by CL_InitInput().

◆ IN_DownUp()

void IN_DownUp ( void )

Definition at line 147 of file cl_input.c.

147 {KeyUp(&in_down);}

Referenced by CL_InitInput().

◆ IN_ForwardDown()

void IN_ForwardDown ( void )

Definition at line 152 of file cl_input.c.

152 {KeyDown(&in_forward);}

Referenced by CL_InitInput().

◆ IN_ForwardUp()

void IN_ForwardUp ( void )

Definition at line 153 of file cl_input.c.

153 {KeyUp(&in_forward);}

Referenced by CL_InitInput().

◆ IN_Impulse()

void IN_Impulse ( void )

Definition at line 176 of file cl_input.c.

176 {in_impulse=atoi(Cmd_Argv(1));}

Referenced by CL_InitInput().

◆ IN_KLookDown()

void IN_KLookDown ( void )

Definition at line 142 of file cl_input.c.

142 {KeyDown(&in_klook);}

Referenced by CL_InitInput().

◆ IN_KLookUp()

void IN_KLookUp ( void )

Definition at line 143 of file cl_input.c.

143 {KeyUp(&in_klook);}

Referenced by CL_InitInput().

◆ IN_LeftDown()

void IN_LeftDown ( void )

Definition at line 148 of file cl_input.c.

148 {KeyDown(&in_left);}

Referenced by CL_InitInput().

◆ IN_LeftUp()

void IN_LeftUp ( void )

Definition at line 149 of file cl_input.c.

149 {KeyUp(&in_left);}

Referenced by CL_InitInput().

◆ IN_LookdownDown()

void IN_LookdownDown ( void )

Definition at line 158 of file cl_input.c.

158 {KeyDown(&in_lookdown);}

Referenced by CL_InitInput().

◆ IN_LookdownUp()

void IN_LookdownUp ( void )

Definition at line 159 of file cl_input.c.

159 {KeyUp(&in_lookdown);}

Referenced by CL_InitInput().

◆ IN_LookupDown()

void IN_LookupDown ( void )

Definition at line 156 of file cl_input.c.

156 {KeyDown(&in_lookup);}

Referenced by CL_InitInput().

◆ IN_LookupUp()

void IN_LookupUp ( void )

Definition at line 157 of file cl_input.c.

157 {KeyUp(&in_lookup);}

Referenced by CL_InitInput().

◆ IN_MoveleftDown()

void IN_MoveleftDown ( void )

Definition at line 160 of file cl_input.c.

160 {KeyDown(&in_moveleft);}

Referenced by CL_InitInput().

◆ IN_MoveleftUp()

void IN_MoveleftUp ( void )

Definition at line 161 of file cl_input.c.

161 {KeyUp(&in_moveleft);}

Referenced by CL_InitInput().

◆ IN_MoverightDown()

void IN_MoverightDown ( void )

Definition at line 162 of file cl_input.c.

162 {KeyDown(&in_moveright);}

Referenced by CL_InitInput().

◆ IN_MoverightUp()

void IN_MoverightUp ( void )

Definition at line 163 of file cl_input.c.

163 {KeyUp(&in_moveright);}

Referenced by CL_InitInput().

◆ IN_RightDown()

void IN_RightDown ( void )

Definition at line 150 of file cl_input.c.

150 {KeyDown(&in_right);}

Referenced by CL_InitInput().

◆ IN_RightUp()

void IN_RightUp ( void )

Definition at line 151 of file cl_input.c.

151 {KeyUp(&in_right);}

Referenced by CL_InitInput().

◆ IN_SpeedDown()

void IN_SpeedDown ( void )

Definition at line 165 of file cl_input.c.

165 {KeyDown(&in_speed);}

Referenced by CL_InitInput().

◆ IN_SpeedUp()

void IN_SpeedUp ( void )

Definition at line 166 of file cl_input.c.

166 {KeyUp(&in_speed);}

Referenced by CL_InitInput().

◆ IN_StrafeDown()

void IN_StrafeDown ( void )

Definition at line 167 of file cl_input.c.

167 {KeyDown(&in_strafe);}

Referenced by CL_InitInput().

◆ IN_StrafeUp()

void IN_StrafeUp ( void )

Definition at line 168 of file cl_input.c.

168 {KeyUp(&in_strafe);}

Referenced by CL_InitInput().

◆ IN_UpDown()

void IN_UpDown ( void )

Definition at line 144 of file cl_input.c.

144 {KeyDown(&in_up);}

Referenced by CL_InitInput().

◆ IN_UpUp()

void IN_UpUp ( void )

Definition at line 145 of file cl_input.c.

145 {KeyUp(&in_up);}

Referenced by CL_InitInput().

◆ IN_UseDown()

void IN_UseDown ( void )

Definition at line 173 of file cl_input.c.

173 {KeyDown(&in_use);}

Referenced by CL_InitInput().

◆ IN_UseUp()

void IN_UseUp ( void )

Definition at line 174 of file cl_input.c.

174 {KeyUp(&in_use);}

Referenced by CL_InitInput().

◆ KeyDown()

void KeyDown ( kbutton_t * b )

Definition at line 66 of file cl_input.c.

 {
     int     k;
     char    *c;
     
     c = Cmd_Argv(1);
     if (c[0])
         k = atoi(c);
     else
         k = -1;     // typed manually at the console for continuous down
  
     if (k == b->down[0] || k == b->down[1])
         return;     // repeating key
     
     if (!b->down[0])
         b->down[0] = k;
     else if (!b->down[1])
         b->down[1] = k;
     else
     {
         Com_Printf ("Three keys down for a button!\n");
         return;
     }
     
     if (b->state & 1)
         return;     // still down
  
     // save timestamp
     c = Cmd_Argv(2);
     b->downtime = atoi(c);
     if (!b->downtime)
         b->downtime = sys_frame_time - 100;
  
     b->state |= 1 + 2;  // down + impulse down
 }

Referenced by IN_AttackDown(), IN_BackDown(), IN_DownDown(), IN_ForwardDown(), IN_KLookDown(), IN_LeftDown(), IN_LookdownDown(), IN_LookupDown(), IN_MoveleftDown(), IN_MoverightDown(), IN_RightDown(), IN_SpeedDown(), IN_StrafeDown(), IN_UpDown(), and IN_UseDown().

◆ KeyUp()

void KeyUp ( kbutton_t * b )

Definition at line 102 of file cl_input.c.

 {
     int     k;
     char    *c;
     unsigned    uptime;
  
     c = Cmd_Argv(1);
     if (c[0])
         k = atoi(c);
     else
     { // typed manually at the console, assume for unsticking, so clear all
         b->down[0] = b->down[1] = 0;
         b->state = 4;   // impulse up
         return;
     }
  
     if (b->down[0] == k)
         b->down[0] = 0;
     else if (b->down[1] == k)
         b->down[1] = 0;
     else
         return;     // key up without coresponding down (menu pass through)
     if (b->down[0] || b->down[1])
         return;     // some other key is still holding it down
  
     if (!(b->state & 1))
         return;     // still up (this should not happen)
  
     // save timestamp
     c = Cmd_Argv(2);
     uptime = atoi(c);
     if (uptime)
         b->msec += uptime - b->downtime;
     else
         b->msec += 10;
  
     b->state &= ~1;     // now up
     b->state |= 4;      // impulse up
 }