ns/releases/3.2.0/source/cl_dll/input.cpp

//======== (C) Copyright 2002 Charles G. Cleveland All rights reserved. =========
//
// The copyright to the contents herein is the property of Charles G. Cleveland.
// The contents may be used and/or copied only with the written permission of
// Charles G. Cleveland, or in accordance with the terms and conditions stipulated in
// the agreement/contract under which the contents have been supplied.
//
// Purpose: 
//
// $Workfile: input.cpp $
// $Date: 2002/10/16 02:12:21 $
//
//-------------------------------------------------------------------------------
// $Log: input.cpp,v $
// Revision 1.28  2002/10/16 02:12:21  Flayra
// - Valve anti-cheat integrated!
//
// Revision 1.27  2002/08/09 00:13:04  Flayra
// - Removed explicitly allowing specific commands.  I can't remember why this was needed, but it doesn't appear to be anymore.
//
// Revision 1.26  2002/08/02 21:39:03  Flayra
// - Refactored variable names
//
// Revision 1.25  2002/07/08 16:13:31  Flayra
// - Fixed bug where command was able to switch weapons via mousewheel (bug #239)
//
//===============================================================================
// cl.input.c  -- builds an intended movement command to send to the server

//xxxxxx Move bob and pitch drifting code here and other stuff from view if needed

// Quake is a trademark of Id Software, Inc., (c) 1996 Id Software, Inc. All
// rights reserved.
#include "hud.h"
#include "cl_util.h"
#include "camera.h"
extern "C"
{
#include "kbutton.h"
}
#include "common/cvardef.h"
#include "common/usercmd.h"
#include "common/const.h"
#include "camera.h"
#include "in_defs.h"
#include "view.h"
#include <string.h>
#include <ctype.h>
#include "engine/keydefs.h"

#include "vgui_TeamFortressViewport.h"
#include "mod/AvHServerVariables.h"// should we go ahead and just make a SharedVariables.h instead?
#include "mod/AvHClientVariables.h"
#include "mod/AvHMessage.h"
#include "fmod.h"
#include "mod/AvHScriptManager.h"
#include "mod/AvHScrollHandler.h"
#include "mod/AvHCommanderModeHandler.h"
#include "Util/Mat3.h"

#include "engine/APIProxy.h"
#include "Exports.h"

// tankefugl: duck toggle
extern bool g_bDuckToggled;
// :tankefugl

extern int g_iAlive;

extern int g_weaponselect;
extern cl_enginefunc_t gEngfuncs;
bool gResetViewAngles = false;
vec3_t gViewAngles;
extern AvHCommanderModeHandler	gCommanderHandler;

///////////////////////////////
// Begin Max's Code
///////////////////////////////

float gPlayerAngles[3]       = { 0, 0, 0 };
float gTargetPlayerAngles[3] = { 0, 0, 0 };
float gWorldViewAngles[3] = { 0, 0, 0 };

///////////////////////////////
// End Max's Code
///////////////////////////////

// Defined in pm_math.c
//extern "C" float anglemod( float a );
float anglemod( float a );

void IN_Init (void);
void IN_Move ( float frametime, float ioRotationDeltas[3], float ioTranslationDeltas[3]);
void IN_Shutdown( void );
void V_Init( void );
void VectorAngles( const float *forward, float *angles );
int CL_ButtonBits( int );

// xxx need client dll function to get and clear impuse
extern cvar_t *in_joystick;

int	in_impulse	= 0;
int	in_cancel	= 0;

cvar_t	*m_pitch;
cvar_t	*m_yaw;
cvar_t	*m_forward;
cvar_t	*m_side;

cvar_t	*lookstrafe;
cvar_t	*lookspring;
//cvar_t	*cl_pitchup;
//cvar_t	*cl_pitchdown;
cvar_t	*cl_upspeed;
cvar_t	*cl_movespeedkey;
cvar_t	*cl_yawspeed;
cvar_t	*cl_pitchspeed;
cvar_t	*cl_anglespeedkey;
cvar_t	*cl_vsmoothing;
cvar_t  *cl_autohelp;
cvar_t  *cl_centerentityid;
cvar_t  *cl_musicenabled;
cvar_t	*cl_musicdelay;
cvar_t  *cl_musicvolume;
cvar_t  *cl_musicdir;
cvar_t	*cl_quickselecttime;
cvar_t	*cl_highdetail;
cvar_t	*cl_cmhotkeys;
cvar_t	*cl_forcedefaultfov;
cvar_t	*cl_dynamiclights;
cvar_t	*cl_buildmessages;
cvar_t	*cl_particleinfo;

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

KEY BUTTONS

Continuous button event tracking is complicated by the fact that two different
input sources (say, mouse button 1 and the control key) can both press the
same button, but the button should only be released when both of the
pressing key have been released.

When a key event issues a button command (+forward, +attack, etc), it appends
its key number as a parameter to the command so it can be matched up with
the release.

state bit 0 is the current state of the key
state bit 1 is edge triggered on the up to down transition
state bit 2 is edge triggered on the down to up transition

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


kbutton_t	in_mlook;
kbutton_t	in_klook;
kbutton_t	in_jlook;
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_jump;
kbutton_t	in_attack;
kbutton_t	in_attack2;
kbutton_t	in_up;
kbutton_t	in_down;
kbutton_t	in_duck;
kbutton_t	in_reload;
kbutton_t	in_alt1;
kbutton_t	in_score;
kbutton_t	in_break;
kbutton_t	in_graph;  // Display the netgraph

typedef struct kblist_s
{
	struct kblist_s *next;
	kbutton_t *pkey;
	char name[32];
} kblist_t;

kblist_t *g_kbkeys = NULL;

vector< pair <int, string> > g_PrevCmds; 

/*
============
KB_ConvertString

Removes references to +use and replaces them with the keyname in the output string.  If
 a binding is unfound, then the original text is retained.
NOTE:  Only works for text with +word in it.
============
*/
int KB_ConvertString( char *in, char **ppout )
{
	char sz[ 4096 ];
	char binding[ 64 ];
	char *p;
	char *pOut;
	char *pEnd;
	const char *pBinding;

	if ( !ppout )
		return 0;

	*ppout = NULL;
	p = in;
	pOut = sz;
	while ( *p )
	{
		if ( *p == '+' )
		{
			pEnd = binding;
			while ( *p && ( isalnum( *p ) || ( pEnd == binding ) ) && ( ( pEnd - binding ) < 63 ) )
			{
				*pEnd++ = *p++;
			}

			*pEnd =  '\0';

			pBinding = NULL;
			if ( strlen( binding + 1 ) > 0 )
			{
				// See if there is a binding for binding?
				pBinding = gEngfuncs.Key_LookupBinding( binding + 1 );
			}

			if ( pBinding )
			{
				*pOut++ = '[';
				pEnd = (char *)pBinding;
			}
			else
			{
				pEnd = binding;
			}

			while ( *pEnd )
			{
				*pOut++ = *pEnd++;
			}

			if ( pBinding )
			{
				*pOut++ = ']';
			}
		}
		else
		{
			*pOut++ = *p++;
		}
	}

	*pOut = '\0';

	pOut = ( char * )malloc( strlen( sz ) + 1 );
	strcpy( pOut, sz );
	*ppout = pOut;

	return 1;
}

