U2.U2PlayerNetTestController

//=============================================================================
// U2PlayerController.uc
//=============================================================================

class U2PlayerNetTestController extends U2PlayerTestController
	config(User);

/*
  mjl-note:
  Would have used struct inheritence to do this (much nicer for the following code),
  but passing inherited structs between functions causes stack corruption. :(
*/

struct MiniMove {
	var float<0.000,0.512,0.001> ElapsedTime;
	var vector Accel;
	var bool bRun;
	var bool bDuck;
	var bool bJump;
	var EDoubleClickDir DodgeDir;
};

struct FullMove {
	var MiniMove MiniMove;
	var bool bFire;
	var bool bAltFire;
	var bool bReload;
	var int<0,65535,2> Pitch;
	var int<0,65535> Yaw;
};

struct StoredMove {
	var FullMove FullMove;
	var int<0,65536> MoveSequence;
	var vector CurLocation;
//	var vector Accel;
};

//client var
var int CurrentMoveSequence;

//server + client var
var int LastMoveSequence;

//server var
var int LastUpdateMoveSequence, LastCorrectionMoveSequence;
var float ServerMoveTimeStamp;

var StoredMove StoredMoves[100];

// toggle support
var globalconfig bool bUseDuckToggles, bUseLeanToggles, bUseRunToggles;
var byte bRunToggle, bDuckToggle;
var byte bRunLast, bDuckLast, bLeanLast;

//-----------------------------------------------------------------------------

replication 
{
	unreliable if (Role == ROLE_Authority)
		ClientAdjustPositionEx;
		
	unreliable if (Role < ROLE_Authority)
		ServerMoveEx;
}

//-----------------------------------------------------------------------------

function byte GetRunFlag()
{
	if( bUseRunToggles )
		return bRunToggle;
	else
		return GetbRun();
}

//-----------------------------------------------------------------------------

function byte GetDuckFlag()
{
	if( bUseDuckToggles )
		return bDuckToggle;
	else
		return GetbDuck();
}

//-----------------------------------------------------------------------------

function SetRunFlag( byte Val )
{
	if( bUseRunToggles )
		bRunToggle = Val;
	else
		Super.SetRunFlag( Val );
}

//-----------------------------------------------------------------------------

function SetDuckFlag( byte Val )
{
	if( bUseDuckToggles )
		bDuckToggle = Val;
	else
		Super.SetDuckFlag( Val );

	if( LPawn != None )
	{
		if( Val == 0 )
			LPawn.SetStance( ST_Standing );
		else if( Val == 1 )
			LPawn.SetStance( ST_Crouching );
		else
			LPawn.SetStance( ST_Prone );
	}
}

//-----------------------------------------------------------------------------

function int BestSignedDifference( int Value, int Reference, int Max )
{
	return ((Value-Reference+Max/2) & (Max-1)) - Max/2;
}

//-----------------------------------------------------------------------------

function int MakeRelative( int Value, int Reference, int Max )
{
	return Reference + BestSignedDifference(Value,Reference,Max);
}

//-----------------------------------------------------------------------------

