UsercmdGen.cpp

Go to the documentation of this file.

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Doom 3 Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "../idlib/precompiled.h"
#pragma hdrstop

#include "Session_local.h"

/*
================
usercmd_t::ByteSwap
================
*/
void usercmd_t::ByteSwap( void ) {
        angles[0] = LittleShort( angles[0] );
        angles[1] = LittleShort( angles[1] );
        angles[2] = LittleShort( angles[2] );
        sequence = LittleLong( sequence );
}

/*
================
usercmd_t::operator==
================
*/
bool usercmd_t::operator==( const usercmd_t &rhs ) const { 
        return ( buttons == rhs.buttons &&
                        forwardmove == rhs.forwardmove &&
                        rightmove == rhs.rightmove &&
                        upmove == rhs.upmove &&
                        angles[0] == rhs.angles[0] &&
                        angles[1] == rhs.angles[1] &&
                        angles[2] == rhs.angles[2] &&
                        impulse == rhs.impulse &&
                        flags == rhs.flags &&
                        mx == rhs.mx &&
                        my == rhs.my );
}


const int KEY_MOVESPEED = 127;

typedef enum {
        UB_NONE,

        UB_UP,
        UB_DOWN,
        UB_LEFT,
        UB_RIGHT,
        UB_FORWARD,
        UB_BACK,
        UB_LOOKUP,
        UB_LOOKDOWN,
        UB_STRAFE,
        UB_MOVELEFT,
        UB_MOVERIGHT,

        UB_BUTTON0,
        UB_BUTTON1,
        UB_BUTTON2,
        UB_BUTTON3,
        UB_BUTTON4,
        UB_BUTTON5,
        UB_BUTTON6,
        UB_BUTTON7,

        UB_ATTACK,
        UB_SPEED,
        UB_ZOOM,
        UB_SHOWSCORES,
        UB_MLOOK,

        UB_IMPULSE0,
        UB_IMPULSE1,
        UB_IMPULSE2,
        UB_IMPULSE3,
        UB_IMPULSE4,
        UB_IMPULSE5,
        UB_IMPULSE6,
        UB_IMPULSE7,
        UB_IMPULSE8,
        UB_IMPULSE9,
        UB_IMPULSE10,
        UB_IMPULSE11,
        UB_IMPULSE12,
        UB_IMPULSE13,
        UB_IMPULSE14,
        UB_IMPULSE15,
        UB_IMPULSE16,
        UB_IMPULSE17,
        UB_IMPULSE18,
        UB_IMPULSE19,
        UB_IMPULSE20,
        UB_IMPULSE21,
        UB_IMPULSE22,
        UB_IMPULSE23,
        UB_IMPULSE24,
        UB_IMPULSE25,
        UB_IMPULSE26,
        UB_IMPULSE27,
        UB_IMPULSE28,
        UB_IMPULSE29,
        UB_IMPULSE30,
        UB_IMPULSE31,
        UB_IMPULSE32,
        UB_IMPULSE33,
        UB_IMPULSE34,
        UB_IMPULSE35,
        UB_IMPULSE36,
        UB_IMPULSE37,
        UB_IMPULSE38,
        UB_IMPULSE39,
        UB_IMPULSE40,
        UB_IMPULSE41,
        UB_IMPULSE42,
        UB_IMPULSE43,
        UB_IMPULSE44,
        UB_IMPULSE45,
        UB_IMPULSE46,
        UB_IMPULSE47,
        UB_IMPULSE48,
        UB_IMPULSE49,
        UB_IMPULSE50,
        UB_IMPULSE51,
        UB_IMPULSE52,
        UB_IMPULSE53,
        UB_IMPULSE54,
        UB_IMPULSE55,
        UB_IMPULSE56,
        UB_IMPULSE57,
        UB_IMPULSE58,
        UB_IMPULSE59,
        UB_IMPULSE60,
        UB_IMPULSE61,
        UB_IMPULSE62,
        UB_IMPULSE63,

        UB_MAX_BUTTONS
} usercmdButton_t;

typedef struct {
        const char *string;
        usercmdButton_t button;
} userCmdString_t;