/*
============
KB_Find

Allows the engine to get a kbutton_t directly ( so it can check +mlook state, etc ) for saving out to .cfg files
============
*/
struct kbutton_s CL_DLLEXPORT *KB_Find( const char *name )
{
	RecClFindKey(name);

	kblist_t *p;
	p = g_kbkeys;
	while ( p )
	{
		if ( !stricmp( name, p->name ) )
			return p->pkey;

		p = p->next;
	}
	return NULL;
}

/*
============
KB_Add

Add a kbutton_t * to the list of pointers the engine can retrieve via KB_Find
============
*/
void KB_Add( const char *name, kbutton_t *pkb )
{
	kblist_t *p;	
	kbutton_t *kb;

	kb = KB_Find( name );
	
	if ( kb )
		return;

	p = ( kblist_t * )malloc( sizeof( kblist_t ) );
	memset( p, 0, sizeof( *p ) );

	strcpy( p->name, name );
	p->pkey = pkb;

	p->next = g_kbkeys;
	g_kbkeys = p;
}

/*
============
KB_Init

Add kbutton_t definitions that the engine can query if needed
============
*/
void KB_Init( void )
{
	g_kbkeys = NULL;

	KB_Add( "in_graph", &in_graph );
	KB_Add( "in_mlook", &in_mlook );
	KB_Add( "in_jlook", &in_jlook );
}

/*
============
KB_Shutdown

Clear kblist
============
*/
void KB_Shutdown( void )
{
	kblist_t *p, *n;
	p = g_kbkeys;
	while ( p )
	{
		n = p->next;
		free( p );
		p = n;
	}
	g_kbkeys = NULL;
}

void KeyDown (kbutton_t *b);
void KeyUp (kbutton_t *b);
void KeyDownForced (kbutton_t *b);
void KeyUpForced (kbutton_t *b);

/*
============
KeyDown
============
*/
void KeyDown (kbutton_t *b)
{
	int		k;
	char	*c;

	c = gEngfuncs.Cmd_Argv(1);
	if (c[0])
		k = atoi(c);
	else
		k = -1;		// typed manually at the console for continuous down

	int theBlockScripts = (int)gHUD.GetServerVariableFloat(kvBlockScripts);

	char *pCmd = gEngfuncs.Cmd_Argv(0);

	if(theBlockScripts && pCmd)
	{
		bool bFound = false;

		//Check thier last few commands (this prevents false positives if a player is hits several keys real fast)
		for (int i = 0; i < g_PrevCmds.size(); i++) 
		{
			//Check both the key pressed and the command it executed.
			if(k == g_PrevCmds[i].first && !strcmp(pCmd, g_PrevCmds[i].second.c_str()))
			{
				bFound = true;
				break;
			}
		}

//		//If they used mwheeldown/mwheelup to activate repeating command, make sure they didnt use +attack or +jump to prevent exploits.
//		if(k == K_MWHEELDOWN || k == K_MWHEELUP && theBlockScripts == 2)
//		{
//			if(strstr(pCmd, "+"))//I could also do pCmd[0] == '+', but that could possibly be bypassed.
//				bFound = false;
//		}
		

		if(!bFound 
			&& strcmp(pCmd, "+mlook") 
			&& strcmp(pCmd, "+jlook")
			&& strcmp(pCmd, "+showscores")
			&& strcmp(pCmd, "+use"))
		{
			gEngfuncs.pfnCenterPrint("Scripting is not allowed on this server.");
			b->down[0] = b->down[1] = 0;
			b->state = 4;	// impulse up
			return;
		}
	}

	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
	{
		gEngfuncs.Con_DPrintf ("Three keys down for a button '%c' '%c' '%c'!\n", b->down[0], b->down[1], c);
		return;
	}
	
	if (b->state & 1)
		return;		// still down
	b->state |= 1 + 2;	// down + impulse down
}

/*
============
KeyDownForced
============
*/
void KeyDownForced (kbutton_t *b)
{
	b->down[0] = 0;
	b->down[1] = 0;
	
	if (b->state & 1)
		return;		// still down
	b->state |= 1 + 2;	// down + impulse down
}

/*
============
KeyUp
============
*/
void KeyUp (kbutton_t *b)
{
	int		k;
	char	*c;

	c = gEngfuncs.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])
	{
		//Con_Printf ("Keys down for button: '%c' '%c' '%c' (%d,%d,%d)!\n", b->down[0], b->down[1], c, b->down[0], b->down[1], c);
		return;		// some other key is still holding it down
	}

	if (!(b->state & 1))
		return;		// still up (this should not happen)

	b->state &= ~1;		// now up
	b->state |= 4; 		// impulse up
}

/*
============
KeyUpForced
============
*/
void KeyUpForced (kbutton_t *b)
{
	b->state &= ~1;		// now up
	b->state |= 4; 		// impulse up
}

bool AvHContainsBlockedCommands(const char* inInput)
{
    if (inInput == NULL)
    {
        return false;
    }

    const char* kBlockedCommand[] =
        {
            "exec",
            "wait",
            "special",
            "_special"
        };

    // Check for a ; indicating multiple commands.

    if (strchr(inInput, ';') != NULL)
    {
        return true;
    }

    // Check if any of the blocked commands are being used.

    const char* theCommandEnd = strpbrk(inInput, " \t");
    
    int theCommandLength;
    
    if (theCommandEnd == NULL)
    {
        theCommandLength = (int)strlen(inInput);
    }
    else
    {
        theCommandLength = theCommandEnd - inInput;
    }

    for (int i = 0; i < sizeof(kBlockedCommand) / sizeof(const char*); ++i)
    {
        if ((int)strlen(kBlockedCommand[i]) == theCommandLength &&
            strncmp(inInput, kBlockedCommand[i], theCommandLength) == 0)
        {
            return true;
        }
	}
    return false;
}