function ProcessMiniMoveEx( MiniMove Move, optional rotator DeltaRot  )
{
	local Actor MoveActor;
	
	if( Viewport(Player) == None )
	{
		bPressedJump = false;
		if ( Move.bJump && Pawn.IsStanding() )
		{
			if ( bJump == 0 )
				bPressedJump = true;
			bJump = 1;
		}
		else
		{
			bJump = 0;
		}
	}

	HandleWalking();

	Acceleration = Move.Accel;//vector( rot(1,0,0) * Move.AccelPitch  +  rot(0,1,0) * Move.AccelYaw );
	if ( Pawn != None )
		Pawn.Acceleration = Move.Accel;

	if( Pawn != None )
		MoveActor = Pawn;
	else
		MoveActor = Self;

	//log("State:  "$GetStateName());	
	//log("Physics:"$MoveActor.Physics);	
	//log("Gravity:"$MoveActor.PhysicsVolume.Gravity);	
	//log("Accel:  "$MoveActor.Acceleration);
	//log("Time:   "$Move.ElapsedTime);
	//log("BefLoc: "$MoveActor.Location);
	//log("BefVel: "$MoveActor.Velocity);

	//Direction = (accel >> (rot(0,1,0)*viewrotation.yaw));
	//bForward  = (Direction.X > 0);
	//bBackward = (Direction.X < 0);
	//bLeft     = (Direction.Y < 0);
	//bRight    = (Direction.Y > 0);
	//bUp       = (Direction.Z > 0);
	//bDown     = (Direction.Z < 0);
	

	//time-cheat checks
	// do this if we don't have a viewport ... 
	// ie, if we are on the server where player is a netconnection, not a viewport
	if( Viewport(Player) == None &&  ServerMoveTimeStamp > 0 )
	{
		TimeMargin += Move.ElapsedTime - 1.01 * (Level.TimeSeconds - ServerMoveTimeStamp) * ActorTimeDilation;
		if( TimeMargin > MaxTimeMargin )
		{
			TimeMargin -= Move.ElapsedTime;
			if ( TimeMargin < 0.5 )
				MaxTimeMargin = Default.MaxTimeMargin;
			else
				MaxTimeMargin = 0.5;
			Move.ElapsedTime = 0;
			//mjl-tbd: remove this for ship, use it to test movement drops
			log("Dropping Move for "$PlayerReplicationInfo.PlayerName$" with TimeMargin "$TimeMargin);
		}
	}
	ServerMoveTimeStamp = Level.TimeSeconds;

	MoveActor.AutonomousPhysics(Move.ElapsedTime);
	// this is done so the controller is in the same place as the pawn ... needed for stasis grenades, among other things
	if( MoveActor != Self )
		SetLocation(MoveActor.Location);

	//log("AftLoc: "$MoveActor.Location);
	//log("AftVel: "$MoveActor.Velocity);
}

//-----------------------------------------------------------------------------

protected function ServerMoveEx
(
	int<0,65536> MoveSequence,
	vector CurLocation,
	FullMove NewMove,
	optional MiniMove OldMove //don't send this if there isn't any packetloss
) 
{
	local int MissedMoves;
	local vector LocDiff;
	local actor MoveActor;
	
	if ( Pawn != None )
		MoveActor = Pawn;
	else 
		MoveActor = self;

	//	log("Move0 Time: "$Move0.MiniMove.ElapsedTime$", Fire: "$Move0.bFire$", AltFire: "$Move0.bAltFire$", Jump: "$Move0.MiniMove.bJump$", Run: "$Move0.MiniMove.bRun);//$", Accel.Yaw: "$Move0.MiniMove.AccelYaw$", Accel.Pitch: "$Move0.MiniMove.AccelPitch);
	MoveSequence = MakeRelative( MoveSequence, LastMoveSequence, 65536);

	//discard already processed moves
	if( LastMoveSequence >= MoveSequence )
		return;
	//log("ServerMoveEx with MoveSequence "$MoveSequence);
	//log("Receiving NewMove Accel: "$NewMove.MiniMove.Accel);
	//log("Receiving OldMove Accel: "$OldMove.Accel);

	MissedMoves = (MoveSequence - LastMoveSequence);
	//log("Missed Moves: "$MissedMoves);
	//log("Location1: "$MoveActor.Location);
	if( MissedMoves > 1 )
		ProcessMiniMoveEx(OldMove);
	if( MissedMoves > 0 )
		ProcessFullMoveEx(NewMove);
	//log("Location2: "$MoveActor.Location);

	if( Pawn != None )
		LocDiff = CurLocation - Pawn.Location;
	else
		LocDiff = CurLocation - Location;
	//log("Sent location: "$CurLocation);
	//log("LocDiff: "$LocDiff);
	if( MoveSequence - LastUpdateMoveSequence > 20 || MissedMoves > 2 )
	{
		LastUpdateMoveSequence = MoveSequence;
		SetupClientAdjustPositionEx(MoveSequence);
	} else {
		if (MoveSequence - LastCorrectionMoveSequence > 10 && LocDiff dot LocDiff > 3 )
		{
			LastUpdateMoveSequence = MoveSequence;
			LastCorrectionMoveSequence = MoveSequence;
			SetupClientAdjustPositionEx(MoveSequence);
		}
	}
	
	LastMoveSequence = MoveSequence;
}

//-----------------------------------------------------------------------------