userCmdString_t userCmdStrings[] = {
        { "_moveUp",            UB_UP },
        { "_moveDown",          UB_DOWN },
        { "_left",                      UB_LEFT },
        { "_right",                     UB_RIGHT },
        { "_forward",           UB_FORWARD },
        { "_back",                      UB_BACK },
        { "_lookUp",            UB_LOOKUP },
        { "_lookDown",          UB_LOOKDOWN },
        { "_strafe",            UB_STRAFE },
        { "_moveLeft",          UB_MOVELEFT },
        { "_moveRight",         UB_MOVERIGHT },

        { "_attack",            UB_ATTACK },
        { "_speed",                     UB_SPEED },
        { "_zoom",                      UB_ZOOM },
        { "_showScores",        UB_SHOWSCORES },
        { "_mlook",                     UB_MLOOK },

        { "_button0",           UB_BUTTON0 },
        { "_button1",           UB_BUTTON1 },
        { "_button2",           UB_BUTTON2 },
        { "_button3",           UB_BUTTON3 },
        { "_button4",           UB_BUTTON4 },
        { "_button5",           UB_BUTTON5 },
        { "_button6",           UB_BUTTON6 },
        { "_button7",           UB_BUTTON7 },

        { "_impulse0",          UB_IMPULSE0 },
        { "_impulse1",          UB_IMPULSE1 },
        { "_impulse2",          UB_IMPULSE2 },
        { "_impulse3",          UB_IMPULSE3 },
        { "_impulse4",          UB_IMPULSE4 },
        { "_impulse5",          UB_IMPULSE5 },
        { "_impulse6",          UB_IMPULSE6 },
        { "_impulse7",          UB_IMPULSE7 },
        { "_impulse8",          UB_IMPULSE8 },
        { "_impulse9",          UB_IMPULSE9 },
        { "_impulse10",         UB_IMPULSE10 },
        { "_impulse11",         UB_IMPULSE11 },
        { "_impulse12",         UB_IMPULSE12 },
        { "_impulse13",         UB_IMPULSE13 },
        { "_impulse14",         UB_IMPULSE14 },
        { "_impulse15",         UB_IMPULSE15 },
        { "_impulse16",         UB_IMPULSE16 },
        { "_impulse17",         UB_IMPULSE17 },
        { "_impulse18",         UB_IMPULSE18 },
        { "_impulse19",         UB_IMPULSE19 },
        { "_impulse20",         UB_IMPULSE20 },
        { "_impulse21",         UB_IMPULSE21 },
        { "_impulse22",         UB_IMPULSE22 },
        { "_impulse23",         UB_IMPULSE23 },
        { "_impulse24",         UB_IMPULSE24 },
        { "_impulse25",         UB_IMPULSE25 },
        { "_impulse26",         UB_IMPULSE26 },
        { "_impulse27",         UB_IMPULSE27 },
        { "_impulse28",         UB_IMPULSE28 },
        { "_impulse29",         UB_IMPULSE29 },
        { "_impulse30",         UB_IMPULSE30 },
        { "_impulse31",         UB_IMPULSE31 },
        { "_impulse32",         UB_IMPULSE32 },
        { "_impulse33",         UB_IMPULSE33 },
        { "_impulse34",         UB_IMPULSE34 },
        { "_impulse35",         UB_IMPULSE35 },
        { "_impulse36",         UB_IMPULSE36 },
        { "_impulse37",         UB_IMPULSE37 },
        { "_impulse38",         UB_IMPULSE38 },
        { "_impulse39",         UB_IMPULSE39 },
        { "_impulse40",         UB_IMPULSE40 },
        { "_impulse41",         UB_IMPULSE41 },
        { "_impulse42",         UB_IMPULSE42 },
        { "_impulse43",         UB_IMPULSE43 },
        { "_impulse44",         UB_IMPULSE44 },
        { "_impulse45",         UB_IMPULSE45 },
        { "_impulse46",         UB_IMPULSE46 },
        { "_impulse47",         UB_IMPULSE47 },
        { "_impulse48",         UB_IMPULSE48 },
        { "_impulse49",         UB_IMPULSE49 },
        { "_impulse50",         UB_IMPULSE50 },
        { "_impulse51",         UB_IMPULSE51 },
        { "_impulse52",         UB_IMPULSE52 },
        { "_impulse53",         UB_IMPULSE53 },
        { "_impulse54",         UB_IMPULSE54 },
        { "_impulse55",         UB_IMPULSE55 },
        { "_impulse56",         UB_IMPULSE56 },
        { "_impulse57",         UB_IMPULSE57 },
        { "_impulse58",         UB_IMPULSE58 },
        { "_impulse59",         UB_IMPULSE59 },
        { "_impulse60",         UB_IMPULSE60 },
        { "_impulse61",         UB_IMPULSE61 },
        { "_impulse62",         UB_IMPULSE62 },
        { "_impulse63",         UB_IMPULSE63 },

        { NULL,                         UB_NONE },
};

 class buttonState_t {
 public:
        int             on;
        bool    held;

                        buttonState_t() { Clear(); };
        void    Clear( void );
        void    SetKeyState( int keystate, bool toggle );
};