/*
============
HUD_Key_Event

Return 1 to allow engine to process the key, otherwise, act on it as needed
============
*/
int CL_DLLEXPORT HUD_Key_Event( int down, int keynum, const char *pszCurrentBinding )
{
    RecClKeyEvent(down, keynum, pszCurrentBinding);

    // Check to see if the event has any outlawed commands in it.
    float theBlockScripts = gHUD.GetServerVariableFloat(kvBlockScripts);
    
	if (theBlockScripts && AvHContainsBlockedCommands(pszCurrentBinding))
	{
		if(down)//voogru: only show when going down.
			gEngfuncs.pfnCenterPrint("Scripting is not allowed on this server.\n"); 
		return 0;
	}

	if(pszCurrentBinding)
	{
		if(g_PrevCmds.size() >= 5)
			g_PrevCmds.erase(g_PrevCmds.begin());//remove the oldest command

		g_PrevCmds.push_back(make_pair(keynum, (string)pszCurrentBinding));
	}

	int theProcessKeyBinding = 1;

//	char theKeyBinding[256] = "none";
//	if(pszCurrentBinding)
//	{
//		sprintf(theKeyBinding, pszCurrentBinding);
//	}
//
//	char theMessage[512];
//	sprintf(theMessage, "%s (down: %d, keynum %d)", theKeyBinding, down, keynum);
//	CenterPrint(theMessage);

	if(gViewPort /*&& gViewPort->IsOptionsMenuVisible()*/)
	{
		
        theProcessKeyBinding = gViewPort->KeyInput(down, keynum, pszCurrentBinding);

		if(pszCurrentBinding && (!strcmp(pszCurrentBinding, "toggleconsole") || !strcmp(pszCurrentBinding, "cancelselect")))
		{
			theProcessKeyBinding = 1;
		}
	}


	// Process topdown commands with precedence first
	if(theProcessKeyBinding && gHUD.GetInTopDownMode())
	{
		if((keynum != 0) && down/*&& pszCurrentBinding*/)
		{
			AvHMessageID theMessageID = gHUD.HotKeyHit(keynum);
			if((theMessageID != MESSAGE_NULL) || (keynum == K_ESCAPE))
			{
				// If ESC or cancel was hit, cancel ghost building
				if((keynum == K_ESCAPE) || (theMessageID == MESSAGE_CANCEL))
				{
					gHUD.SetGhostBuildingMode(MESSAGE_NULL);
				}

				theProcessKeyBinding = 0;
			}
			
//			// Else look for hotkey commands
//			int thePrefixLength = strlen(kHotKeyPrefix);
//			if(down && !strncmp(pszCurrentBinding, kHotKeyPrefix, thePrefixLength))
//			{
//				// Strip out number, pass it to HUD
//				char theNumberString[8];
//				memset(theNumberString, 0, 8);
//				int theBindingLength = strlen(pszCurrentBinding);
//				ASSERT(theBindingLength > thePrefixLength);
//				strncpy(theNumberString, pszCurrentBinding + thePrefixLength, theBindingLength - thePrefixLength);
//				
//				int theBuildTech = MakeIntFromString(string(theNumberString));
//			
//				gHUD.HotKeyHit(theBuildTech);
//			
//				theProcessKeyBinding = 0;
//			}
//			else
//			{
//				// Look for top down only commands, like scrolling
//				if(!strcmp("+forward", pszCurrentBinding))
//				{
//					AvHScrollHandler::ScrollUp();
//					theProcessKeyBinding = 0;
//				}
//				else if(!strcmp("-forward", pszCurrentBinding))
//				{
//					AvHScrollHandler::StopScroll();
//					theProcessKeyBinding = 0;
//				}
//				else if(!strcmp("+back", pszCurrentBinding))
//				{
//					AvHScrollHandler::ScrollDown();
//					theProcessKeyBinding = 0;
//				}
//				else if(!strcmp("-back", pszCurrentBinding))
//				{
//					AvHScrollHandler::StopScroll();
//					theProcessKeyBinding = 0;
//				}
//				else if(!strcmp("+moveleft", pszCurrentBinding))
//				{
//					AvHScrollHandler::ScrollLeft();
//					theProcessKeyBinding = 0;
//				}
//				else if(!strcmp("-moveleft", pszCurrentBinding))
//				{
//					AvHScrollHandler::StopScroll();
//					theProcessKeyBinding = 0;
//				}
//				else if(!strcmp("+moveright", pszCurrentBinding))
//				{
//					AvHScrollHandler::ScrollRight();
//					theProcessKeyBinding = 0;
//				}
//				else if(!strcmp("-moveright", pszCurrentBinding))
//				{
//					AvHScrollHandler::StopScroll();
//					theProcessKeyBinding = 0;
//				}
//			}
		}
	}

	if(theProcessKeyBinding)
	{
		// Process only a couple keybindings in top down mode
//		if(!gHUD.GetInTopDownMode() || (pszCurrentBinding && 
//
//			// Misc. commands
//			(!strcmp(pszCurrentBinding, "toggleconsole") || !strcmp(pszCurrentBinding, "cancelselect") || !strcmp(pszCurrentBinding, "+showscores") || !strcmp(pszCurrentBinding, "-showscores") || !strcmp(pszCurrentBinding, "messagemode") || !strcmp(pszCurrentBinding, "messagemode2") || !strcmp(pszCurrentBinding, "snapshot") || !strcmp(pszCurrentBinding, "screenshot") || !strcmp(pszCurrentBinding, "+jump") || !strcmp(pszCurrentBinding, "addbot") || !strcmp(pszCurrentBinding, "+voicerecord") || !strcmp(pszCurrentBinding, "-voicerecord") || 
//
//			// Movement commands
//			!strcmp(pszCurrentBinding, "testevent") /*|| !strcmp(pszCurrentBinding, "invnext") || !strcmp(pszCurrentBinding, "invprev")*/ || !strcmp(pszCurrentBinding, "+moveleft") || !strcmp(pszCurrentBinding, "-moveleft") || !strcmp(pszCurrentBinding, "+moveright") || !strcmp(pszCurrentBinding, "-moveright") || !strcmp(pszCurrentBinding, "+moveup")  || !strcmp(pszCurrentBinding, "-moveup") || !strcmp(pszCurrentBinding, "+movedown") || !strcmp(pszCurrentBinding, "-movedown") ||
//		
//			// For selecting groups
//			!strcmp(pszCurrentBinding, "slot1") || !strcmp(pszCurrentBinding, "slot2") || !strcmp(pszCurrentBinding, "slot3") || !strcmp(pszCurrentBinding, "slot4") || !strcmp(pszCurrentBinding, "slot5") || 
//		
//			// For creating groups
//			!strcmp(pszCurrentBinding, "+duck") || !strcmp(pszCurrentBinding, "-duck") ||
//		
//			// For testing ease
//			!strcmp(pszCurrentBinding, "givepoints")
//		
//			)))
//		{
			if (gViewPort)
				theProcessKeyBinding = gViewPort->KeyInput(down, keynum, pszCurrentBinding);
		
//			// Don't
//			if(!strcmp(pszCurrentBinding, "+jump") && gHUD.GetInTopDownMode())
//			{
//				gHUD.GotoAlert();
//			}

//		}
	}
	
	return theProcessKeyBinding;
}