function SetupClientAdjustPositionEx( int MoveSequence )
{
	local vector ClientLocation, ClientVelocity;
	local actor ClientBase;
	local EPhysics ClientPhysics;
	local bool ClientMantling;
	
	if( Pawn != None )
	{
		if ( Mover(Pawn.Base) != None )
			ClientLocation = Pawn.Location - Base.Location;
		else
			ClientLocation = Pawn.Location;
		ClientVelocity = Pawn.Velocity;
		ClientPhysics  = Pawn.Physics;
		ClientBase     = Pawn.Base;
		if( LPawn != None )
			ClientMantling = LPawn.bMantling;
	}
	else
	{
		ClientPhysics = Physics;
		ClientLocation = Location;
	}
	//log("Updating client at "$Level.TimeSeconds$" with "$MoveSequence);
	ClientAdjustPositionEx( Pawn!=None, MoveSequence%65536, ClientMantling, ClientLocation, ClientVelocity, GetStateName(), ClientPhysics, ClientBase );
}

//-----------------------------------------------------------------------------

function ClientAdjustPositionEx (
	bool OnPawn,
	int<0,65536> MoveSequence,
	bool ClientMantling,
	vector ClientLocation,
	vector ClientVelocity,
	name ClientStateName,
	EPhysics ClientPhysics,
	Actor ClientBase
) 
{
	local actor MoveActor;
	local StoredMove LastMove;
	local vector LocDiff;
	
	MoveSequence = MakeRelative( MoveSequence, LastMoveSequence, 65536);

	if( MoveSequence <= LastMoveSequence )
		return;
	LastMoveSequence = MoveSequence;

	//set vel/loc
	if ( OnPawn )
		MoveActor = Pawn;
	else 
		MoveActor = self;

	//this check is to ensure that we don't try moving on a null Pawn, when the server has a Pawn, but the client does not
	if( MoveActor == None )
		return;

	//log("CAP: MoveSequence "$MoveSequence);
	//only update if needed (could be due to inaccuracies in ClientLocation replication)
	LastMove = StoredMoves[MoveSequence % ArrayCount(StoredMoves)];
	if( ClientStateName != MoveActor.GetStateName() )
		GotoState(ClientStateName);
	if( LastMove.MoveSequence == MoveSequence )
	{
		LocDiff = LastMove.CurLocation-ClientLocation;
		if( LocDiff dot LocDiff > 3 )
		{
			if( LPawn != None )
				LPawn.bMantling = ClientMantling;
	
			MoveActor.Velocity = ClientVelocity;
			MoveActor.SetBase(ClientBase);
	
			if (Mover(ClientBase) != None)
				ClientLocation += ClientBase.Location;
	
			MoveActor.SetPhysics(ClientPhysics);

			MoveActor.bCanTeleport = false;
			MoveActor.SetLocation(ClientLocation);
			MoveActor.bCanTeleport = true;
			//causes ClientUpdatePositionEx to be called later this Tick
			bUpdatePosition = true;
		}
	}
}

//-----------------------------------------------------------------------------

function ClientUpdatePosition()
{
	local int i;
	local byte bRunReal, bDuckReal;
	local bool bPressedJumpReal;
	local StoredMove Move;
	local Actor MoveActor;
	
	bUpdatePosition = false;

	if ( Pawn != None )
		MoveActor = Pawn;
	else 
		MoveActor = self;

	bRunReal  = GetRunFlag();
	bDuckReal = GetDuckFlag();
	bPressedJumpReal = bPressedJump;
	bUpdating = true;
	//log("CAP: Replay Location: "$MoveActor.Location);
	//replay old moves
	while( i < ArrayCount(StoredMoves) )
	{
		Move = StoredMoves[(LastMoveSequence+i) % ArrayCount(StoredMoves)];
		if( Move.MoveSequence > LastMoveSequence )
		{
			//log("CAP: Playing Move "$Move.MoveSequence$" with elapsed time "$Move.FullMove.MiniMove.ElapsedTime);
			if( Pawn != None )
				AdjustRadius(Move.FullMove.MiniMove.ElapsedTime * Pawn.GroundSpeed);
			ProcessFullMoveEx(Move.FullMove);
		}
		i++;
	}
	//log("CAP: Final Location: "$MoveActor.Location);
	SetDuckFlag( bDuckReal );
	SetRunFlag( bRunReal );
	bPressedJump = bPressedJumpReal;
	bUpdating = false;
}

//-----------------------------------------------------------------------------
// Combine the passed in move (or none) with the current player's move, and return it