/*
================
buttonState_t::Clear
================
*/
void buttonState_t::Clear( void ) {
        held = false;
        on = 0;
}

/*
================
buttonState_t::SetKeyState
================
*/
void buttonState_t::SetKeyState( int keystate, bool toggle ) {
        if ( !toggle ) {
                held = false;
                on = keystate;
        } else if ( !keystate ) {
                held = false;
        } else if ( !held ) {
                held = true;
                on ^= 1;
        }
}


const int NUM_USER_COMMANDS = sizeof(userCmdStrings) / sizeof(userCmdString_t);

const int MAX_CHAT_BUFFER = 127;

class idUsercmdGenLocal : public idUsercmdGen {
public:
                                        idUsercmdGenLocal( void );
        
        void                    Init( void );

        void                    InitForNewMap( void );

        void                    Shutdown( void );

        void                    Clear( void );

        void                    ClearAngles( void );

        usercmd_t               TicCmd( int ticNumber );

        void                    InhibitUsercmd( inhibit_t subsystem, bool inhibit );

        void                    UsercmdInterrupt( void );

        int                             CommandStringUsercmdData( const char *cmdString );

        int                             GetNumUserCommands( void );

        const char *    GetUserCommandName( int index );

        void                    MouseState( int *x, int *y, int *button, bool *down );

        int                             ButtonState( int key );
        int                             KeyState( int key );

        usercmd_t               GetDirectUsercmd( void );

private:
        void                    MakeCurrent( void );
        void                    InitCurrent( void );

        bool                    Inhibited( void );
        void                    AdjustAngles( void );
        void                    KeyMove( void );
        void                    JoystickMove( void );
        void                    MouseMove( void );
        void                    CmdButtons( void );

        void                    Mouse( void );
        void                    Keyboard( void );
        void                    Joystick( void );

        void                    Key( int keyNum, bool down );

        idVec3                  viewangles;
        int                             flags;
        int                             impulse;

        buttonState_t   toggled_crouch;
        buttonState_t   toggled_run;
        buttonState_t   toggled_zoom;

        int                             buttonState[UB_MAX_BUTTONS];
        bool                    keyState[K_LAST_KEY];

        int                             inhibitCommands;        // true when in console or menu locally
        int                             lastCommandTime;

        bool                    initialized;

        usercmd_t               cmd;            // the current cmd being built
        usercmd_t               buffered[MAX_BUFFERED_USERCMD];

        int                             continuousMouseX, continuousMouseY;     // for gui event generatioin, never zerod
        int                             mouseButton;                                            // for gui event generatioin
        bool                    mouseDown;

        int                             mouseDx, mouseDy;       // added to by mouse events
        int                             joystickAxis[MAX_JOYSTICK_AXIS];        // set by joystick events

        static idCVar   in_yawSpeed;
        static idCVar   in_pitchSpeed;
        static idCVar   in_angleSpeedKey;
        static idCVar   in_freeLook;
        static idCVar   in_alwaysRun;
        static idCVar   in_toggleRun;
        static idCVar   in_toggleCrouch;
        static idCVar   in_toggleZoom;
        static idCVar   sensitivity;
        static idCVar   m_pitch;
        static idCVar   m_yaw;
        static idCVar   m_strafeScale;
        static idCVar   m_smooth;
        static idCVar   m_strafeSmooth;
        static idCVar   m_showMouseRate;
};

