Engine.PlayerInput

//=============================================================================
// PlayerInput
// Object within playercontroller that manages player input.
// only spawned on client
//=============================================================================

class PlayerInput extends Object within PlayerController
	config(User)
	native
	transient;

var globalconfig	bool	bMaxMouseSmoothing;
var globalconfig	bool	bInvertMouse;

var bool		bWasForward;	// used for doubleclick move 
var bool		bWasBack;
var bool		bWasLeft;
var bool		bWasRight;
var bool		bEdgeForward;
var bool		bEdgeBack;
var bool		bEdgeLeft;
var bool 		bEdgeRight;

// Mouse smoothing
var globalconfig float	MouseSensitivity;
var float SmoothMouseX, SmoothMouseY, BorrowedMouseX, BorrowedMouseY;
var globalconfig float MouseSmoothThreshold;
var float MouseZeroTime;

//!!MJL (mdf) do we even need this any more given that I made dodging identical 
// in terms of physics to jumping? Just have animation controller occasionally
// pick dodge animation instead of jump animation for 3rd person views (dm)?
var	float DoubleClickTimer; // max double click interval for double click move
var globalconfig float	DoubleClickTime;

//=============================================================================
// Input related functions.

// Postprocess the player's input.
event PlayerInput( float DeltaTime )
{
	local float FOVScale, MouseScale, AbsSmoothX, AbsSmoothY, MouseTime;
				
	// Check for Double click move
	// flag transitions
	bEdgeForward = (bWasForward ^^ (aBaseY > 0));
	bEdgeBack = (bWasBack ^^ (aBaseY < 0));
	bEdgeLeft = (bWasLeft ^^ (aStrafe > 0));
	bEdgeRight = (bWasRight ^^ (aStrafe < 0));
	bWasForward = (aBaseY > 0);
	bWasBack = (aBaseY < 0);
	bWasLeft = (aStrafe > 0);
	bWasRight = (aStrafe < 0);
	
	// Smooth and amplify mouse movement
	FOVScale = DesiredFOV * 0.01111; 
	MouseScale = MouseSensitivity * FOVScale;

	aMouseX *= MouseScale;
	aMouseY *= MouseScale;
	MouseTime = (Level.TimeSeconds - MouseZeroTime)/Level.TimeDilation;
	SmoothMouse(aMouseX, MouseTime, SmoothMouseX, BorrowedMouseX, AbsSmoothX);
	SmoothMouse(aMouseY, MouseTime, SmoothMouseY, BorrowedMouseY, AbsSmoothY);

	if ( (aMouseX != 0) || (aMouseY != 0) )
		MouseZeroTime = Level.TimeSeconds;

	// adjust keyboard and joystick movements
	aLookUp *= FOVScale;
	aTurn   *= FOVScale;

	// Remap raw x-axis movement.
	if( bStrafe!=0 ) // strafe
		aStrafe += aBaseX + SmoothMouseX;
	else // forward
		aTurn  += aBaseX * FOVScale + SmoothMouseX;
	aBaseX = 0;

	// Remap mouse y-axis movement.
	if( (bStrafe == 0) && (bAlwaysMouseLook || (bLook!=0)) )
	{
		// Look up/down.
		if ( bInvertMouse )
			aLookUp -= SmoothMouseY;
		else
			aLookUp += SmoothMouseY;
	}
	else // Move forward/backward.
		aForward += SmoothMouseY;

	SmoothMouseX = AbsSmoothX;
	SmoothMouseY = AbsSmoothY;

	if ( bSnapLevel != 0 )
	{
		bCenterView = true;
		bKeyboardLook = false;
	}
	else if (aLookUp != 0)
	{
		bCenterView = false;
		bKeyboardLook = true;
	}
	else if ( bSnapToLevel && !bAlwaysMouseLook )
	{
		bCenterView = true;
		bKeyboardLook = false;
	}

	// Remap other y-axis movement.
	if ( bFreeLook != 0 )
	{
		bKeyboardLook = true;
		aLookUp += 0.5 * aBaseY * FOVScale;
	}
	else
		aForward += aBaseY;
	aBaseY = 0;

	// scale inputs FIXME REMOVE
		aForward *= 4;
		aStrafe  *= 4;
		aLookup  *= 0.24;
		aTurn    *= 0.24;
		aUp		 *= 1;

	// Handle walking.
	HandleWalking();
}