function StoredMove GenerateMoveEx( float DeltaTime, vector NewAccel, EDoubleClickDir DoubleClickMove, optional StoredMove Move )
{
	local vector Acceleration;
	local rotator AccelRot;
	local int temp;

	Move.MoveSequence = CurrentMoveSequence+1;

	Move.FullMove.MiniMove.Accel = (DeltaTime * NewAccel + Move.FullMove.MiniMove.ElapsedTime * Move.FullMove.MiniMove.Accel)/(DeltaTime + Move.FullMove.MiniMove.ElapsedTime);
	// round off the Accel to make it identical to the value sent to the server ... 0 decimal places
	Move.FullMove.MiniMove.Accel.X = int( Move.FullMove.MiniMove.Accel.X + 0.5 );
	Move.FullMove.MiniMove.Accel.Y = int( Move.FullMove.MiniMove.Accel.Y + 0.5 );
	Move.FullMove.MiniMove.Accel.Z = int( Move.FullMove.MiniMove.Accel.Z + 0.5 );

	Move.FullMove.MiniMove.ElapsedTime += DeltaTime;
	// round off the ElapsedTime to make it identical to the value sent to the server ... 3 decimal places
	Move.FullMove.MiniMove.ElapsedTime = int( Move.FullMove.MiniMove.ElapsedTime * 1000 + 0.5 ) / 1000.0;

	Move.FullMove.bFire = Move.FullMove.bFire || (bFire != 0);
	Move.FullMove.bAltFire = Move.FullMove.bAltFire || (bAltFire != 0);
	Move.FullMove.MiniMove.bJump = Move.FullMove.MiniMove.bJump || (bJump != 0);
	Move.FullMove.MiniMove.bRun = Move.FullMove.MiniMove.bRun || GetRunFlag() > 0;
	Move.FullMove.MiniMove.bDuck = Move.FullMove.MiniMove.bDuck || GetDuckFlag() > 0;
	if( Move.FullMove.MiniMove.DodgeDir == DCLICK_None )
		Move.FullMove.MiniMove.DodgeDir = DoubleClickMove;
	Move.FullMove.Pitch = Rotation.Pitch & 65535;
	Move.FullMove.Yaw = Rotation.Yaw   & 65535;
	
	if( Pawn != None )
		Move.CurLocation = Pawn.Location;
	else
		Move.CurLocation = Location;
	return Move;
}

//-----------------------------------------------------------------------------
// Store the current Move into the StoredMoves array for later replaying

function StoreMoveEx( StoredMove Move )
{
	local StoredMove BlankMove;
	StoredMoves[(Move.MoveSequence) % ArrayCount(StoredMoves)] = Move;
	CurrentMoveSequence = Move.MoveSequence;
}

//-----------------------------------------------------------------------------