idCVar idUsercmdGenLocal::in_yawSpeed( "in_yawspeed", "140", CVAR_SYSTEM | CVAR_ARCHIVE | CVAR_FLOAT, "yaw change speed when holding down _left or _right button" );
idCVar idUsercmdGenLocal::in_pitchSpeed( "in_pitchspeed", "140", CVAR_SYSTEM | CVAR_ARCHIVE | CVAR_FLOAT, "pitch change speed when holding down look _lookUp or _lookDown button" );
idCVar idUsercmdGenLocal::in_angleSpeedKey( "in_anglespeedkey", "1.5", CVAR_SYSTEM | CVAR_ARCHIVE | CVAR_FLOAT, "angle change scale when holding down _speed button" );
idCVar idUsercmdGenLocal::in_freeLook( "in_freeLook", "1", CVAR_SYSTEM | CVAR_ARCHIVE | CVAR_BOOL, "look around with mouse (reverse _mlook button)" );
idCVar idUsercmdGenLocal::in_alwaysRun( "in_alwaysRun", "0", CVAR_SYSTEM | CVAR_ARCHIVE | CVAR_BOOL, "always run (reverse _speed button) - only in MP" );
idCVar idUsercmdGenLocal::in_toggleRun( "in_toggleRun", "0", CVAR_SYSTEM | CVAR_ARCHIVE | CVAR_BOOL, "pressing _speed button toggles run on/off - only in MP" );
idCVar idUsercmdGenLocal::in_toggleCrouch( "in_toggleCrouch", "0", CVAR_SYSTEM | CVAR_ARCHIVE | CVAR_BOOL, "pressing _movedown button toggles player crouching/standing" );
idCVar idUsercmdGenLocal::in_toggleZoom( "in_toggleZoom", "0", CVAR_SYSTEM | CVAR_ARCHIVE | CVAR_BOOL, "pressing _zoom button toggles zoom on/off" );
idCVar idUsercmdGenLocal::sensitivity( "sensitivity", "5", CVAR_SYSTEM | CVAR_ARCHIVE | CVAR_FLOAT, "mouse view sensitivity" );
idCVar idUsercmdGenLocal::m_pitch( "m_pitch", "0.022", CVAR_SYSTEM | CVAR_ARCHIVE | CVAR_FLOAT, "mouse pitch scale" );
idCVar idUsercmdGenLocal::m_yaw( "m_yaw", "0.022", CVAR_SYSTEM | CVAR_ARCHIVE | CVAR_FLOAT, "mouse yaw scale" );
idCVar idUsercmdGenLocal::m_strafeScale( "m_strafeScale", "6.25", CVAR_SYSTEM | CVAR_ARCHIVE | CVAR_FLOAT, "mouse strafe movement scale" );
idCVar idUsercmdGenLocal::m_smooth( "m_smooth", "1", CVAR_SYSTEM | CVAR_ARCHIVE | CVAR_INTEGER, "number of samples blended for mouse viewing", 1, 8, idCmdSystem::ArgCompletion_Integer<1,8> );
idCVar idUsercmdGenLocal::m_strafeSmooth( "m_strafeSmooth", "4", CVAR_SYSTEM | CVAR_ARCHIVE | CVAR_INTEGER, "number of samples blended for mouse moving", 1, 8, idCmdSystem::ArgCompletion_Integer<1,8> );
idCVar idUsercmdGenLocal::m_showMouseRate( "m_showMouseRate", "0", CVAR_SYSTEM | CVAR_BOOL, "shows mouse movement" );

static idUsercmdGenLocal localUsercmdGen;
idUsercmdGen    *usercmdGen = &localUsercmdGen;

/*
================
idUsercmdGenLocal::idUsercmdGenLocal
================
*/
idUsercmdGenLocal::idUsercmdGenLocal( void ) {
        lastCommandTime = 0;
        initialized = false;

        flags = 0;
        impulse = 0;

        toggled_crouch.Clear();
        toggled_run.Clear();
        toggled_zoom.Clear();
        toggled_run.on = in_alwaysRun.GetBool();

        ClearAngles();
        Clear();
}

/*
================
idUsercmdGenLocal::InhibitUsercmd
================
*/
void idUsercmdGenLocal::InhibitUsercmd( inhibit_t subsystem, bool inhibit ) {
        if ( inhibit ) {
                inhibitCommands |= 1 << subsystem;
        } else {
                inhibitCommands &= ( 0xffffffff ^ ( 1 << subsystem ) );
        }
}

/*
===============
idUsercmdGenLocal::ButtonState

Returns (the fraction of the frame) that the key was down
===============
*/
int     idUsercmdGenLocal::ButtonState( int key ) {
        if ( key<0 || key>=UB_MAX_BUTTONS ) {
                return -1;
        }
        return ( buttonState[key] > 0 ) ? 1 : 0;
}

/*
===============
idUsercmdGenLocal::KeyState

Returns (the fraction of the frame) that the key was down
bk20060111
===============
*/
int     idUsercmdGenLocal::KeyState( int key ) {
        if ( key<0 || key>=K_LAST_KEY ) {
                return -1;
        }
        return ( keyState[key] ) ? 1 : 0;
}


//=====================================================================


/*
================
idUsercmdGenLocal::GetNumUserCommands
================
*/
int idUsercmdGenLocal::GetNumUserCommands( void ) {
        return NUM_USER_COMMANDS;
}

/*
================
idUsercmdGenLocal::GetNumUserCommands
================
*/
const char *idUsercmdGenLocal::GetUserCommandName( int index ) {
        if (index >= 0 && index < NUM_USER_COMMANDS) {
                return userCmdStrings[index].string;
        }
        return "";
}