void IN_BreakDown( void ) { KeyDown( &in_break );};
void IN_BreakUp( void ) { KeyUp( &in_break ); };
void IN_KLookDown (void) {KeyDown(&in_klook);}
void IN_KLookUp (void) {KeyUp(&in_klook);}
void IN_JLookDown (void) {KeyDown(&in_jlook);}
void IN_JLookUp (void) {KeyUp(&in_jlook);}
void IN_MLookDown (void) {KeyDown(&in_mlook);}
void IN_UpDown(void) {KeyDown(&in_up);}
void IN_UpUp(void) {KeyUp(&in_up);}
void IN_DownDown(void) {KeyDown(&in_down);}
void IN_DownUp(void) {KeyUp(&in_down);}
void IN_LeftDown(void) {KeyDown(&in_left);}
void IN_LeftUp(void) {KeyUp(&in_left);}
void IN_RightDown(void) {KeyDown(&in_right);}
void IN_RightUp(void) {KeyUp(&in_right);}

void IN_ForwardDown(void)
{
	KeyDown(&in_forward);
	gHUD.m_Spectator.HandleButtonsDown( IN_FORWARD );
}

void IN_ForwardUp(void)
{
	KeyUp(&in_forward);
	gHUD.m_Spectator.HandleButtonsUp( IN_FORWARD );
}

void IN_BackDown(void)
{
	KeyDown(&in_back);
	gHUD.m_Spectator.HandleButtonsDown( IN_BACK );
}

void IN_BackUp(void)
{
	KeyUp(&in_back);
	gHUD.m_Spectator.HandleButtonsUp( IN_BACK );
}
void IN_LookupDown(void) {KeyDown(&in_lookup);}
void IN_LookupUp(void) {KeyUp(&in_lookup);}
void IN_LookdownDown(void) {KeyDown(&in_lookdown);}
void IN_LookdownUp(void) {KeyUp(&in_lookdown);}
void IN_MoveleftDown(void)
{
	KeyDown(&in_moveleft);
	gHUD.m_Spectator.HandleButtonsDown( IN_MOVELEFT );
}

void IN_MoveleftUp(void)
{
	KeyUp(&in_moveleft);
	gHUD.m_Spectator.HandleButtonsUp( IN_MOVELEFT );
}

void IN_MoverightDown(void)
{
	KeyDown(&in_moveright);
	gHUD.m_Spectator.HandleButtonsDown( IN_MOVERIGHT );
}

void IN_MoverightUp(void)
{
	KeyUp(&in_moveright);
	gHUD.m_Spectator.HandleButtonsUp( IN_MOVERIGHT );
}
void IN_SpeedDown(void) {KeyDown(&in_speed);}
void IN_SpeedUp(void) {KeyUp(&in_speed);}
void IN_StrafeDown(void) {KeyDown(&in_strafe);}
void IN_StrafeUp(void) {KeyUp(&in_strafe);}
void IN_Attack2Down(void) {KeyDownForced(&in_attack2);}
void IN_Attack2Up(void) {KeyUpForced(&in_attack2);}
void IN_UseDown (void)
{
	KeyDown(&in_use);
	gHUD.m_Spectator.HandleButtonsDown( IN_USE );
}
void IN_UseUp (void) {KeyUp(&in_use);}
void IN_JumpDown (void)
{
	KeyDown(&in_jump);

	if(gHUD.GetInTopDownMode())
	{
		//gHUD.GotoAlert();
	}
	
	gHUD.m_Spectator.HandleButtonsDown( IN_JUMP );

}

void IN_JumpUp (void) 
{
    KeyUp(&in_jump);
    gHUD.m_Spectator.HandleButtonsUp( IN_JUMP );
}

void IN_DuckDown(void)
{
	KeyDown(&in_duck);
	gHUD.m_Spectator.HandleButtonsDown( IN_DUCK );
}

void IN_DuckUp(void) {KeyUp(&in_duck);}
// tankefugl: duck toggle
void IN_DuckToggle(void) 
{
	g_bDuckToggled = !g_bDuckToggled;
}
// :tankefugl
void IN_ReloadDown(void) {KeyDownForced(&in_reload);}
void IN_ReloadUp(void) {KeyUpForced(&in_reload);}
void IN_Alt1Down(void) {KeyDown(&in_alt1);}
void IN_Alt1Up(void) {KeyUp(&in_alt1);}
void IN_GraphDown(void) {KeyDown(&in_graph);}
void IN_GraphUp(void) {KeyUp(&in_graph);}

void IN_AttackDown(void)
{
	KeyDown( &in_attack );
	gHUD.m_Spectator.HandleButtonsDown( IN_ATTACK );
}

void IN_AttackUp(void)
{
	KeyUp( &in_attack );
	in_cancel = 0;
	IN_Attack2Up();
}

void IN_AttackDownForced(void)
{
	KeyDownForced( &in_attack );
}

void IN_AttackUpForced(void)
{
	KeyUpForced( &in_attack );
}

// Special handling
void IN_Cancel(void)
{
	in_cancel = 1;
}

bool CheckInAttack(void)
{
	return (in_attack.state & 1 || in_attack2.state & 1);
}

bool CheckInAttack2(void)
{
	return (in_attack2.state & 1);
}

void IN_Impulse (void)
{
	//char msg[1024];
	//sprintf(msg, "in_impulse=%s\n", gEngfuncs.Cmd_Argv(1));
	//CenterPrint(msg);

	in_impulse = atoi( gEngfuncs.Cmd_Argv(1) );
}

void IN_ScoreDown(void)
{
	KeyDown(&in_score);

	if ( gViewPort )
	{
		//if(gHUD.SwitchUIMode(SCOREBOARD_MODE))
		//{
			gViewPort->ShowScoreBoard();
		//}
	}
}

void IN_ScoreUp(void)
{
	KeyUp(&in_score);

	// Removed because it was getting called and hiding mouse <<< cgc >>>
	if ( gViewPort )
	{
		//if(gHUD.SwitchUIMode(MAIN_MODE))
		//{
			gViewPort->HideScoreBoard();
		//}
	}
}