protected function HandleMove
(
	float DeltaTime, 
	vector NewAccel, 
	eDoubleClickDir DoubleClickMove, 
	rotator DeltaRot
) 
{
	local StoredMove Move;
	local byte bRunLocal, bDuckLocal;
	local ELeanDir NewLeanDir;
	
	bRunLocal = GetbRun();
	bDuckLocal = GetbDuck();
	
	if( bUseRunToggles )
	{
		if( bRunLast == 0 && bRunLocal > 0 )
		{
			if( bRunToggle == 0 )
				bRunToggle = 1;
			else
				bRunToggle = 0;
		}
		bRunLast = bRunLocal;
	}
	
	if( bUseDuckToggles )
	{
		if( Pawn != None && Pawn.CanCrouch() )
		{
			if( bDuckLast == 0 && bDuckLocal > 0 )
			{
				// duck key does standing -> crouching -> prone
				if( bDuckToggle == 0 )
					SetDuckFlag( 1 );
				else if( bDuckToggle == 1 && OKToCheat() )
					SetDuckFlag( 2 );
			}
			
			if( bJump > 0 && bDuckToggle > 0 )
			{
				// jump key does prone -> crouching -> standing -> jump
				SetDuckFlag( bDuckToggle - 1 );
				bJump = 0;
			}
							
			bDuckLast = bDuckLocal;
		}
	}
	else
	{
		//DMTNS( "bJump: " $ bJump $ " bDuckLocal: " $ bDuckLocal );
		if( LPawn != None && LPawn.IsProne() )
		{
			// currently prone
			if( bJump == 0 && bDuckLocal == 0 )
			{
				// jumping and not ducking -- stand
				//DMTNS( "prone -> standing" );
				SetDuckFlag( 0 );
			}
			else if( bJump == 0 && bDuckLocal > 0 )
			{
				// not jumping and ducking -- crouch
				//DMTNS( "prone -> ducking" );
				SetDuckFlag( 1 );
			}
			else
			{
				//DMTNS( "stay prone" );
			}
		}
		else if( LPawn != None && LPawn.IsCrouching() )
		{
			// currently crouching
			if( bJump > 0 && bDuckLocal > 0 )
			{
				// jumping and ducking -- prone
				//DMTNS( "ducking -> prone" );
				if( OKToCheat() )
					SetDuckFlag( 2 );
			}
			else if( bJump == 0 && bDuckLocal == 0 )
			{
				//DMTNS( "ducking -> standing" );
				// not jumping and not ducking -- stand
				SetDuckFlag( 0 );
			}
			else
			{
				//DMTNS( "stay crouching" );
			}
		}
		else
		{
			// currently standing
			//DMTNS( "SetDuckFlag " $ bDuckLocal );
			SetDuckFlag( bDuckLocal );
		}
	}

	NewLeanDir = Lean_None;
	if( bLeanForward > 0 )
		NewLeanDir = Lean_Forward;
	else if( bLeanLeft > 0 )
		NewLeanDir = Lean_Left;
	else if( bLeanRight > 0 )
		NewLeanDir = Lean_Right;
	else if( bLeanUp > 0 )
		NewLeanDir = Lean_Up;

	if( bUseLeanToggles )
	{
		//DMTNS( "NewLeanDir: " $ NewLeanDir $ " bLeanLast: " $ bLeanLast $ " CanLean: " $ CanLean() );
		
		if( bLeanLast == 0 && NewLeanDir != Lean_None )
		{
			if( LeanDir != Lean_None )
				LeanEnd();
			else if( CanLean() )
				LeanBegin( NewLeanDir );
				
			bLeanLast = 1;
		}
		else if( NewLeanDir == Lean_None )
		{
			bLeanLast = 0;
		}
	}
	else
	{
		if( (LeanDir == Lean_None || NewLeanDir == Lean_None) && NewLeanDir != LeanDir )
		{
			//DMTNS( "NewLeanDir: " $ NewLeanDir $ " CanLean: " $ CanLean() );
			if( NewLeanDir == Lean_None )
				LeanEnd();
			else if( CanLean() )
				LeanBegin( NewLeanDir );
		}
	}
		
	if ( Role < ROLE_Authority ) // then save this move and replicate it
		ReplicateMoveEx(DeltaTime, NewAccel, DoubleClickMove, DeltaRot);
	else
	{
		Move = GenerateMoveEx(DeltaTime, newAccel, DoubleClickMove);
		ProcessFullMoveEx(Move.FullMove,DeltaRot);
	}
}

//-----------------------------------------------------------------------------

protected function ReplicateMoveEx
(
	float DeltaTime, 
	vector NewAccel, 
	eDoubleClickDir DoubleClickMove, 
	rotator DeltaRot
) 
{
	local actor MoveActor;
	local StoredMove Move;
	local bool OldBMantling;
	//local bool bImportant;
	
	if( Pawn != None)
		MoveActor = Pawn;
	else
		MoveActor = Self;

	//log("Move Accel: "$Move.FullMove.MiniMove.Accel$", Time: "$Move.FullMove.MiniMove.ElapsedTime$", Fire: "$Move.FullMove.bFire$", AltFire: "$Move.FullMove.bAltFire$", Jump: "$Move.FullMove.MiniMove.bJump$", Run: "$Move.FullMove.MiniMove.bRun);//$", Accel.Yaw: "$Move.FullMove.MiniMove.AccelYaw$", Accel.Pitch: "$Move.FullMove.MiniMove.AccelPitch);
	
	//log("Local MoveSequence: "$CurrentMoveSequence+1);

	if( LPawn != None )
		OldBMantling = LPawn.bMantling;
	// Simulate the movement locally.
	Move = GenerateMoveEx(DeltaTime, NewAccel, DoubleClickMove);
	// Adjust radius of nearby players with uncertain location
	if ( Pawn != None )
		AdjustRadius(Move.FullMove.MiniMove.ElapsedTime * Pawn.GroundSpeed);
	ProcessFullMoveEx(Move.FullMove);

	Move.CurLocation = MoveActor.Location;
	//	Move = GenerateMoveEx(DeltaTime, NewAccel, DoubleClickMove, Move);

	// Check if it's important move, and unset the variables
	//	bImportant = bFire != 0 || bAltFire != 0 || bPressedJump || (LPawn != None && OldBMantling != LPawn.bMantling);
	//	bPressedJump = false;

	//	// If it's important, or we've waited long enough, call ServerMoveEx
	//	if ( Move.FullMove.MiniMove.ElapsedTime < 64.0/Player.CurrentNetSpeed && !bImportant )
	//		return; //don't send move, but just let it ripen inside the Move
	//log("updating at "$Level.TimeSeconds);
	
	ServerMoveEx
	(
		Move.MoveSequence%65536,
		Move.CurLocation,
		Move.FullMove,
		StoredMoves[(Move.MoveSequence-1)%ArrayCount(StoredMoves)].FullMove.MiniMove
	);
	StoreMoveEx(Move);
}