/*
================
idUsercmdGenLocal::Inhibited

is user cmd generation inhibited
================
*/
bool idUsercmdGenLocal::Inhibited( void ) {
        return ( inhibitCommands != 0);
}

/*
================
idUsercmdGenLocal::AdjustAngles

Moves the local angle positions
================
*/
void idUsercmdGenLocal::AdjustAngles( void ) {
        float   speed;
        
        if ( toggled_run.on ^ ( in_alwaysRun.GetBool() && idAsyncNetwork::IsActive() ) ) {
                speed = idMath::M_MS2SEC * USERCMD_MSEC * in_angleSpeedKey.GetFloat();
        } else {
                speed = idMath::M_MS2SEC * USERCMD_MSEC;
        }

        if ( !ButtonState( UB_STRAFE ) ) {
                viewangles[YAW] -= speed * in_yawSpeed.GetFloat() * ButtonState( UB_RIGHT );
                viewangles[YAW] += speed * in_yawSpeed.GetFloat() * ButtonState( UB_LEFT );
        }

        viewangles[PITCH] -= speed * in_pitchSpeed.GetFloat() * ButtonState( UB_LOOKUP );
        viewangles[PITCH] += speed * in_pitchSpeed.GetFloat() * ButtonState( UB_LOOKDOWN );
}

/*
================
idUsercmdGenLocal::KeyMove

Sets the usercmd_t based on key states
================
*/
void idUsercmdGenLocal::KeyMove( void ) {
        int             forward, side, up;

        forward = 0;
        side = 0;
        up = 0;
        if ( ButtonState( UB_STRAFE ) ) {
                side += KEY_MOVESPEED * ButtonState( UB_RIGHT );
                side -= KEY_MOVESPEED * ButtonState( UB_LEFT );
        }

        side += KEY_MOVESPEED * ButtonState( UB_MOVERIGHT );
        side -= KEY_MOVESPEED * ButtonState( UB_MOVELEFT );

        up -= KEY_MOVESPEED * toggled_crouch.on;
        up += KEY_MOVESPEED * ButtonState( UB_UP );

        forward += KEY_MOVESPEED * ButtonState( UB_FORWARD );
        forward -= KEY_MOVESPEED * ButtonState( UB_BACK );

        cmd.forwardmove = idMath::ClampChar( forward );
        cmd.rightmove = idMath::ClampChar( side );
        cmd.upmove = idMath::ClampChar( up );
}

/*
=================
idUsercmdGenLocal::MouseMove
=================
*/
void idUsercmdGenLocal::MouseMove( void ) {
        float           mx, my, strafeMx, strafeMy;
        static int      history[8][2];
        static int      historyCounter;
        int                     i;

        history[historyCounter&7][0] = mouseDx;
        history[historyCounter&7][1] = mouseDy;
        
        // allow mouse movement to be smoothed together
        int smooth = m_smooth.GetInteger();
        if ( smooth < 1 ) {
                smooth = 1;
        }
        if ( smooth > 8 ) {
                smooth = 8;
        }
        mx = 0;
        my = 0;
        for ( i = 0 ; i < smooth ; i++ ) {
                mx += history[ ( historyCounter - i + 8 ) & 7 ][0];
                my += history[ ( historyCounter - i + 8 ) & 7 ][1];
        }
        mx /= smooth;
        my /= smooth;

        // use a larger smoothing for strafing
        smooth = m_strafeSmooth.GetInteger();
        if ( smooth < 1 ) {
                smooth = 1;
        }
        if ( smooth > 8 ) {
                smooth = 8;
        }
        strafeMx = 0;
        strafeMy = 0;
        for ( i = 0 ; i < smooth ; i++ ) {
                strafeMx += history[ ( historyCounter - i + 8 ) & 7 ][0];
                strafeMy += history[ ( historyCounter - i + 8 ) & 7 ][1];
        }
        strafeMx /= smooth;
        strafeMy /= smooth;

        historyCounter++;

        if ( idMath::Fabs( mx ) > 1000 || idMath::Fabs( my ) > 1000 ) {
                Sys_DebugPrintf( "idUsercmdGenLocal::MouseMove: Ignoring ridiculous mouse delta.\n" );
                mx = my = 0;
        }

        mx *= sensitivity.GetFloat();
        my *= sensitivity.GetFloat();

        if ( m_showMouseRate.GetBool() ) {
                Sys_DebugPrintf( "[%3i %3i  = %5.1f %5.1f = %5.1f %5.1f] ", mouseDx, mouseDy, mx, my, strafeMx, strafeMy );
        }

        mouseDx = 0;
        mouseDy = 0;

        if ( !strafeMx && !strafeMy ) {
                return;
        }

        if ( ButtonState( UB_STRAFE ) || !( cmd.buttons & BUTTON_MLOOK ) ) {
                // add mouse X/Y movement to cmd
                strafeMx *= m_strafeScale.GetFloat();
                strafeMy *= m_strafeScale.GetFloat();
                // clamp as a vector, instead of separate floats
                float len = sqrt( strafeMx * strafeMx + strafeMy * strafeMy );
                if ( len > 127 ) {
                        strafeMx = strafeMx * 127 / len;
                        strafeMy = strafeMy * 127 / len;
                }
        }

        if ( !ButtonState( UB_STRAFE ) ) {
                viewangles[YAW] -= m_yaw.GetFloat() * mx;
        } else {
                cmd.rightmove = idMath::ClampChar( (int)(cmd.rightmove + strafeMx) );
        }

        if ( !ButtonState( UB_STRAFE ) && ( cmd.buttons & BUTTON_MLOOK ) ) {
                viewangles[PITCH] += m_pitch.GetFloat() * my;
        } else {
                cmd.forwardmove = idMath::ClampChar( (int)(cmd.forwardmove - strafeMy) );
        }
}