void IN_MLookUp (void)
{
	/*KeyUp( &in_mlook );
	if ( !( in_mlook.state & 1 ) && lookspring->value )
	{
		V_StartPitchDrift();
	}*/
}

/*
===============
CL_KeyState

Returns 0.25 if a key was pressed and released during the frame,
0.5 if it was pressed and held
0 if held then released, and
1.0 if held for the entire time
===============
*/
float CL_KeyState (kbutton_t *key)
{
	float		val = 0.0;
	int			impulsedown, impulseup, down;
	
	impulsedown = key->state & 2;
	impulseup	= key->state & 4;
	down		= key->state & 1;
	
	if ( impulsedown && !impulseup )
	{
		// pressed and held this frame?
		val = down ? 0.5 : 0.0;
	}

	if ( impulseup && !impulsedown )
	{
		// released this frame?
		val = down ? 0.0 : 0.0;
	}

	if ( !impulsedown && !impulseup )
	{
		// held the entire frame?
		val = down ? 1.0 : 0.0;
	}

	if ( impulsedown && impulseup )
	{
		if ( down )
		{
			// released and re-pressed this frame
			val = 0.75;	
		}
		else
		{
			// pressed and released this frame
			val = 0.25;	
		}
	}

	// clear impulses
	key->state &= 1;		
	return val;
}

/*
================
CL_AdjustAngles

Moves the local angle positions
================
*/
void CL_AdjustAngles ( float frametime, float *viewangles )
{
	float	speed;
	float	up, down;
	
	if (in_speed.state & 1)
	{
		speed = frametime * cl_anglespeedkey->value;
	}
	else
	{
		speed = frametime;
	}

	if (!(in_strafe.state & 1))
	{
		viewangles[YAW] -= speed*cl_yawspeed->value*CL_KeyState (&in_right);
		viewangles[YAW] += speed*cl_yawspeed->value*CL_KeyState (&in_left);
		viewangles[YAW] = anglemod(viewangles[YAW]);
	}
	if (in_klook.state & 1)
	{
		V_StopPitchDrift ();
		viewangles[PITCH] -= speed*cl_pitchspeed->value * CL_KeyState (&in_forward);
		viewangles[PITCH] += speed*cl_pitchspeed->value * CL_KeyState (&in_back);
	}
	
	up = CL_KeyState (&in_lookup);
	down = CL_KeyState(&in_lookdown);
	
	viewangles[PITCH] -= speed*cl_pitchspeed->value * up;
	viewangles[PITCH] += speed*cl_pitchspeed->value * down;

	if (up || down)
		V_StopPitchDrift ();
		
	if (viewangles[PITCH] > 89)
		viewangles[PITCH] = 89;
	if (viewangles[PITCH] < -89)
		viewangles[PITCH] = -89;

	if (viewangles[ROLL] > 50)
		viewangles[ROLL] = 50;
	if (viewangles[ROLL] < -50)
		viewangles[ROLL] = -50;
}