//-----------------------------------------------------------------------------

function ProcessFullMoveEx( FullMove Move, optional rotator DeltaRot )
{
	local rotator Rot;
	local int maxPitch;
	
	//only do this where there is no local client
	//moves which are grouped together into one move can
	//   cause problems where it 'sets' bFire again when it shouldn't be
	if( Viewport(Player) == None )
	{
		if ( Move.bFire )
		{
			if ( bFire == 0 )
			{
				bFire = 1;
				Fire();
			}
		}
		else
			bFire = 0;
		
		if ( Move.bAltFire )
		{
			if ( bAltFire == 0 )
			{
				bAltFire = 1;
				AltFire();
			}
		}
		else
			bAltFire = 0;
	}

	if( !bUpdating )
		SetRotation(rot(1,0,0) * Move.Pitch  +  rot(0,1,0) * Move.Yaw);

	//the following code constrain's the Pawn's rotation.
	if( Pawn != None )
	{
		Rot = Rotation;
		Rot.Yaw = Rotation.Yaw;

		if ( (Pawn.Physics == PHYS_Swimming) || (Pawn.Physics == PHYS_Flying) )
			maxPitch = 2;
		else
			maxPitch = 0; //NEW (mdf) we have procedural aiming now (leave alone for swimming, flying?
			//OLD maxPitch = 1;
		if ( (Rotation.Pitch > maxPitch * RotationRate.Pitch) && (Rotation.Pitch < 65536 - maxPitch * RotationRate.Pitch) )
		{
			if (Rotation.Pitch < 32768) 
				Rot.Pitch = maxPitch * RotationRate.Pitch;
			else
				Rot.Pitch = 65536 - maxPitch * RotationRate.Pitch;
		}
		else
			Rot.Pitch = Rotation.Pitch;

		DeltaRot = (Pawn.Rotation - Rot);
		if( !bUpdating )
			Pawn.SetRotation(Rot);
	}
	
	ProcessMiniMoveEx( Move.MiniMove, DeltaRot );
}

//-----------------------------------------------------------------------------
// STATES
//-----------------------------------------------------------------------------

state @ PlayerWalkingState
{
	function ProcessMiniMoveEx( MiniMove Move, optional rotator DeltaRot )
	{
		if( Pawn == None )
			return;

		if( LeanTransition() )
			return;

		if( LeanDir == Lean_None )
		{
			if ( (Move.DodgeDir == DCLICK_Active) && (Pawn.Physics == PHYS_Falling) )
				Move.DodgeDir = DCLICK_Active;
			else if ( (Move.DodgeDir != DCLICK_None) && (Move.DodgeDir < DCLICK_Active) )
			{
				if( U2Pawn(Pawn) != None && CanDodge() )
				{
					U2Pawn(Pawn).Dodge( Move.DodgeDir, true );
					Move.DodgeDir = DCLICK_Active;
				}
			}
		}

		SetMovementVars( Move.Accel );
		Global.ProcessMiniMoveEx( Move, DeltaRot );

		if ( bPressedJump && Level != None && Level.Pauser == None )
		{
			if( InLeanMode() )
				LeanEnd();
			Pawn.DoJump( bUpdating );
		}
		
		Pawn.CheckStanceStatus();
	}
} // PlayerWalkingState

//-----------------------------------------------------------------------------