/*
=================
idUsercmdGenLocal::JoystickMove
=================
*/
void idUsercmdGenLocal::JoystickMove( void ) {
        float   anglespeed;

        if ( toggled_run.on ^ ( in_alwaysRun.GetBool() && idAsyncNetwork::IsActive() ) ) {
                anglespeed = idMath::M_MS2SEC * USERCMD_MSEC * in_angleSpeedKey.GetFloat();
        } else {
                anglespeed = idMath::M_MS2SEC * USERCMD_MSEC;
        }

        if ( !ButtonState( UB_STRAFE ) ) {
                viewangles[YAW] += anglespeed * in_yawSpeed.GetFloat() * joystickAxis[AXIS_SIDE];
                viewangles[PITCH] += anglespeed * in_pitchSpeed.GetFloat() * joystickAxis[AXIS_FORWARD];
        } else {
                cmd.rightmove = idMath::ClampChar( cmd.rightmove + joystickAxis[AXIS_SIDE] );
                cmd.forwardmove = idMath::ClampChar( cmd.forwardmove + joystickAxis[AXIS_FORWARD] );
        }

        cmd.upmove = idMath::ClampChar( cmd.upmove + joystickAxis[AXIS_UP] );
}

/*
==============
idUsercmdGenLocal::CmdButtons
==============
*/
void idUsercmdGenLocal::CmdButtons( void ) {
        int             i;

        cmd.buttons = 0;

        // figure button bits
        for (i = 0 ; i <= 7 ; i++) {
                if ( ButtonState( (usercmdButton_t)( UB_BUTTON0 + i ) ) ) {
                        cmd.buttons |= 1 << i;
                }
        }

        // check the attack button
        if ( ButtonState( UB_ATTACK ) ) {
                cmd.buttons |= BUTTON_ATTACK;
        }

        // check the run button
        if ( toggled_run.on ^ ( in_alwaysRun.GetBool() && idAsyncNetwork::IsActive() ) ) {
                cmd.buttons |= BUTTON_RUN;
        }

        // check the zoom button
        if ( toggled_zoom.on ) {
                cmd.buttons |= BUTTON_ZOOM;
        }

        // check the scoreboard button
        if ( ButtonState( UB_SHOWSCORES ) || ButtonState( UB_IMPULSE19 ) ) {
                // the button is toggled in SP mode as well but without effect
                cmd.buttons |= BUTTON_SCORES;
        }

        // check the mouse look button
        if ( ButtonState( UB_MLOOK ) ^ in_freeLook.GetInteger() ) {
                cmd.buttons |= BUTTON_MLOOK;
        }
}

/*
================
idUsercmdGenLocal::InitCurrent

inits the current command for this frame
================
*/
void idUsercmdGenLocal::InitCurrent( void ) {
        memset( &cmd, 0, sizeof( cmd ) );
        cmd.flags = flags;
        cmd.impulse = impulse;
        cmd.buttons |= ( in_alwaysRun.GetBool() && idAsyncNetwork::IsActive() ) ? BUTTON_RUN : 0;
        cmd.buttons |= in_freeLook.GetBool() ? BUTTON_MLOOK : 0;
}