/*
================
CL_CreateMove

Send the intended movement message to the server
if active == 1 then we are 1) not playing back demos ( where our commands are ignored ) and
2 ) we have finished signing on to server
================
*/
void CL_DLLEXPORT CL_CreateMove ( float frametime, struct usercmd_s *cmd, int active )
{	
	RecClCL_CreateMove(frametime, cmd, active);

	float spd;
	vec3_t viewangles;
	static vec3_t oldangles;

	if ( active && (!gViewPort || !gViewPort->IsOptionsMenuVisible()) /*&& !gHUD.GetShowingMap()*/)
	{
		int theButtonState = CL_ButtonBits( 1 );

        memset (cmd, 0, sizeof(*cmd));

		float theRotationDeltas[3] = {0,0,0};
		float theTranslationDeltas[3] = {0,0,0};

		IN_Move(frametime,theRotationDeltas,theTranslationDeltas);

		if(gResetViewAngles)
		{
			VectorCopy(gViewAngles,viewangles);
			gResetViewAngles = false;
		}
		else
		{
			gEngfuncs.GetViewAngles( (float *)viewangles );
		}
		VectorAdd(viewangles,theRotationDeltas,viewangles);
		CL_AdjustAngles ( frametime, viewangles );

		gEngfuncs.SetViewAngles( (float *)viewangles );
		VectorCopy (viewangles,gWorldViewAngles);

		// If we're in topdown mode
		bool theProcessedMove = false;
		bool theIsSendingSpecialEvent = false;
		bool theOverrideImpulse = false;
		float theWorldX, theWorldY;
		int theScriptImpulse = 0;

		AvHMessageID theAlienAbility = MESSAGE_NULL;
		AvHMessageID theGroupMessage = MESSAGE_NULL;

		//int theUpgradeVar = gEngfuncs.GetLocalPlayer()->curstate.iuser4;
		//bool theIsParalyzed = GetHasUpgrade(theUpgradeVar, PLAYER_PARALYZED);
		if(AvHScriptManager::Instance()->GetClientMove(theButtonState, theScriptImpulse))
		{
			if(theScriptImpulse)
			{
				theOverrideImpulse = true;
			}
			//theProcessedMove = true;
			
			// TODO: Pass theButtonState to override all CL_KeyState() calls
		}
		else if(gHUD.GetInTopDownMode())
		{
			cmd->upmove = cmd->sidemove = cmd->forwardmove = 0;

			// If a button was JUST pressed or released
			vec3_t theMouseNormPos;
			AvHMessageID theTechEvent = MESSAGE_NULL;
			if(gCommanderHandler.GetMoveToWorldPosition(theWorldX, theWorldY))
			{
				// Commander wants to scroll to an area of the mini-map
				cmd->impulse = COMMANDER_MOVETO;
				cmd->upmove = theWorldX/kWorldPosNetworkConstant;
				cmd->sidemove = theWorldY/kWorldPosNetworkConstant;
				gCommanderHandler.ClearMoveToPosition();
				gHUD.ClearTrackingEntity();
				
				theIsSendingSpecialEvent = true;
				theProcessedMove = true;
			}
			else if(gCommanderHandler.GetDefaultOrderPosition(theWorldX, theWorldY))
			{
				// Commander wants to scroll to an area of the mini-map
				cmd->impulse = COMMANDER_DEFAULTORDER;
				cmd->upmove = theWorldX/kWorldPosNetworkConstant;
				cmd->sidemove = theWorldY/kWorldPosNetworkConstant;
				gCommanderHandler.ClearDefaultOrderPosition();
				gHUD.ClearTrackingEntity();
				
				theIsSendingSpecialEvent = true;
				theProcessedMove = true;
			}
			else if(gHUD.GetAndClearTechEvent(theTechEvent))
			{
				cmd->impulse = theTechEvent;
				theProcessedMove = true;
				theIsSendingSpecialEvent = true;
				gHUD.ClearTrackingEntity();

			}
			// else scroll
			else
			{
				// Scroll the view if the HUD tells us to, otherwise use normal key presses
				int theScrollX = 0, theScrollY = 0, theScrollZ = 0;
				gHUD.GetAndClearTopDownScrollAmount(theScrollX, theScrollY, theScrollZ);
				
				if(theScrollX || theScrollY || theScrollZ)
				{
					// Commander move speed
					float kCommanderMoveSpeed = 1000;					
					cmd->upmove += kCommanderMoveSpeed * theScrollY;
					cmd->sidemove += kCommanderMoveSpeed * theScrollX;
					cmd->forwardmove += kCommanderMoveSpeed * theScrollZ;

					cmd->impulse = COMMANDER_SCROLL;
					theOverrideImpulse = true;

					gHUD.ClearTrackingEntity();

					//theIsSendingSpecialEvent = true;
					theProcessedMove = true;
				}
				else if(gHUD.GetAndClearGroupEvent(theGroupMessage))
				{
					cmd->impulse = theGroupMessage;
					theIsSendingSpecialEvent = true;
					theProcessedMove = true;
					
					gHUD.SetLastHotkeySelectionEvent(theGroupMessage);
				}
//				else if(gHUD.GetTrackingEntity() > 0)
//				{
//					int theTrackingEntity = gHUD.GetTrackingEntity();
//					cmd->upmove = theTrackingEntity*kHotKeyNetworkFactor;
//					cmd->impulse = COMMANDER_TRACKENTITY;
//					
//					theIsSendingSpecialEvent = true;
//					theProcessedMove = true;
//				}
                else if(in_impulse != 0)
                {
                    bool theProcessImpulse = false;
                    switch(in_impulse)
                    {
                    case COMMANDER_SELECTALL:
                    case COMMANDER_NEXTIDLE:
                    case COMMANDER_NEXTAMMO:
                    case COMMANDER_NEXTHEALTH:
                        theProcessImpulse = true;
                        break;
                    }

                    if(theProcessImpulse)
                    {
                        cmd->impulse = in_impulse;
                        in_impulse = 0;

                        theProcessedMove = true;
                        theIsSendingSpecialEvent = true;
                    }
                }

				if(!theProcessedMove && gHUD.GetAndClearSelectionEvent(theMouseNormPos, theTechEvent))
				{
					// Store world position x,y in upmove,sidemove 
					cmd->upmove = theMouseNormPos.x*kSelectionNetworkConstant;
					cmd->sidemove = theMouseNormPos.y*kSelectionNetworkConstant;
					cmd->forwardmove = theMouseNormPos.z*kSelectionNetworkConstant;
					
					// Set impulse indicating this
					//cmd->impulse = COMMANDER_MOUSECOORD;
					
					// This could be COMMANDER_MOUSECOORD or BUILD_TURRET or one of the other BUILD_ events
					// They are all sent the same way
					cmd->impulse = theTechEvent;
					
					// Order mode isn't currently used but may be in the future
					//cmd->weaponselect = gHUD.GetOrderMode();
					
					// Set buttons.  Attack gets turned off when we're in mouse mode (apparently)
					// so we need to set the buttons manually
					cmd->buttons = theButtonState;
					if(gHUD.GetMouseOneDown())
					{
						cmd->buttons |= IN_ATTACK;
					}
					if(gHUD.GetMouseTwoDown())
					{
						cmd->buttons |= IN_ATTACK2;
					}
					
					gHUD.ClearTrackingEntity();

					theIsSendingSpecialEvent = true;
					theProcessedMove = true;
				}
			}
		}
		else if(gHUD.GetAndClearAlienAbility(theAlienAbility))
		{
			cmd->impulse = theAlienAbility;
			
			// Added by mmcguire.
			// 255 signifies that the impulse came from us and not from the console.
			cmd->weaponselect = 255; 
			
			theProcessedMove = true;
			theIsSendingSpecialEvent = true;

		}

		// else process move normally
		if(!theProcessedMove)
		{
			if ( in_strafe.state & 1 )
			{
				cmd->sidemove += kSideSpeed * CL_KeyState (&in_right);
				cmd->sidemove -= kSideSpeed * CL_KeyState (&in_left);
			}
			
			cmd->sidemove += kSideSpeed * CL_KeyState (&in_moveright);
			cmd->sidemove -= kSideSpeed * 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 += kForwardSpeed * CL_KeyState (&in_forward);
				cmd->forwardmove -= kBackSpeed * CL_KeyState (&in_back);
			}	
		}
		
		if(!theIsSendingSpecialEvent)
		{
			// adjust for speed key
			if ( in_speed.state & 1 )
			{
				cmd->forwardmove *= cl_movespeedkey->value;
				cmd->sidemove *= cl_movespeedkey->value;
				cmd->upmove *= cl_movespeedkey->value;
			}
			
			// clip to maxspeed
			spd = gEngfuncs.GetClientMaxspeed();

			if ( spd != 0.0 )
			{
				// scale the 3 speeds so that the total velocity is not > cl.maxspeed
				float fmov = sqrt( (cmd->forwardmove*cmd->forwardmove) + (cmd->sidemove*cmd->sidemove) + (cmd->upmove*cmd->upmove) );
				
				if ( fmov > spd )
				{
					float fratio = spd / fmov;
					cmd->forwardmove *= fratio;
					cmd->sidemove *= fratio;
					cmd->upmove *= fratio;
				}
			}

			// Allow mice and other controllers to add their inputs
			cmd->forwardmove += theTranslationDeltas[0];
			cmd->sidemove += theTranslationDeltas[1];
			cmd->upmove += theTranslationDeltas[2];
			
			if(!theOverrideImpulse)
			{
				cmd->impulse = in_impulse;
				in_impulse = 0;
			}
			
			cmd->weaponselect = g_weaponselect;
			g_weaponselect = 0;
			
			//
			// set button and flag bits
			//
			cmd->buttons = theButtonState;

			// If they're in a modal dialog, or we're stunned, ignore the attack button.
			int theLocalUpgrades = gHUD.GetLocalUpgrades();
			if( GetClientVoiceMgr()->IsInSquelchMode() )
			{
				cmd->buttons &= ~IN_ATTACK;
			}
			
			// Using joystick?
			if ( in_joystick->value )
			{
				if ( cmd->forwardmove > 0 )
				{
					cmd->buttons |= IN_FORWARD;
				}
				else if ( cmd->forwardmove < 0 )
				{
					cmd->buttons |= IN_BACK;
				}
			}
		}
	}
	
	gEngfuncs.GetViewAngles( (float *)viewangles );

	// Set current view angles but not if frozen (this still allows you to rotate in first-person, but player model won't change)
	int theUser4 = gHUD.GetLocalUpgrades();
	bool theIsFrozen = GetHasUpgrade(theUser4, MASK_PLAYER_STUNNED) || GetHasUpgrade(theUser4, MASK_ALIEN_EMBRYO);

	if ( g_iAlive && !theIsFrozen)
	{
		VectorCopy( viewangles, cmd->viewangles );
		VectorCopy( viewangles, oldangles );
	}
	else
	{
		VectorCopy( oldangles, cmd->viewangles );
	}
}