state @ PlayerClimbingState
{
	function ProcessMiniMoveEx( MiniMove Move, optional rotator DeltaRot )
	{
		if( LeanTransition() )
			return;

		SetMovementVars(Move.Accel);
		Global.ProcessMiniMoveEx(Move, DeltaRot);
	}
} // PlayerClimbingState

//-----------------------------------------------------------------------------

state @ MantlingState
{
	ignores Fire, AltFire, PressingFire, PressingAltFire;
	
	function ProcessMiniMoveEx( MiniMove Move, optional rotator DeltaRot )
	{
		local vector OldAccel;
		local vector MantleDir;

		//hack so no acceleration is used for physics (it used to use vect(0,0,1) which was useless, physics wise)
		//still want to keep the acceleration tho, so that the server GetMovement func 
		//can correctly determine bForwardPressed, to determine if mantling is still needed
		if( LPawn != None )
		{
			SetMovementVars(Move.Accel);
			OldAccel = Move.Accel;
			Move.Accel = vect(0,0,0);

			if( LPawn.Location.Z < LPawn.MantleDestination.Z )
				LPawn.Velocity = vect(0,0,1) * LPawn.MantleSpeed; // move up to clear ledge
			else
			{
				MantleDir = LPawn.MantleDestination - LPawn.Location;
				LPawn.Velocity = Normal(MantleDir) * LPawn.MantleSpeed; // move toward mantle destination
			}

			Global.ProcessMiniMoveEx( Move, DeltaRot );
	
			Move.Accel = OldAccel;
		}
	}
} // MantlingState

//-----------------------------------------------------------------------------

state @ PlayerSpideringState
{
	function ProcessMiniMoveEx( MiniMove Move, optional rotator DeltaRot )
	{
		SetMovementVars(Move.Accel);

		Global.ProcessMiniMoveEx(Move);

		if ( bPressedJump && Level.Pauser == None )
		{
			if( InLeanMode() )
				LeanEnd();
			Pawn.DoJump(bUpdating);
		}
		
		Pawn.CheckStanceStatus();
	}
} // PlayerSpideringState

//-----------------------------------------------------------------------------

state @ PlayerSwimmingState
{
	function ProcessMiniMoveEx( MiniMove Move, optional rotator DeltaRot )
	{
		if( LeanTransition() )
			return;

		SetMovementVars(Move.Accel);
		
		//!!MJL (mdf) Pawn.bUpAndOut = (bForwardPressed && (bUpPressed || Rotation.Pitch > 2048));
		Pawn.bUpAndOut = (bUpPressed || Rotation.Pitch > 2048);

		if ( !Pawn.PhysicsVolume.bWaterVolume ) //check for waterjump
			NotifyPhysicsVolumeChange(Pawn.PhysicsVolume);
		Global.ProcessMiniMoveEx( Move, DeltaRot );
	}
} // PlayerSwimmingState

//-----------------------------------------------------------------------------

state @ SpectatingState
{
	function ProcessMiniMoveEx( MiniMove Move, optional rotator DeltaRot )
	{
		Acceleration = Move.Accel;
		MoveSmooth(Move.Accel * Move.ElapsedTime);
	}
} // SpectatingState

//-----------------------------------------------------------------------------

auto state @ PlayerWaitingState
{
	function ProcessMiniMoveEx( MiniMove Move, optional rotator DeltaRot )
	{
		Acceleration = Move.Accel;
		MoveSmooth(Move.Accel * Move.ElapsedTime);
	}
} // PlayerWaitingState

//-----------------------------------------------------------------------------

state @ WaitingForPawnState
{
	function ProcessMiniMoveEx( MiniMove Move, optional rotator DeltaRot )
	{
		Acceleration = Move.Accel;
		MoveSmooth(Move.Accel * Move.ElapsedTime);
	}
} // WaitingForPawnState

//-----------------------------------------------------------------------------

state @ TeleportFixedState
{
	function ProcessMiniMoveEx( MiniMove Move, optional rotator DeltaRot )
	{
	}
} // TeleportFixedState

//-----------------------------------------------------------------------------

defaultproperties
{
     DeathMusic(0)="DEATH_1.ogg"
     DeathMusic(1)="DEATH_2.ogg"
     DeathMusic(2)="DEATH_3.ogg"
     DeathMusic(3)="DEATH_4.ogg"
     ExecManagerClasses(0)=Class'U2.CheatManager'
     ExecManagerClasses(1)=Class'U2.AdminManager'
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}