/*
================
idUsercmdGenLocal::MakeCurrent

creates the current command for this frame
================
*/
void idUsercmdGenLocal::MakeCurrent( void ) {
        idVec3          oldAngles;
        int             i;

        oldAngles = viewangles;
        
        if ( !Inhibited() ) {
                // update toggled key states
                toggled_crouch.SetKeyState( ButtonState( UB_DOWN ), in_toggleCrouch.GetBool() );
                toggled_run.SetKeyState( ButtonState( UB_SPEED ), in_toggleRun.GetBool() && idAsyncNetwork::IsActive() );
                toggled_zoom.SetKeyState( ButtonState( UB_ZOOM ), in_toggleZoom.GetBool() );

                // keyboard angle adjustment
                AdjustAngles();

                // set button bits
                CmdButtons();

                // get basic movement from keyboard
                KeyMove();

                // get basic movement from mouse
                MouseMove();

                // get basic movement from joystick
                JoystickMove();

                // check to make sure the angles haven't wrapped
                if ( viewangles[PITCH] - oldAngles[PITCH] > 90 ) {
                        viewangles[PITCH] = oldAngles[PITCH] + 90;
                } else if ( oldAngles[PITCH] - viewangles[PITCH] > 90 ) {
                        viewangles[PITCH] = oldAngles[PITCH] - 90;
                } 
        } else {
                mouseDx = 0;
                mouseDy = 0;
        }

        for ( i = 0; i < 3; i++ ) {
                cmd.angles[i] = ANGLE2SHORT( viewangles[i] );
        }

        cmd.mx = continuousMouseX;
        cmd.my = continuousMouseY;

        flags = cmd.flags;
        impulse = cmd.impulse;

}

//=====================================================================


/*
================
idUsercmdGenLocal::CommandStringUsercmdData

Returns the button if the command string is used by the async usercmd generator.
================
*/
int     idUsercmdGenLocal::CommandStringUsercmdData( const char *cmdString ) {
        for ( userCmdString_t *ucs = userCmdStrings ; ucs->string ; ucs++ ) {
                if ( idStr::Icmp( cmdString, ucs->string ) == 0 ) {
                        return ucs->button;
                }
        }
        return UB_NONE;
}

/*
================
idUsercmdGenLocal::Init
================
*/
void idUsercmdGenLocal::Init( void ) {
        initialized = true;
}

/*
================
idUsercmdGenLocal::InitForNewMap
================
*/
void idUsercmdGenLocal::InitForNewMap( void ) {
        flags = 0;
        impulse = 0;

        toggled_crouch.Clear();
        toggled_run.Clear();
        toggled_zoom.Clear();
        toggled_run.on = in_alwaysRun.GetBool();

        Clear();
        ClearAngles();
}

/*
================
idUsercmdGenLocal::Shutdown
================
*/
void idUsercmdGenLocal::Shutdown( void ) {
        initialized = false;
}

/*
================
idUsercmdGenLocal::Clear
================
*/
void idUsercmdGenLocal::Clear( void ) {
        // clears all key states 
        memset( buttonState, 0, sizeof( buttonState ) );
        memset( keyState, false, sizeof( keyState ) );

        inhibitCommands = false;

        mouseDx = mouseDy = 0;
        mouseButton = 0;
        mouseDown = false;
}

/*
================
idUsercmdGenLocal::ClearAngles
================
*/
void idUsercmdGenLocal::ClearAngles( void ) {
        viewangles.Zero();
}

/*
================
idUsercmdGenLocal::TicCmd

Returns a buffered usercmd
================
*/
usercmd_t idUsercmdGenLocal::TicCmd( int ticNumber ) {

        // the packetClient code can legally ask for com_ticNumber+1, because
        // it is in the async code and com_ticNumber hasn't been updated yet,
        // but all other code should never ask for anything > com_ticNumber
        if ( ticNumber > com_ticNumber+1 ) {
                common->Error( "idUsercmdGenLocal::TicCmd ticNumber > com_ticNumber" );
        }

        if ( ticNumber <= com_ticNumber - MAX_BUFFERED_USERCMD ) {
                // this can happen when something in the game code hitches badly, allowing the
                // async code to overflow the buffers
                //common->Printf( "warning: idUsercmdGenLocal::TicCmd ticNumber <= com_ticNumber - MAX_BUFFERED_USERCMD\n" );
        }

        return buffered[ ticNumber & (MAX_BUFFERED_USERCMD-1) ];
}

//======================================================================