/*
============
CL_IsDead

Returns 1 if health is <= 0
============
*/
int	CL_IsDead( void )
{
	return ( gHUD.m_Health.m_iHealth <= 0 ) ? 1 : 0;
}

/*
============
CL_ButtonBits

Returns appropriate button info for keyboard and mouse state
Set bResetState to 1 to clear old state info
============
*/
int CL_ButtonBits( int bResetState )
{
	int bits = 0;

	if ( in_attack.state & 3 )
	{
		bits |= IN_ATTACK;
	}

	if ( in_speed.state & 3 )
	{
		bits |= IN_WALK;
	}

	// tankefugl: duck toggle
	if ( g_bDuckToggled )
	{
		if (!(in_duck.state & 3))
		{
			bits |= IN_DUCK;
		}
	} 
	else if (in_duck.state & 3)
	{
		bits |= IN_DUCK;
	}
	// :tankefugl

	if (in_jump.state & 3)
	{
		bits |= IN_JUMP;
	}

	if ( in_forward.state & 3 )
	{
		bits |= IN_FORWARD;
	}
	
	if (in_back.state & 3)
	{
		bits |= IN_BACK;
	}

	if (in_use.state & 3)
	{
		bits |= IN_USE;
	}

	if (in_cancel)
	{
		bits |= IN_CANCEL;
	}

	if ( in_left.state & 3 )
	{
		bits |= IN_LEFT;
	}
	
	if (in_right.state & 3)
	{
		bits |= IN_RIGHT;
	}
	
	if ( in_moveleft.state & 3 )
	{
		bits |= IN_MOVELEFT;
	}
	
	if (in_moveright.state & 3)
	{
		bits |= IN_MOVERIGHT;
	}

	if (in_attack2.state & 3)
	{
		bits |= IN_ATTACK2;
	}

	if (in_reload.state & 3)
	{
		bits |= IN_RELOAD;
	}

	if (in_alt1.state & 3)
	{
		bits |= IN_ALT1;
	}

	if ( in_score.state & 3 )
	{
		bits |= IN_SCORE;
	}

	// Dead or in intermission? Shore scoreboard, too
	if ( CL_IsDead() || gHUD.m_iIntermission )
	{
		bits |= IN_SCORE;
	}

	if ( bResetState )
	{
		in_attack.state &= ~2;
		in_speed.state &= ~2;
		in_duck.state &= ~2;
		in_jump.state &= ~2;
		in_forward.state &= ~2;
		in_back.state &= ~2;
		in_use.state &= ~2;
		in_left.state &= ~2;
		in_right.state &= ~2;
		in_moveleft.state &= ~2;
		in_moveright.state &= ~2;
		in_attack2.state &= ~2;
		in_reload.state &= ~2;
		in_alt1.state &= ~2;
		in_score.state &= ~2;
	}

	return bits;
}

/*
============
CL_ResetButtonBits

============
*/
void CL_ResetButtonBits( int bits )
{
	int bitsNew = CL_ButtonBits( 0 ) ^ bits;

	// Has the attack button been changed
	if ( bitsNew & IN_ATTACK )
	{
		// Was it pressed? or let go?
		if ( bits & IN_ATTACK )
		{
			KeyDown( &in_attack );
		}
		else
		{
			// totally clear state
			in_attack.state &= ~7;
		}
	}
}