function SmoothMouse(float aMouse, float MouseTime, out float SmoothMouse, out float BorrowedMouse, out float AbsSmooth)
{
	AbsSmooth = SmoothMouse;
	if ( bMaxMouseSmoothing && (aMouse == 0) && (MouseTime < MouseSmoothThreshold) )
	{
		SmoothMouse = 0.5 * (MouseSmoothThreshold - MouseTime) * AbsSmooth/MouseSmoothThreshold;
		BorrowedMouse += SmoothMouse;
	}
	else
	{
		if ( (SmoothMouse == 0) || (aMouse == 0) 
				|| ((SmoothMouse > 0) != (aMouse > 0)) )
		{
			SmoothMouse = aMouse;
			BorrowedMouse = 0;
		}
		else
		{
			SmoothMouse = 0.5 * (SmoothMouse + aMouse - BorrowedMouse);
			if ( (SmoothMouse > 0) != (aMouse > 0) )
			{
				if ( AMouse > 0 )
					SmoothMouse = 1;
				else
					SmoothMouse = -1;
			} 
			BorrowedMouse = SmoothMouse - aMouse;
		}
		AbsSmooth = SmoothMouse;
	}
}

function UpdateSensitivity(float F)
{
	MouseSensitivity = FMax(0,F);
}

function ChangeSnapView( bool B )
{
	bSnapToLevel = B;
}

exec function SetMouseSmoothThreshold( float F )
{
	MouseSmoothThreshold = FClamp(F, 0, 0.1);
	SaveConfig();
}

// check for double click move
function Actor.eDoubleClickDir CheckForDoubleClickMove(float DeltaTime)
{
	local Actor.eDoubleClickDir DoubleClickMove, OldDoubleClick;

	if ( DoubleClickDir == DCLICK_Active )
		DoubleClickMove = DCLICK_Active;
	else
		DoubleClickMove = DCLICK_None;
	if (DoubleClickTime > 0.0)
	{
		if ( DoubleClickDir < DCLICK_Active )
		{
			OldDoubleClick = DoubleClickDir;
			DoubleClickDir = DCLICK_None;

			if (bEdgeForward && bWasForward)
				DoubleClickDir = DCLICK_Forward;
			else if (bEdgeBack && bWasBack)
				DoubleClickDir = DCLICK_Back;
			else if (bEdgeLeft && bWasLeft)
				DoubleClickDir = DCLICK_Left;
			else if (bEdgeRight && bWasRight)
				DoubleClickDir = DCLICK_Right;

			if ( DoubleClickDir == DCLICK_None)
				DoubleClickDir = OldDoubleClick;
			else if ( DoubleClickDir != OldDoubleClick )
				DoubleClickTimer = DoubleClickTime + 0.5 * DeltaTime;
			else 
				DoubleClickMove = DoubleClickDir;
		}

		if (DoubleClickDir == DCLICK_Done)
		{
			DoubleClickTimer -= DeltaTime;
			if (DoubleClickTimer < -0.35) 
			{
				DoubleClickDir = DCLICK_None;
				DoubleClickTimer = DoubleClickTime;
			}
		}		
		else if ((DoubleClickDir != DCLICK_None) && (DoubleClickDir != DCLICK_Active))
		{
			DoubleClickTimer -= DeltaTime;			
			if (DoubleClickTimer < 0)
			{
				DoubleClickDir = DCLICK_None;
				DoubleClickTimer = DoubleClickTime;
			}
		}
	}
	return DoubleClickMove;
}

defaultproperties
{
	MouseSensitivity=3.031496
	MouseSmoothThreshold=0.070000
	DoubleClickTime=0.196850
}