/*
===================
idUsercmdGenLocal::Key

Handles async mouse/keyboard button actions
===================
*/
void idUsercmdGenLocal::Key( int keyNum, bool down ) {

        // Sanity check, sometimes we get double message :(
        if ( keyState[ keyNum ] == down ) {
                return;
        }
        keyState[ keyNum ] = down;

        int action = idKeyInput::GetUsercmdAction( keyNum );

        if ( down ) {

                buttonState[ action ]++;

                if ( !Inhibited()  ) {
                        if ( action >= UB_IMPULSE0 && action <= UB_IMPULSE61 ) {
                                cmd.impulse = action - UB_IMPULSE0;
                                cmd.flags ^= UCF_IMPULSE_SEQUENCE;
                        }
                }
        } else {
                buttonState[ action ]--;
                // we might have one held down across an app active transition
                if ( buttonState[ action ] < 0 ) {
                        buttonState[ action ] = 0;
                }
        }
}

/*
===================
idUsercmdGenLocal::Mouse
===================
*/
void idUsercmdGenLocal::Mouse( void ) {
        int i, numEvents;

        numEvents = Sys_PollMouseInputEvents();

        if ( numEvents ) {
                //
            // Study each of the buffer elements and process them.
                //
                for( i = 0; i < numEvents; i++ ) {
                        int action, value;
                        if ( Sys_ReturnMouseInputEvent( i, action, value ) ) {
                                if ( action >= M_ACTION1 && action <= M_ACTION8 ) {
                                        mouseButton = K_MOUSE1 + ( action - M_ACTION1 );
                                        mouseDown = ( value != 0 );
                                        Key( mouseButton, mouseDown );
                                } else {
                                        switch ( action ) {
                                                case M_DELTAX:
                                                        mouseDx += value;
                                                        continuousMouseX += value;
                                                        break;
                                                case M_DELTAY:
                                                        mouseDy += value;
                                                        continuousMouseY += value;
                                                        break;
                                                case M_DELTAZ:
                                                        int key = value < 0 ? K_MWHEELDOWN : K_MWHEELUP;
                                                        value = abs( value );
                                                        while( value-- > 0 ) {
                                                                Key( key, true );
                                                                Key( key, false );
                                                                mouseButton = key;
                                                                mouseDown = true;
                                                        }
                                                        break;
                                        }
                                }
                        }
                }
        }

        Sys_EndMouseInputEvents();
}

/*
===============
idUsercmdGenLocal::Keyboard
===============
*/
void idUsercmdGenLocal::Keyboard( void ) {

        int numEvents = Sys_PollKeyboardInputEvents();

        if ( numEvents ) {
                //
            // Study each of the buffer elements and process them.
                //
                int key;
                bool state;
                for( int i = 0; i < numEvents; i++ ) {
                        if (Sys_ReturnKeyboardInputEvent( i, key, state )) {
                                Key ( key, state );
                        }
                }
        }

        Sys_EndKeyboardInputEvents();
}

/*
===============
idUsercmdGenLocal::Joystick
===============
*/
void idUsercmdGenLocal::Joystick( void ) {
        memset( joystickAxis, 0, sizeof( joystickAxis ) );
}

/*
================
idUsercmdGenLocal::UsercmdInterrupt

Called asyncronously
================
*/
void idUsercmdGenLocal::UsercmdInterrupt( void ) {
        // dedicated servers won't create usercmds
        if ( !initialized ) {
                return;
        }

        // init the usercmd for com_ticNumber+1
        InitCurrent();

        // process the system mouse events
        Mouse();

        // process the system keyboard events
        Keyboard();

        // process the system joystick events
        Joystick();

        // create the usercmd for com_ticNumber+1
        MakeCurrent();

        // save a number for debugging cmdDemos and networking
        cmd.sequence = com_ticNumber+1;

        buffered[(com_ticNumber+1) & (MAX_BUFFERED_USERCMD-1)] = cmd;
}

/*
================
idUsercmdGenLocal::MouseState
================
*/
void idUsercmdGenLocal::MouseState( int *x, int *y, int *button, bool *down ) {
        *x = continuousMouseX;
        *y = continuousMouseY;
        *button = mouseButton;
        *down = mouseDown;
}

/*
================
idUsercmdGenLocal::GetDirectUsercmd
================
*/
usercmd_t idUsercmdGenLocal::GetDirectUsercmd( void ) {

        // initialize current usercmd
        InitCurrent();

        // process the system mouse events
        Mouse();

        // process the system keyboard events
        Keyboard();

        // process the system joystick events
        Joystick();

        // create the usercmd
        MakeCurrent();

        cmd.duplicateCount = 0;

        return cmd;
}