/*
============
InitInput
============
*/
void InitInput (void)
{
	gEngfuncs.pfnAddCommand ("+moveup",IN_UpDown);
	gEngfuncs.pfnAddCommand ("-moveup",IN_UpUp);
	gEngfuncs.pfnAddCommand ("+movedown",IN_DownDown);
	gEngfuncs.pfnAddCommand ("-movedown",IN_DownUp);
	gEngfuncs.pfnAddCommand ("+left",IN_LeftDown);
	gEngfuncs.pfnAddCommand ("-left",IN_LeftUp);
	gEngfuncs.pfnAddCommand ("+right",IN_RightDown);
	gEngfuncs.pfnAddCommand ("-right",IN_RightUp);
	gEngfuncs.pfnAddCommand ("+forward",IN_ForwardDown);
	gEngfuncs.pfnAddCommand ("-forward",IN_ForwardUp);
	gEngfuncs.pfnAddCommand ("+back",IN_BackDown);
	gEngfuncs.pfnAddCommand ("-back",IN_BackUp);
	gEngfuncs.pfnAddCommand ("+lookup", IN_LookupDown);
	gEngfuncs.pfnAddCommand ("-lookup", IN_LookupUp);
	gEngfuncs.pfnAddCommand ("+lookdown", IN_LookdownDown);
	gEngfuncs.pfnAddCommand ("-lookdown", IN_LookdownUp);
	gEngfuncs.pfnAddCommand ("+strafe", IN_StrafeDown);
	gEngfuncs.pfnAddCommand ("-strafe", IN_StrafeUp);
	gEngfuncs.pfnAddCommand ("+moveleft", IN_MoveleftDown);
	gEngfuncs.pfnAddCommand ("-moveleft", IN_MoveleftUp);
	gEngfuncs.pfnAddCommand ("+moveright", IN_MoverightDown);
	gEngfuncs.pfnAddCommand ("-moveright", IN_MoverightUp);
	gEngfuncs.pfnAddCommand ("+speed", IN_SpeedDown);
	gEngfuncs.pfnAddCommand ("-speed", IN_SpeedUp);
	gEngfuncs.pfnAddCommand ("+attack", IN_AttackDown);
	gEngfuncs.pfnAddCommand ("-attack", IN_AttackUp);
	//gEngfuncs.pfnAddCommand ("+movement", IN_Attack2Down);
	//gEngfuncs.pfnAddCommand ("-movement", IN_Attack2Up);
	gEngfuncs.pfnAddCommand ("+use", IN_UseDown);
	gEngfuncs.pfnAddCommand ("-use", IN_UseUp);
	gEngfuncs.pfnAddCommand ("+jump", IN_JumpDown);
	gEngfuncs.pfnAddCommand ("-jump", IN_JumpUp);
	gEngfuncs.pfnAddCommand ("impulse", IN_Impulse);
	gEngfuncs.pfnAddCommand ("+klook", IN_KLookDown);
	gEngfuncs.pfnAddCommand ("-klook", IN_KLookUp);
	gEngfuncs.pfnAddCommand ("+mlook", IN_MLookDown);
	gEngfuncs.pfnAddCommand ("-mlook", IN_MLookUp);
	gEngfuncs.pfnAddCommand ("+jlook", IN_JLookDown);
	gEngfuncs.pfnAddCommand ("-jlook", IN_JLookUp);
	gEngfuncs.pfnAddCommand ("+duck", IN_DuckDown);
	gEngfuncs.pfnAddCommand ("-duck", IN_DuckUp);
	// tankefugl: duck toggle
	gEngfuncs.pfnAddCommand ("toggleduck", IN_DuckToggle);
	// :tankefugl
	gEngfuncs.pfnAddCommand ("+reload", IN_ReloadDown);
	gEngfuncs.pfnAddCommand ("-reload", IN_ReloadUp);
	gEngfuncs.pfnAddCommand ("+alt1", IN_Alt1Down);
	gEngfuncs.pfnAddCommand ("-alt1", IN_Alt1Up);
	gEngfuncs.pfnAddCommand ("+score", IN_ScoreDown);
	gEngfuncs.pfnAddCommand ("-score", IN_ScoreUp);
	gEngfuncs.pfnAddCommand ("+showscores", IN_ScoreDown);
	gEngfuncs.pfnAddCommand ("-showscores", IN_ScoreUp);
	gEngfuncs.pfnAddCommand ("+graph", IN_GraphDown);
	gEngfuncs.pfnAddCommand ("-graph", IN_GraphUp);
	gEngfuncs.pfnAddCommand ("+break",IN_BreakDown);
	gEngfuncs.pfnAddCommand ("-break",IN_BreakUp);

	lookstrafe			= gEngfuncs.pfnRegisterVariable ( "lookstrafe", "0", FCVAR_ARCHIVE );
	lookspring			= gEngfuncs.pfnRegisterVariable ( "lookspring", "0", FCVAR_ARCHIVE );
	cl_anglespeedkey	= gEngfuncs.pfnRegisterVariable ( "cl_anglespeedkey", "0.67", 0 );
	cl_yawspeed			= gEngfuncs.pfnRegisterVariable ( "cl_yawspeed", "210", 0 );
	cl_pitchspeed		= gEngfuncs.pfnRegisterVariable ( "cl_pitchspeed", "225", 0 );
	cl_upspeed			= gEngfuncs.pfnRegisterVariable ( "cl_upspeed", "320", 0 );
	cl_movespeedkey		= gEngfuncs.pfnRegisterVariable ( "cl_movespeedkey", "0.3", 0 );
	//cl_pitchup			= gEngfuncs.pfnRegisterVariable ( "cl_pitchup", "89", 0 );
	//cl_pitchdown		= gEngfuncs.pfnRegisterVariable ( "cl_pitchdown", "89", 0 );

	cl_vsmoothing		= gEngfuncs.pfnRegisterVariable ( "cl_vsmoothing", "0.05", FCVAR_ARCHIVE );

	m_pitch			    = gEngfuncs.pfnRegisterVariable ( "m_pitch","0.022", FCVAR_ARCHIVE );
	m_yaw				= gEngfuncs.pfnRegisterVariable ( "m_yaw","0.022", FCVAR_ARCHIVE );
	m_forward			= gEngfuncs.pfnRegisterVariable ( "m_forward","1", FCVAR_ARCHIVE );
	m_side				= gEngfuncs.pfnRegisterVariable ( "m_side","0.8", FCVAR_ARCHIVE );

	cl_autohelp			= gEngfuncs.pfnRegisterVariable ( kvAutoHelp, "1.0", FCVAR_ARCHIVE );
	cl_centerentityid	= gEngfuncs.pfnRegisterVariable ( kvCenterEntityID, "0.0", FCVAR_ARCHIVE );
	cl_musicenabled		= gEngfuncs.pfnRegisterVariable ( kvMusicEnabled, "1.0", FCVAR_ARCHIVE );
	cl_musicvolume		= gEngfuncs.pfnRegisterVariable ( kvMusicVolume, "155", FCVAR_ARCHIVE );
	cl_musicdir			= gEngfuncs.pfnRegisterVariable ( kvMusicDirectory, "", FCVAR_ARCHIVE);
	cl_musicdelay		= gEngfuncs.pfnRegisterVariable ( kvMusicDelay, "90", FCVAR_ARCHIVE);
	cl_forcedefaultfov	= gEngfuncs.pfnRegisterVariable ( kvForceDefaultFOV, "0", FCVAR_ARCHIVE );
	cl_dynamiclights	= gEngfuncs.pfnRegisterVariable ( kvDynamicLights, "1", FCVAR_ARCHIVE );
	cl_buildmessages	= gEngfuncs.pfnRegisterVariable ( kvBuildMessages, "1", FCVAR_ARCHIVE);
	cl_quickselecttime	= gEngfuncs.pfnRegisterVariable ( kvQuickSelectTime, ".15", FCVAR_ARCHIVE );
	cl_highdetail		= gEngfuncs.pfnRegisterVariable ( kvHighDetail, "1", FCVAR_ARCHIVE );
	cl_cmhotkeys		= gEngfuncs.pfnRegisterVariable ( kvCMHotkeys, "qwerasdfzxcv", FCVAR_ARCHIVE );
	cl_forcedefaultfov	= gEngfuncs.pfnRegisterVariable ( kvForceDefaultFOV, "0", FCVAR_ARCHIVE );
	cl_particleinfo		= gEngfuncs.pfnRegisterVariable ( kvParticleInfo, "0", FCVAR_ARCHIVE );

	// Initialize third person camera controls.
	CAM_Init();
	// Initialize inputs
	IN_Init();
	// Initialize keyboard
	KB_Init();
	// Initialize view system
	V_Init();
}

/*
============
ShutdownInput
============
*/
void ShutdownInput (void)
{
	IN_Shutdown();
	KB_Shutdown();
}

void CL_DLLEXPORT HUD_Shutdown( void )
{
	RecClShutdown();

	ShutdownInput();

	gHUD.Shutdown();
}